diff --git a/AtalaPrismSDK/Apollo/Sources/ApolloImpl+Public.swift b/AtalaPrismSDK/Apollo/Sources/ApolloImpl+Public.swift index 07631178..d7bbc0b0 100644 --- a/AtalaPrismSDK/Apollo/Sources/ApolloImpl+Public.swift +++ b/AtalaPrismSDK/Apollo/Sources/ApolloImpl+Public.swift @@ -42,7 +42,7 @@ returns random mnemonics nerver returns invalid mnemonics /// - seed: A seed object used to generate the key pair /// - curve: The key curve to use for generating the key pair /// - Returns: A key pair object containing a private and public key - public func createKeyPair(seed: Seed, curve: KeyCurve) -> KeyPair { + public func createKeyPair(seed: Seed, curve: KeyCurve) throws -> KeyPair { switch curve { case .x25519: return CreateX25519KeyPairOperation(logger: ApolloImpl.logger) @@ -51,7 +51,7 @@ returns random mnemonics nerver returns invalid mnemonics return CreateEd25519KeyPairOperation(logger: ApolloImpl.logger) .compute() case let .secp256k1(index): - return CreateSec256k1KeyPairOperation( + return try CreateSec256k1KeyPairOperation( logger: ApolloImpl.logger, seed: seed, keyPath: .init(index: index) @@ -69,7 +69,7 @@ returns random mnemonics nerver returns invalid mnemonics public func createKeyPair(seed: Seed, privateKey: PrivateKey) throws -> KeyPair { switch privateKey.curve { case .secp256k1: - return createKeyPair(seed: seed, curve: privateKey.curve) + return try createKeyPair(seed: seed, curve: privateKey.curve) case .x25519: return try CreateX25519KeyPairOperation(logger: ApolloImpl.logger) .compute(fromPrivateKey: privateKey) @@ -84,15 +84,25 @@ returns random mnemonics nerver returns invalid mnemonics /// - Parameter publicKey: The public key to compress /// - Returns: The compressed public key public func compressedPublicKey(publicKey: PublicKey) -> CompressedPublicKey { - publicKey.compressed() + CompressedPublicKey( + uncompressed: publicKey, + value: LockPublicKey( + bytes: publicKey.value + ).compressedPublicKey().data + ) } /// compressedPublicKey decompresses a given compressed public key into its original form. /// /// - Parameter compressedData: The compressed public key data /// - Returns: The decompressed public key - public func compressedPublicKey(compressedData: Data) -> CompressedPublicKey { - CompressedPublicKey(compressedData: compressedData) + public func uncompressedPublicKey(compressedData: Data) -> PublicKey { + PublicKey( + curve: KeyCurve.secp256k1().name, + value: LockPublicKey( + bytes: compressedData + ).uncompressedPublicKey().data + ) } /// signMessage signs a message using a given private key, returning the signature. @@ -101,8 +111,8 @@ returns random mnemonics nerver returns invalid mnemonics /// - privateKey: The private key to use for signing the message /// - message: The message to sign, in binary data form /// - Returns: The signature of the message - public func signMessage(privateKey: PrivateKey, message: Data) -> Signature { - return SignMessageOperation( + public func signMessage(privateKey: PrivateKey, message: Data) throws -> Signature { + return try SignMessageOperation( logger: ApolloImpl.logger, privateKey: privateKey, message: message @@ -118,7 +128,7 @@ returns random mnemonics nerver returns invalid mnemonics /// - Throws: An error if the message is invalid public func signMessage(privateKey: PrivateKey, message: String) throws -> Signature { guard let data = message.data(using: .utf8) else { throw ApolloError.couldNotParseMessageString } - return signMessage(privateKey: privateKey, message: data) + return try signMessage(privateKey: privateKey, message: data) } /// verifySignature verifies the authenticity of a signature using the corresponding public key, challenge, and signature. This function returns a boolean value indicating whether the signature is valid or not. @@ -128,8 +138,12 @@ returns random mnemonics nerver returns invalid mnemonics /// - challenge: The challenge used to generate the signature /// - signature: The signature to verify /// - Returns: A boolean value indicating whether the signature is valid or not - public func verifySignature(publicKey: PublicKey, challenge: Data, signature: Signature) -> Bool { - return VerifySignatureOperation( + public func verifySignature( + publicKey: PublicKey, + challenge: Data, + signature: Signature + ) throws -> Bool { + return try VerifySignatureOperation( logger: ApolloImpl.logger, publicKey: publicKey, challenge: challenge, diff --git a/AtalaPrismSDK/Apollo/Sources/BIPs/BIP32_44/HDKey.swift b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP32_44/HDKey.swift new file mode 100644 index 00000000..d6561424 --- /dev/null +++ b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP32_44/HDKey.swift @@ -0,0 +1,101 @@ +// +// BitcoinKitPrivateSwift.swift +// +// Copyright © 2019 BitcoinKit developers +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// +// Modified by Gonçalo Frade on 07/03/2023 +// +// Changes made: +// - Moved to a file of its own +// - Removed Fingerprints and Network +// - Removed Public + +import CryptoKit +import Foundation +import secp256k1 + +class HDKey { + private(set) var privateKey: Data? + private(set) var publicKey: Data + private(set) var chainCode: Data + private(set) var depth: UInt8 + private(set) var childIndex: UInt32 + + init(privateKey: Data?, publicKey: Data, chainCode: Data, depth: UInt8, childIndex: UInt32) { + self.privateKey = privateKey + self.publicKey = publicKey + self.chainCode = chainCode + self.depth = depth + self.childIndex = childIndex + } + + func derived(at childIndex: UInt32, hardened: Bool) -> HDKey? { + var data = Data() + if hardened { + data.append(0) + guard let privateKey = self.privateKey else { + return nil + } + data.append(privateKey) + } else { + data.append(publicKey) + } + var childIndex = CFSwapInt32HostToBig(hardened ? (0x80000000 as UInt32) | childIndex : childIndex) + data.append(Data(bytes: &childIndex, count: MemoryLayout.size)) + let hmac = HMAC.authenticationCode(for: data, using: .init(data: self.chainCode)) + let digest = Data(hmac) + let derivedPrivateKey: [UInt8] = digest[0..<32].map { $0 } + let derivedChainCode: [UInt8] = digest[32..<64].map { $0 } + var result: Data + if let privateKey = self.privateKey { + guard let ctx = secp256k1_context_create(UInt32(SECP256K1_CONTEXT_SIGN)) else { + return nil + } + defer { secp256k1_context_destroy(ctx) } + var privateKeyBytes = privateKey.map { $0 } + var derivedPrivateKeyBytes = derivedPrivateKey.map { $0 } + if secp256k1_ec_seckey_tweak_add(ctx, &privateKeyBytes, &derivedPrivateKeyBytes) == 0 { + return nil + } + result = Data(privateKeyBytes) + } else { + guard let ctx = secp256k1_context_create(UInt32(SECP256K1_CONTEXT_VERIFY)) else { + return nil + } + defer { secp256k1_context_destroy(ctx) } + let publicKeyBytes: [UInt8] = publicKey.map { $0 } + var secpPubkey = secp256k1_pubkey() + if secp256k1_ec_pubkey_parse(ctx, &secpPubkey, publicKeyBytes, publicKeyBytes.count) == 0 { + return nil + } + if secp256k1_ec_pubkey_tweak_add(ctx, &secpPubkey, derivedPrivateKey) == 0 { + return nil + } + var compressedPublicKeyBytes = [UInt8](repeating: 0, count: 33) + var compressedPublicKeyBytesLen = 33 + if secp256k1_ec_pubkey_serialize(ctx, &compressedPublicKeyBytes, &compressedPublicKeyBytesLen, &secpPubkey, UInt32(SECP256K1_EC_COMPRESSED)) == 0 { + return nil + } + result = Data(compressedPublicKeyBytes) + } + return HDKey(privateKey: result, publicKey: result, chainCode: Data(derivedChainCode), depth: self.depth + 1, childIndex: childIndex) + } +} diff --git a/AtalaPrismSDK/Apollo/Sources/BIPs/BIP32_44/HDKeychain.swift b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP32_44/HDKeychain.swift new file mode 100644 index 00000000..53e2e58b --- /dev/null +++ b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP32_44/HDKeychain.swift @@ -0,0 +1,90 @@ +// +// HDKeychain.swift +// +// Copyright © 2018 Kishikawa Katsumi +// Copyright © 2018 BitcoinKit developers +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// +// Modified by Gonçalo Frade on 07/03/2023 +// +// Changes made: +// - Using CryptoKit now +// - Changed to a struct instead of a class +// - Removed Fingerprints and Network +// - Removed Public + +import CryptoKit +import Foundation +import secp256k1 + +struct HDKeychain { + private let rootKey: HDPrivateKey + + init(rootKey: HDPrivateKey) { + self.rootKey = rootKey + } + + init(seed: Data) { + self.init(rootKey: HDPrivateKey(seed: seed)) + } + /// Parses the BIP32 path and derives the chain of keychains accordingly. + /// Path syntax: (m?/)?([0-9]+'?(/[0-9]+'?)*)? + /// The following paths are valid: + /// + /// "" (root key) + /// "m" (root key) + /// "/" (root key) + /// "m/0'" (hardened child #0 of the root key) + /// "/0'" (hardened child #0 of the root key) + /// "0'" (hardened child #0 of the root key) + /// "m/44'/1'/2'" (BIP44 testnet account #2) + /// "/44'/1'/2'" (BIP44 testnet account #2) + /// "44'/1'/2'" (BIP44 testnet account #2) + /// + /// The following paths are invalid: + /// + /// "m / 0 / 1" (contains spaces) + /// "m/b/c" (alphabetical characters instead of numerical indexes) + /// "m/1.2^3" (contains illegal characters) + func derivedKey(path: String) throws -> HDPrivateKey { + var key = rootKey + + var path = path + if path == "m" || path == "/" || path == "" { + return key + } + if path.contains("m/") { + path = String(path.dropFirst(2)) + } + for chunk in path.split(separator: "/") { + var hardened = false + var indexText = chunk + if chunk.contains("'") { + hardened = true + indexText = indexText.dropLast() + } + guard let index = UInt32(indexText) else { + fatalError("invalid path") + } + key = try key.derived(at: index, hardened: hardened) + } + return key + } +} diff --git a/AtalaPrismSDK/Apollo/Sources/BIPs/BIP32_44/HDPrivateKey.swift b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP32_44/HDPrivateKey.swift new file mode 100644 index 00000000..dbc0b733 --- /dev/null +++ b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP32_44/HDPrivateKey.swift @@ -0,0 +1,94 @@ +// +// DeterministicKey.swift +// +// Copyright © 2018 Kishikawa Katsumi +// Copyright © 2018 BitcoinKit developers +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// +// Modified by Gonçalo Frade on 07/03/2023 +// +// Changes made: +// - Using CryptoKit now +// - Changed to a struct instead of a class +// - Removed Fingerprints and Network +// - Removed public + +import CryptoKit +import Foundation +import secp256k1 + +struct HDPrivateKey { + let depth: UInt8 + let childIndex: UInt32 + + let raw: Data + let chainCode: Data + + init(privateKey: Data, chainCode: Data) { + self.raw = privateKey + self.chainCode = chainCode + self.depth = 0 + self.childIndex = 0 + } + + init(seed: Data) { + let hmac = HMAC.authenticationCode(for: seed, using: .init(data: "Bitcoin seed".data(using: .ascii)!)) + let hmacData = Data(hmac) +// let hmac = Crypto.hmacsha512(data: seed, key: "Bitcoin seed".data(using: .ascii)!) + let privateKey = hmacData[0..<32] + let chainCode = hmacData[32..<64] + self.init(privateKey: privateKey, chainCode: chainCode) + } + + init(privateKey: Data, chainCode: Data, depth: UInt8, childIndex: UInt32) { + self.raw = privateKey + self.chainCode = chainCode + self.depth = depth + self.childIndex = childIndex + } + + func privateKey() -> LockPrivateKey { + return LockPrivateKey(data: raw, isPublicKeyCompressed: true) + } + + func extendedPublicKey() -> HDPublicKey { + return HDPublicKey(raw: computePublicKeyData(), chainCode: chainCode, depth: depth, childIndex: childIndex) + } + + private func computePublicKeyData() -> Data { + return KeyHelpers.computePublicKey(fromPrivateKey: raw, compression: false) + } + + func derived(at index: UInt32, hardened: Bool = false) throws -> HDPrivateKey { + // As we use explicit parameter "hardened", do not allow higher bit set. + if (0x80000000 & index) != 0 { + fatalError("invalid child index") + } + + guard let derivedKey = HDKey(privateKey: raw, publicKey: extendedPublicKey().raw, chainCode: chainCode, depth: depth, childIndex: childIndex).derived(at: index, hardened: hardened) else { + throw DerivationError.derivationFailed + } + return HDPrivateKey(privateKey: derivedKey.privateKey!, chainCode: derivedKey.chainCode, depth: derivedKey.depth, childIndex: derivedKey.childIndex) + } +} + +enum DerivationError: Error { + case derivationFailed +} diff --git a/AtalaPrismSDK/Apollo/Sources/BIPs/BIP32_44/HDPublicKey.swift b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP32_44/HDPublicKey.swift new file mode 100644 index 00000000..cee47169 --- /dev/null +++ b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP32_44/HDPublicKey.swift @@ -0,0 +1,63 @@ +// +// HDPublicKey.swift +// +// Copyright © 2018 Kishikawa Katsumi +// Copyright © 2018 BitcoinKit developers +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// +// Modified by Gonçalo Frade on 07/03/2023 +// +// Changes made: +// - Using CryptoKit now +// - Changed to a struct instead of a class +// - Removed Fingerprints and Network +// - Removed public + +import Foundation + +struct HDPublicKey { + let depth: UInt8 + let childIndex: UInt32 + + let raw: Data + let chainCode: Data + + init(raw: Data, chainCode: Data, depth: UInt8, childIndex: UInt32) { + self.raw = raw + self.chainCode = chainCode + self.depth = depth + self.childIndex = childIndex + } + + func publicKey() -> LockPublicKey { + return LockPublicKey(bytes: raw) + } + + func derived(at index: UInt32) throws -> HDPublicKey { + // As we use explicit parameter "hardened", do not allow higher bit set. + if (0x80000000 & index) != 0 { + fatalError("invalid child index") + } + guard let derivedKey = HDKey(privateKey: nil, publicKey: raw, chainCode: chainCode, depth: depth, childIndex: childIndex).derived(at: index, hardened: false) else { + throw DerivationError.derivationFailed + } + return HDPublicKey(raw: derivedKey.publicKey, chainCode: derivedKey.chainCode, depth: derivedKey.depth, childIndex: derivedKey.childIndex) + } +} diff --git a/AtalaPrismSDK/Apollo/Sources/BIPs/BIP32_44/KeyHelpers.swift b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP32_44/KeyHelpers.swift new file mode 100644 index 00000000..a067f977 --- /dev/null +++ b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP32_44/KeyHelpers.swift @@ -0,0 +1,105 @@ +import Foundation +import secp256k1 + +struct KeyHelpers { + static func computePublicKey(fromPrivateKey privateKey: Data, compression: Bool) -> Data { + guard let ctx = secp256k1_context_create(UInt32(SECP256K1_CONTEXT_SIGN)) else { + return Data() + } + defer { secp256k1_context_destroy(ctx) } + var pubkey = secp256k1_pubkey() + var seckey: [UInt8] = privateKey.map { $0 } + if seckey.count != 32 { + return Data() + } + if secp256k1_ec_pubkey_create(ctx, &pubkey, &seckey) == 0 { + return Data() + } + if compression { + var serializedPubkey = [UInt8](repeating: 0, count: 33) + var outputlen = 33 + if secp256k1_ec_pubkey_serialize(ctx, &serializedPubkey, &outputlen, &pubkey, UInt32(SECP256K1_EC_COMPRESSED)) == 0 { + return Data() + } + if outputlen != 33 { + return Data() + } + return Data(serializedPubkey) + } else { + var serializedPubkey = [UInt8](repeating: 0, count: 65) + var outputlen = 65 + if secp256k1_ec_pubkey_serialize(ctx, &serializedPubkey, &outputlen, &pubkey, UInt32(SECP256K1_EC_UNCOMPRESSED)) == 0 { + return Data() + } + if outputlen != 65 { + return Data() + } + return Data(serializedPubkey) + } + } + + static func compressPublicKey(fromPublicKey publicKey: Data) -> Data { + guard let ctx = secp256k1_context_create(UInt32(SECP256K1_CONTEXT_SIGN)) else { + return Data() + } + defer { secp256k1_context_destroy(ctx) } + var pubkey = secp256k1_pubkey() + var input: [UInt8] = publicKey.map { $0 } + if secp256k1_ec_pubkey_parse(ctx, &pubkey, &input, input.count) == 0 { + return Data() + } + var serializedPubkey = [UInt8](repeating: 0, count: 33) + var outputlen = 33 + if secp256k1_ec_pubkey_serialize(ctx, &serializedPubkey, &outputlen, &pubkey, UInt32(SECP256K1_EC_COMPRESSED)) == 0 { + return Data() + } + if outputlen != 33 { + return Data() + } + return Data(serializedPubkey) + } + + static func uncompressPublicKey(fromPublicKey publicKey: Data) -> Data { + guard let ctx = secp256k1_context_create(UInt32(SECP256K1_CONTEXT_SIGN)) else { + return Data() + } + defer { secp256k1_context_destroy(ctx) } + var pubkey = secp256k1_pubkey() + var input: [UInt8] = publicKey.map { $0 } + if secp256k1_ec_pubkey_parse(ctx, &pubkey, &input, input.count) == 0 { + return Data() + } + var serializedPubkey = [UInt8](repeating: 0, count: 65) + var outputlen = 65 + if secp256k1_ec_pubkey_serialize(ctx, &serializedPubkey, &outputlen, &pubkey, UInt32(SECP256K1_EC_UNCOMPRESSED)) == 0 { + return Data() + } + if outputlen != 65 { + return Data() + } + return Data(serializedPubkey) + } + +// if compression { +// var serializedPubkey = [UInt8](repeating: 0, count: 33) +// var outputlen = 33 +// if secp256k1_ec_pubkey_serialize(ctx, &serializedPubkey, &outputlen, &pubkey, UInt32(SECP256K1_EC_COMPRESSED)) == 0 { +// return Data() +// } +// if outputlen != 33 { +// return Data() +// } +// return Data(serializedPubkey) +// } else { +// var serializedPubkey = [UInt8](repeating: 0, count: 65) +// var outputlen = 65 +// if secp256k1_ec_pubkey_serialize(ctx, &serializedPubkey, &outputlen, &pubkey, UInt32(SECP256K1_EC_UNCOMPRESSED)) == 0 { +// return Data() +// } +// if outputlen != 65 { +// return Data() +// } +// return Data(serializedPubkey) +// } +// } +} diff --git a/AtalaPrismSDK/Apollo/Sources/BIPs/BIP32_44/LockPrivateKey.swift b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP32_44/LockPrivateKey.swift new file mode 100644 index 00000000..452f51ad --- /dev/null +++ b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP32_44/LockPrivateKey.swift @@ -0,0 +1,113 @@ +// +// PrivateKey.swift +// +// Copyright © 2018 Kishikawa Katsumi +// Copyright © 2018 BitcoinKit developers +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// +// Modified by Gonçalo Frade on 07/03/2023 +// +// Changes made: +// - Removed Fingerprints and Network +// - Remove the public +// - Changed name +// - Removed wif + +import Foundation + +struct LockPrivateKey { + let data: Data + let isPublicKeyCompressed: Bool + + init(isPublicKeyCompressed: Bool = true) { + self.isPublicKeyCompressed = isPublicKeyCompressed + + // Check if vch is greater than or equal to max value + func check(_ vch: [UInt8]) -> Bool { + let max: [UInt8] = [ + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, + 0xBA, 0xAE, 0xDC, 0xE6, 0xAF, 0x48, 0xA0, 0x3B, + 0xBF, 0xD2, 0x5E, 0x8C, 0xD0, 0x36, 0x41, 0x40 + ] + var fIsZero = true + for byte in vch where byte != 0 { + fIsZero = false + break + } + if fIsZero { + return false + } + for (index, byte) in vch.enumerated() { + if byte < max[index] { + return true + } + if byte > max[index] { + return false + } + } + return true + } + + let count = 32 + var key = Data(count: count) + var status: Int32 = 0 + repeat { + status = key.withUnsafeMutableBytes { SecRandomCopyBytes(kSecRandomDefault, count, $0.baseAddress.unsafelyUnwrapped) } + } while (status != 0 || !check([UInt8](key))) + + self.data = key + } + + init(data: Data, isPublicKeyCompressed: Bool = true) { + self.data = data + self.isPublicKeyCompressed = isPublicKeyCompressed + } + + private func computePublicKeyData() -> Data { + return KeyHelpers.computePublicKey(fromPrivateKey: data, compression: isPublicKeyCompressed) + } + + func publicKeyPoint() throws -> PointOnCurve { + let xAndY: Data = KeyHelpers.computePublicKey(fromPrivateKey: data, compression: false) + let expectedLengthOfScalar = Scalar32Bytes.expectedByteCount + let expectedLengthOfKey = expectedLengthOfScalar * 2 + guard xAndY.count == expectedLengthOfKey else { + fatalError("expected length of key is \(expectedLengthOfKey) bytes, but got: \(xAndY.count)") + } + let x = xAndY.prefix(expectedLengthOfScalar) + let y = xAndY.suffix(expectedLengthOfScalar) + return try PointOnCurve(x: x, y: y) + } + + func publicKey() -> LockPublicKey { + return LockPublicKey(bytes: computePublicKeyData()) + } +} + +extension LockPrivateKey: Equatable { + public static func == (lhs: LockPrivateKey, rhs: LockPrivateKey) -> Bool { + return lhs.data == rhs.data + } +} + +enum PrivateKeyError: Error { + case invalidFormat +} diff --git a/AtalaPrismSDK/Apollo/Sources/BIPs/BIP32_44/LockPublicKey.swift b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP32_44/LockPublicKey.swift new file mode 100644 index 00000000..66347a77 --- /dev/null +++ b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP32_44/LockPublicKey.swift @@ -0,0 +1,63 @@ +// +// PublicKey.swift +// +// Copyright © 2018 Kishikawa Katsumi +// Copyright © 2018 BitcoinKit developers +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// +// Modified by Gonçalo Frade on 07/03/2023 +// +// Changes made: +// - Removed Fingerprints and Network +// - Remove the public +// - Changed name + +import Foundation + +struct LockPublicKey { + let data: Data + let isCompressed: Bool + + init(bytes data: Data) { + self.data = data + let header = data[0] + self.isCompressed = (header == 0x02 || header == 0x03) + } + + func compressedPublicKey() -> LockPublicKey { + LockPublicKey(bytes: KeyHelpers.compressPublicKey(fromPublicKey: data)) + } + + func uncompressedPublicKey() -> LockPublicKey { + LockPublicKey(bytes: KeyHelpers.uncompressPublicKey(fromPublicKey: data)) + } +} + +extension LockPublicKey: Equatable { + static func == (lhs: LockPublicKey, rhs: LockPublicKey) -> Bool { + return lhs.data == rhs.data + } +} + +extension LockPublicKey: CustomStringConvertible { + var description: String { + return data.base64UrlEncodedString() + } +} diff --git a/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/BitArray.swift b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/BitArray.swift new file mode 100644 index 00000000..afe2a041 --- /dev/null +++ b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/BitArray.swift @@ -0,0 +1,363 @@ +// +// BitArray.swift +// +// Created by Mauricio Santos on 2/23/15. +// Modified by BitcoinKit developers +// +// Github: https://github.com/mauriciosantos/Buckets-Swift/blob/master/Source/BitArray.swift +// +// Copyright (c) 2015 Mauricio Santos +// +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// + +import Foundation + +/// An array of boolean values stored +/// using individual bits, thus providing a +/// very small memory footprint. It has most of the features of a +/// standard array such as constant time random access and +/// amortized constant time insertion at the end of the array. +/// +/// Conforms to `MutableCollection`, `RangeReplaceableCollection`, `ExpressibleByArrayLiteral` +/// , `Equatable`, `Hashable`, `CustomStringConvertible` + +struct BitArray: Hashable, RangeReplaceableCollection { + + // MARK: Creating a BitArray + + /// Constructs an empty bit array. + init() {} + + /// Constructs a bit array from a `Bool` sequence, such as an array. + init(_ elements: S) where S.Iterator.Element == Bool { + for value in elements { + append(value) + } + } + + init(data: Data) { + guard let viaBitstring = BitArray(binaryString: data.binaryString) else { + fatalError("should always be able to init from data, incorrect implementation of either Data.binaryString or `Self.init(binaryString:)`") + } + + assert(viaBitstring.asData() == data, "assert correctness of conversion") + + self = viaBitstring + } + + /// A non-optimized initializer taking a binary String, if the string passed contains any other characters than '0' or '1' then the init will fail (return nil) + init?(binaryString: S) where S: StringProtocol { + let mapped: [Bool] = binaryString.compactMap { + if $0 == "1" { + return true + } else if $0 == "0" { + return false + } else { + fatalError("bad char: \($0)") + } + } + self.init(mapped) + } + + /// A non-optimized initializer taking an array of `UInt11` + init(_ elements: S) where S: Sequence, S.Iterator.Element == UInt11 { + let binaryString: String = elements.map { $0.binaryString }.joined() + guard let bitArray = BitArray(binaryString: binaryString) else { fatalError("Should always be able to create BitArray from [UInt11] binaryString: '\(binaryString)'") } + self = bitArray + } + + /// Constructs a new bit array from an `Int` array representation. + /// All values different from 0 are considered `true`. + init(intRepresentation: [Int]) { + bits.reserveCapacity((intRepresentation.count / Constants.IntSize) + 1) + for value in intRepresentation { + append(value != 0) + } + } + + /// Constructs a new bit array with `count` bits set to the specified value. + init(repeating repeatedValue: Bool, count: Int) { + precondition(!isEmpty, "Can't construct BitArray with count < 0") + + let numberOfInts = (count / Constants.IntSize) + 1 + let intValue = repeatedValue ? ~0 : 0 + bits = [Int](repeating: intValue, count: numberOfInts) + self.count = count + + if repeatedValue { + bits[bits.count - 1] = 0 + let missingBits = count % Constants.IntSize + self.count = count - missingBits + for _ in 0..= bits.count { + bits.append(0) + } + setValue(bit, atIndex: count) + count += 1 + } + + /// Inserts a bit into the array at a given index. + /// Use this method to insert a new bit anywhere within the range + /// of existing bits, or as the last bit. The index must be less + /// than or equal to the number of bits in the bit array. If you + /// attempt to remove a bit at a greater index, you’ll trigger an error. + mutating func insert(_ bit: Bool, at index: Int) { + checkIndex(index, lessThan: count + 1) + append(bit) + for i in stride(from: (count - 2), through: index, by: -1) { + let iBit = valueAtIndex(i) + setValue(iBit, atIndex: i + 1) + } + setValue(bit, atIndex: index) + + } + + /// Removes the last bit from the bit array and returns it. + /// + /// - returns: The last bit, or nil if the bit array is empty. + @discardableResult + mutating func removeLast() -> Bool { + if let value = last { + setValue(false, atIndex: count - 1) + count -= 1 + return value + } + preconditionFailure("Array is empty") + } + + /// Removes the bit at the given index and returns it. + /// The index must be less than the number of bits in the + /// bit array. If you attempt to remove a bit at a + /// greater index, you’ll trigger an error. + @discardableResult + mutating func remove(at index: Int) -> Bool { + checkIndex(index) + let bit = valueAtIndex(index) + + for i in (index + 1)..( + _ subrange: Range, with newElements: C + ) where C : Collection, C.Element == Bool { + let start = Swift.max(0, subrange.lowerBound) + let end = Swift.min(count, subrange.upperBound) + let newBits = BitArray(newElements) + let newCount = count - (end - start) + newBits.count + bits.withUnsafeMutableBufferPointer { buffer in + let ptr = UnsafeMutableRawPointer(buffer.baseAddress!).assumingMemoryBound(to: UInt8.self) + let newPtr = UnsafeRawPointer(newBits.bits).assumingMemoryBound(to: UInt8.self) + memmove(ptr + start / Constants.IntSize * MemoryLayout.stride, newPtr, newBits.bits.count * MemoryLayout.stride) + count = newCount + cardinality = -1 // Force a recalculation of the cardinality on next access + } + } + + // MARK: Private Properties and Helper Methods + + /// Structure holding the bits. + fileprivate var bits = [Int]() + + fileprivate func valueAtIndex(_ logicalIndex: Int) -> Bool { + let indexPath = realIndexPath(logicalIndex) + var mask = 1 << indexPath.bitIndex + mask = mask & bits[indexPath.arrayIndex] + return mask != 0 + } + + fileprivate mutating func setValue(_ newValue: Bool, atIndex logicalIndex: Int) { + let indexPath = realIndexPath(logicalIndex) + let mask = 1 << indexPath.bitIndex + let oldValue = mask & bits[indexPath.arrayIndex] != 0 + + switch (oldValue, newValue) { + case (false, true): + cardinality += 1 + case (true, false): + cardinality -= 1 + default: + break + } + + if newValue { + bits[indexPath.arrayIndex] |= mask + } else { + bits[indexPath.arrayIndex] &= ~mask + } + } + + fileprivate func realIndexPath(_ logicalIndex: Int) -> (arrayIndex: Int, bitIndex: Int) { + return (logicalIndex / Constants.IntSize, logicalIndex % Constants.IntSize) + } + + fileprivate func checkIndex(_ index: Int, lessThan: Int? = nil) { + let bound = lessThan == nil ? count : lessThan + precondition(!isEmpty && index < bound!, "Index out of range (\(index))") + } + + // MARK: Constants + + fileprivate struct Constants { + // Int size in bits + static let IntSize = MemoryLayout.size * 8 + } +} + +extension BitArray: MutableCollection { + + // MARK: MutableCollection Protocol Conformance + + /// Always zero, which is the index of the first bit when non-empty. + var startIndex: Int { + return 0 + } + + /// Always `count`, which the successor of the last valid + /// subscript argument. + var endIndex: Int { + return count + } + + /// Returns the position immediately after the given index. + /// + /// - Parameter i: A valid index of the collection. `i` must be less than + /// `endIndex`. + /// - Returns: The index value immediately after `i`. + func index(after i: Int) -> Int { + return i + 1 + } + + /// Provides random access to individual bits using square bracket noation. + /// The index must be less than the number of items in the bit array. + /// If you attempt to get or set a bit at a greater + /// index, you’ll trigger an error. + subscript(index: Int) -> Bool { + get { + checkIndex(index) + return valueAtIndex(index) + } + set { + checkIndex(index) + setValue(newValue, atIndex: index) + } + } +} + +extension BitArray: ExpressibleByArrayLiteral { + + // MARK: ExpressibleByArrayLiteral Protocol Conformance + + /// Constructs a bit array using a `Bool` array literal. + /// `let example: BitArray = [true, false, true]` + init(arrayLiteral elements: Bool...) { + bits.reserveCapacity((elements.count / Constants.IntSize) + 1) + for element in elements { + append(element) + } + } +} + +extension BitArray: CustomStringConvertible { + + // MARK: CustomStringConvertible Protocol Conformance + + /// A string containing a suitable textual + /// representation of the bit array. + var description: String { return binaryString } + var binaryString: String { return map { "\($0 == true ? 1 : 0)" }.joined() } +} + +/// Returns `true` if and only if the bit arrays contain the same bits in the same order. +func == (lhs: BitArray, rhs: BitArray) -> Bool { + if lhs.count != rhs.count || lhs.cardinality != rhs.cardinality { + return false + } + return lhs.elementsEqual(rhs) +} + +extension BitArray { + func asBoolArray() -> [Bool] { + return self.map { $0 } + } + + // https://stackoverflow.com/a/28930093/1311272 + func asBytesArray() -> [UInt8] { + let numBits = self.count + let numBytes = (numBits + 7) / 8 + var bytes = [UInt8](repeating: 0, count: numBytes) + + for (index, bit) in self.enumerated() where bit == true { + bytes[index / 8] += UInt8(1 << (7 - index % 8)) + } + + return bytes + } + + func asData() -> Data { + return Data(self.asBytesArray()) + } +} diff --git a/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/Mnemonic+Checksum+Validate.swift b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/Mnemonic+Checksum+Validate.swift new file mode 100644 index 00000000..7bf5282e --- /dev/null +++ b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/Mnemonic+Checksum+Validate.swift @@ -0,0 +1,99 @@ +// +// Mnemonic+Checksum+Validate.swift +// +// Copyright © 2018 BitcoinKit developers +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// +// Modified by Gonçalo Frade on 07/03/2023 +// +// Changes made: +// - Using CryptoKit +// - Removed Public + +import CryptoKit +import Foundation + +extension Mnemonic { + + static func deriveLanguageFromMnemonic(words: [String]) -> Language? { + func tryLangauge( + _ language: Language + ) -> Language? { + let vocabulary = Set(wordList(for: language)) + let wordsLeftToCheck = Set(words) + + guard wordsLeftToCheck.intersection(vocabulary) == wordsLeftToCheck else { + return nil + } + + return language + } + + for langauge in Language.allCases { + guard let derived = tryLangauge(langauge) else { continue } + return derived + } + return nil + } + + @discardableResult + static func validateChecksumDerivingLanguageOf(mnemonic mnemonicWords: [String]) throws -> Bool { + guard let derivedLanguage = deriveLanguageFromMnemonic(words: mnemonicWords) else { + throw MnemonicError.validationError(.unableToDeriveLanguageFrom(words: mnemonicWords)) + } + return try validateChecksumOf(mnemonic: mnemonicWords, language: derivedLanguage) + } + + // https://github.com/mcdallas/cryptotools/blob/master/btctools/HD/__init__.py#L27-L41 + // alternative in C: + // https://github.com/trezor/trezor-crypto/blob/0c622d62e1f1e052c2292d39093222ce358ca7b0/bip39.c#L161-L179 + @discardableResult + static func validateChecksumOf(mnemonic mnemonicWords: [String], language: Language) throws -> Bool { + let vocabulary = wordList(for: language) + + let indices: [UInt11] = try mnemonicWords.map { word in + guard let indexInVocabulary = vocabulary.firstIndex(of: word) else { + throw MnemonicError.validationError(.wordNotInList(word, language: language)) + } + guard let indexAs11Bits = UInt11(exactly: indexInVocabulary) else { + fatalError("Unexpected error, is word list longer than 2048 words, it shold not be") + } + return indexAs11Bits + } + + let bitArray = BitArray(indices) + + let checksumLength = mnemonicWords.count / 3 + + let dataBits = bitArray.prefix(subtractFromCount: checksumLength) + let checksumBits = bitArray.suffix(maxCount: checksumLength) + + let hash = Data(SHA256.hash(data: dataBits.asData())) // Crypto.sha256(dataBits.asData()) + + let hashBits = BitArray(data: hash).prefix(maxCount: checksumLength) + + guard hashBits == checksumBits else { + throw MnemonicError.validationError(.checksumMismatch) + } + + // All is well + return true + } +} diff --git a/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/Mnemonic+Error.swift b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/Mnemonic+Error.swift new file mode 100644 index 00000000..bf7c7b80 --- /dev/null +++ b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/Mnemonic+Error.swift @@ -0,0 +1,44 @@ +// +// Mnemonic+Error.swift +// +// Copyright © 2018 BitcoinKit developers +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// + +import Foundation + +typealias MnemonicError = Mnemonic.Error + +extension Mnemonic { + enum Error: Swift.Error { + case randomBytesError + case unsupportedByteCountOfEntropy(got: Int) + indirect case validationError(ValidationError) + } +} + +extension Mnemonic.Error { + enum ValidationError: Swift.Error { + case badWordCount(expectedAnyOf: [Int], butGot: Int) + case wordNotInList(String, language: Mnemonic.Language) + case unableToDeriveLanguageFrom(words: [String]) + case checksumMismatch + } +} diff --git a/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/Mnemonic+Generate.swift b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/Mnemonic+Generate.swift new file mode 100644 index 00000000..6c65996b --- /dev/null +++ b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/Mnemonic+Generate.swift @@ -0,0 +1,110 @@ +// +// Mnemonic+Generate.swift +// +// Copyright © 2018 BitcoinKit developers +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// +// Modified by Gonçalo Frade on 07/03/2023 +// +// Changes made: +// - Using CryptoKit +// - Removed Public + +import Core +import CommonCrypto +import CryptoKit +import Foundation + +// MARK: Generate +extension Mnemonic { + static func generate(strength: Strength = .default, language: Language = .english) throws -> [String] { + let entropy = try securelyGenerateBytes(count: strength.byteCount) + return try generate(entropy: entropy, language: language) + } +} + +extension Mnemonic { + static func generate( + entropy: Data, + language: Language = .english + ) throws -> [String] { + + guard let strength = Mnemonic.Strength(byteCount: entropy.count) else { + throw Error.unsupportedByteCountOfEntropy(got: entropy.count) + } + + let words = wordList(for: language) + let hash = Data(SHA256.hash(data: entropy)) + + let checkSumBits = BitArray(data: hash).prefix(strength.checksumLengthInBits) + + let bits = BitArray(data: entropy) + checkSumBits + + let wordIndices = bits.splitIntoChunks(ofSize: Mnemonic.WordList.sizeLog2) + .map { UInt11(bitArray: $0)! } + .map { $0.asInt } + + let mnemonic = wordIndices.map { words[$0] } + + try validateChecksumOf(mnemonic: mnemonic, language: language) + return mnemonic + } +} + +// MARK: To Seed +extension Mnemonic { + /// Pass a trivial closure: `{ _ in }` to `validateChecksum` if you would like to opt-out of checksum validation. + static func seed( + mnemonic words: [String], + passphrase: String = "", + validateChecksum: (([String]) throws -> Void) = { try Mnemonic.validateChecksumDerivingLanguageOf(mnemonic: $0) } + ) throws -> Data { + try validateChecksum(words) + + let mnemonic = words.joined(separator: " ").decomposedStringWithCompatibilityMapping.data(using: .utf8)! + let salt = ("mnemonic" + passphrase).decomposedStringWithCompatibilityMapping.data(using: .utf8)! + let seed = try deriveSeedHmacAlgSha512(mnemonic, salt: salt, iterations: 2048, keyLength: 64) + return seed + } +} + +private func deriveSeedHmacAlgSha512(_ password: Data, salt: Data, iterations: Int = 2048, keyLength: Int = 64) throws -> Data { + var bytes = [UInt8](repeating: 0, count: keyLength) + + let status: Int32 = password.withUnsafeBytes { pptr in + let passwdPtr = pptr.bindMemory(to: CChar.self) + return CCKeyDerivationPBKDF( + CCPBKDFAlgorithm(kCCPBKDF2), + passwdPtr.baseAddress, + passwdPtr.count, + salt.bytes, + salt.count, + CCPBKDFAlgorithm(kCCPRFHmacAlgSHA512), + UInt32(iterations), + &bytes, + keyLength + ) + } + + guard status == kCCSuccess else { + throw Status(status: status) + } + return Data(bytes) +} diff --git a/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/Mnemonic+Language.swift b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/Mnemonic+Language.swift new file mode 100644 index 00000000..a045a4e2 --- /dev/null +++ b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/Mnemonic+Language.swift @@ -0,0 +1,40 @@ +// +// Mnemonic.swift +// +// Copyright © 2018 Kishikawa Katsumi +// Copyright © 2018 BitcoinKit developers +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// + +import Foundation +import CommonCrypto + +extension Mnemonic { + enum Language: String, CaseIterable { + case english + case japanese + case korean + case spanish + case simplifiedChinese + case traditionalChinese + case french + case italian + } +} diff --git a/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/Mnemonic+Strength.swift b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/Mnemonic+Strength.swift new file mode 100644 index 00000000..501dfaac --- /dev/null +++ b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/Mnemonic+Strength.swift @@ -0,0 +1,79 @@ +// +// Mnemonic+Strength.swift +// +// Copyright © 2018 BitcoinKit developers +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// + +import Foundation + +private let bitsPerByte = 8 + +// MARK: Strength +extension Mnemonic { + enum Strength: Int, CaseIterable { + case `default` = 128 + case low = 160 + case medium = 192 + case high = 224 + case veryHigh = 256 + } +} + +extension Mnemonic.Strength { + + /// `wordCount` must be divisible by `3`, else `nil` is returned + init?(wordCount: Int) { + guard wordCount % Mnemonic.Strength.checksumBitsPerWord == 0 else { return nil } + let entropyInBitsFromWordCount = (wordCount / Mnemonic.Strength.checksumBitsPerWord) * 32 + self.init(rawValue: entropyInBitsFromWordCount) + } + + init?(byteCount: Int) { + let bitCount = byteCount * bitsPerByte + guard + let strength = Mnemonic.Strength(rawValue: bitCount) + else { return nil } + self = strength + } +} + +// MARK: - Internal + +internal extension Mnemonic.Strength { + + static let checksumBitsPerWord = 3 + + var byteCount: Int { + return rawValue / bitsPerByte + } + + var wordCount: Int { + return Mnemonic.Strength.wordCountFrom(entropyInBits: rawValue) + } + + static func wordCountFrom(entropyInBits: Int) -> Int { + return Int(ceil(Double(entropyInBits) / Double(Mnemonic.WordList.sizeLog2))) + } + + var checksumLengthInBits: Int { + return wordCount / Mnemonic.Strength.checksumBitsPerWord + } +} diff --git a/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/Mnemonic+Wordlist.swift b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/Mnemonic+Wordlist.swift new file mode 100644 index 00000000..618419f1 --- /dev/null +++ b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/Mnemonic+Wordlist.swift @@ -0,0 +1,47 @@ +// +// Mnemonic+Wordlist.swift +// +// Copyright © 2018 BitcoinKit developers +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// +import Foundation + +extension Mnemonic { + static func wordList(for language: Language) -> [String] { + switch language { + case .english: + return WordList.english + case .japanese: + return WordList.japanese + case .korean: + return WordList.korean + case .spanish: + return WordList.spanish + case .simplifiedChinese: + return WordList.simplifiedChinese + case .traditionalChinese: + return WordList.traditionalChinese + case .french: + return WordList.french + case .italian: + return WordList.italian + } + } +} diff --git a/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/Mnemonic.swift b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/Mnemonic.swift new file mode 100644 index 00000000..958181a8 --- /dev/null +++ b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/Mnemonic.swift @@ -0,0 +1,27 @@ +// +// Mnemonic.swift +// +// Copyright © 2018 BitcoinKit developers +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// + +import Foundation + +enum Mnemonic {} diff --git a/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/UInt11.swift b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/UInt11.swift new file mode 100644 index 00000000..6647def5 --- /dev/null +++ b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/UInt11.swift @@ -0,0 +1,89 @@ +// +// UInt11.swift +// +// Copyright © 2018 BitcoinKit developers +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// + +import Foundation + +struct UInt11: ExpressibleByIntegerLiteral { + + private let valueBoundBy16Bits: UInt16 + + init?(valueBoundBy16Bits: UInt16) { + if valueBoundBy16Bits > UInt11.max16 { + return nil + } + self.valueBoundBy16Bits = valueBoundBy16Bits + } +} + +// MARK: - Static min/max +extension UInt11 { + static var bitWidth: Int { return 11 } + static var max16: UInt16 { return UInt16(2047) } + static var max: UInt11 { return UInt11(exactly: max16)! } + static var min: UInt11 { return 0 } +} + +// MARK: - Convenience Init +extension UInt11 { + + init?(exactly source: T) where T: BinaryInteger { + guard let valueBoundBy16Bits = UInt16(exactly: source) else { return nil } + self.init(valueBoundBy16Bits: valueBoundBy16Bits) + } + + init(truncatingIfNeeded source: T) where T: BinaryInteger { + let valueBoundBy16Bits = UInt16(truncatingIfNeeded: source) + self.valueBoundBy16Bits = Swift.min(UInt11.max16, valueBoundBy16Bits) + } + + /// Creates a new integer value from the given string and radix. + init?(_ text: S, radix: Int = 10) where S: StringProtocol { + guard let uint16 = UInt16(text, radix: radix) else { return nil } + self.init(valueBoundBy16Bits: uint16) + } + + init(integerLiteral value: Int) { + guard let exactly = UInt11(exactly: value) else { + fatalError("bad integer literal value does not fit in UInt11, value passed was: \(value)") + } + self = exactly + } + + init?(bitArray: BitArray) { + if bitArray.count > UInt11.bitWidth { return nil } + self.init(bitArray.binaryString, radix: 2) + } +} + +extension UInt11 { + var binaryString: String { + let binaryString = String(valueBoundBy16Bits.binaryString.suffix(UInt11.bitWidth)) + assert(UInt16(binaryString, radix: 2)! == valueBoundBy16Bits, "incorrect conversion.") + return binaryString + } + + var asInt: Int { + return Int(valueBoundBy16Bits) + } +} diff --git a/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/WordList/WordList+English.swift b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/WordList/WordList+English.swift new file mode 100644 index 00000000..579b062a --- /dev/null +++ b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/WordList/WordList+English.swift @@ -0,0 +1,2085 @@ +// +// WordList.swift +// +// Copyright © 2018 Kishikawa Katsumi +// Copyright © 2018 BitcoinKit developers +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// + +import Foundation + +// swiftlint:disable file_length +extension Mnemonic.WordList { + static var english: [String] = { + let words = + """ + abandon + ability + able + about + above + absent + absorb + abstract + absurd + abuse + access + accident + account + accuse + achieve + acid + acoustic + acquire + across + act + action + actor + actress + actual + adapt + add + addict + address + adjust + admit + adult + advance + advice + aerobic + affair + afford + afraid + again + age + agent + agree + ahead + aim + air + airport + aisle + alarm + album + alcohol + alert + alien + all + alley + allow + almost + alone + alpha + already + also + alter + always + amateur + amazing + among + amount + amused + analyst + anchor + ancient + anger + angle + angry + animal + ankle + announce + annual + another + answer + antenna + antique + anxiety + any + apart + apology + appear + apple + approve + april + arch + arctic + area + arena + argue + arm + armed + armor + army + around + arrange + arrest + arrive + arrow + art + artefact + artist + artwork + ask + aspect + assault + asset + assist + assume + asthma + athlete + atom + attack + attend + attitude + attract + auction + audit + august + aunt + author + auto + autumn + average + avocado + avoid + awake + aware + away + awesome + awful + awkward + axis + baby + bachelor + bacon + badge + bag + balance + balcony + ball + bamboo + banana + banner + bar + barely + bargain + barrel + base + basic + basket + battle + beach + bean + beauty + because + become + beef + before + begin + behave + behind + believe + below + belt + bench + benefit + best + betray + better + between + beyond + bicycle + bid + bike + bind + biology + bird + birth + bitter + black + blade + blame + blanket + blast + bleak + bless + blind + blood + blossom + blouse + blue + blur + blush + board + boat + body + boil + bomb + bone + bonus + book + boost + border + boring + borrow + boss + bottom + bounce + box + boy + bracket + brain + brand + brass + brave + bread + breeze + brick + bridge + brief + bright + bring + brisk + broccoli + broken + bronze + broom + brother + brown + brush + bubble + buddy + budget + buffalo + build + bulb + bulk + bullet + bundle + bunker + burden + burger + burst + bus + business + busy + butter + buyer + buzz + cabbage + cabin + cable + cactus + cage + cake + call + calm + camera + camp + can + canal + cancel + candy + cannon + canoe + canvas + canyon + capable + capital + captain + car + carbon + card + cargo + carpet + carry + cart + case + cash + casino + castle + casual + cat + catalog + catch + category + cattle + caught + cause + caution + cave + ceiling + celery + cement + census + century + cereal + certain + chair + chalk + champion + change + chaos + chapter + charge + chase + chat + cheap + check + cheese + chef + cherry + chest + chicken + chief + child + chimney + choice + choose + chronic + chuckle + chunk + churn + cigar + cinnamon + circle + citizen + city + civil + claim + clap + clarify + claw + clay + clean + clerk + clever + click + client + cliff + climb + clinic + clip + clock + clog + close + cloth + cloud + clown + club + clump + cluster + clutch + coach + coast + coconut + code + coffee + coil + coin + collect + color + column + combine + come + comfort + comic + common + company + concert + conduct + confirm + congress + connect + consider + control + convince + cook + cool + copper + copy + coral + core + corn + correct + cost + cotton + couch + country + couple + course + cousin + cover + coyote + crack + cradle + craft + cram + crane + crash + crater + crawl + crazy + cream + credit + creek + crew + cricket + crime + crisp + critic + crop + cross + crouch + crowd + crucial + cruel + cruise + crumble + crunch + crush + cry + crystal + cube + culture + cup + cupboard + curious + current + curtain + curve + cushion + custom + cute + cycle + dad + damage + damp + dance + danger + daring + dash + daughter + dawn + day + deal + debate + debris + decade + december + decide + decline + decorate + decrease + deer + defense + define + defy + degree + delay + deliver + demand + demise + denial + dentist + deny + depart + depend + deposit + depth + deputy + derive + describe + desert + design + desk + despair + destroy + detail + detect + develop + device + devote + diagram + dial + diamond + diary + dice + diesel + diet + differ + digital + dignity + dilemma + dinner + dinosaur + direct + dirt + disagree + discover + disease + dish + dismiss + disorder + display + distance + divert + divide + divorce + dizzy + doctor + document + dog + doll + dolphin + domain + donate + donkey + donor + door + dose + double + dove + draft + dragon + drama + drastic + draw + dream + dress + drift + drill + drink + drip + drive + drop + drum + dry + duck + dumb + dune + during + dust + dutch + duty + dwarf + dynamic + eager + eagle + early + earn + earth + easily + east + easy + echo + ecology + economy + edge + edit + educate + effort + egg + eight + either + elbow + elder + electric + elegant + element + elephant + elevator + elite + else + embark + embody + embrace + emerge + emotion + employ + empower + empty + enable + enact + end + endless + endorse + enemy + energy + enforce + engage + engine + enhance + enjoy + enlist + enough + enrich + enroll + ensure + enter + entire + entry + envelope + episode + equal + equip + era + erase + erode + erosion + error + erupt + escape + essay + essence + estate + eternal + ethics + evidence + evil + evoke + evolve + exact + example + excess + exchange + excite + exclude + excuse + execute + exercise + exhaust + exhibit + exile + exist + exit + exotic + expand + expect + expire + explain + expose + express + extend + extra + eye + eyebrow + fabric + face + faculty + fade + faint + faith + fall + false + fame + family + famous + fan + fancy + fantasy + farm + fashion + fat + fatal + father + fatigue + fault + favorite + feature + february + federal + fee + feed + feel + female + fence + festival + fetch + fever + few + fiber + fiction + field + figure + file + film + filter + final + find + fine + finger + finish + fire + firm + first + fiscal + fish + fit + fitness + fix + flag + flame + flash + flat + flavor + flee + flight + flip + float + flock + floor + flower + fluid + flush + fly + foam + focus + fog + foil + fold + follow + food + foot + force + forest + forget + fork + fortune + forum + forward + fossil + foster + found + fox + fragile + frame + frequent + fresh + friend + fringe + frog + front + frost + frown + frozen + fruit + fuel + fun + funny + furnace + fury + future + gadget + gain + galaxy + gallery + game + gap + garage + garbage + garden + garlic + garment + gas + gasp + gate + gather + gauge + gaze + general + genius + genre + gentle + genuine + gesture + ghost + giant + gift + giggle + ginger + giraffe + girl + give + glad + glance + glare + glass + glide + glimpse + globe + gloom + glory + glove + glow + glue + goat + goddess + gold + good + goose + gorilla + gospel + gossip + govern + gown + grab + grace + grain + grant + grape + grass + gravity + great + green + grid + grief + grit + grocery + group + grow + grunt + guard + guess + guide + guilt + guitar + gun + gym + habit + hair + half + hammer + hamster + hand + happy + harbor + hard + harsh + harvest + hat + have + hawk + hazard + head + health + heart + heavy + hedgehog + height + hello + helmet + help + hen + hero + hidden + high + hill + hint + hip + hire + history + hobby + hockey + hold + hole + holiday + hollow + home + honey + hood + hope + horn + horror + horse + hospital + host + hotel + hour + hover + hub + huge + human + humble + humor + hundred + hungry + hunt + hurdle + hurry + hurt + husband + hybrid + ice + icon + idea + identify + idle + ignore + ill + illegal + illness + image + imitate + immense + immune + impact + impose + improve + impulse + inch + include + income + increase + index + indicate + indoor + industry + infant + inflict + inform + inhale + inherit + initial + inject + injury + inmate + inner + innocent + input + inquiry + insane + insect + inside + inspire + install + intact + interest + into + invest + invite + involve + iron + island + isolate + issue + item + ivory + jacket + jaguar + jar + jazz + jealous + jeans + jelly + jewel + job + join + joke + journey + joy + judge + juice + jump + jungle + junior + junk + just + kangaroo + keen + keep + ketchup + key + kick + kid + kidney + kind + kingdom + kiss + kit + kitchen + kite + kitten + kiwi + knee + knife + knock + know + lab + label + labor + ladder + lady + lake + lamp + language + laptop + large + later + latin + laugh + laundry + lava + law + lawn + lawsuit + layer + lazy + leader + leaf + learn + leave + lecture + left + leg + legal + legend + leisure + lemon + lend + length + lens + leopard + lesson + letter + level + liar + liberty + library + license + life + lift + light + like + limb + limit + link + lion + liquid + list + little + live + lizard + load + loan + lobster + local + lock + logic + lonely + long + loop + lottery + loud + lounge + love + loyal + lucky + luggage + lumber + lunar + lunch + luxury + lyrics + machine + mad + magic + magnet + maid + mail + main + major + make + mammal + man + manage + mandate + mango + mansion + manual + maple + marble + march + margin + marine + market + marriage + mask + mass + master + match + material + math + matrix + matter + maximum + maze + meadow + mean + measure + meat + mechanic + medal + media + melody + melt + member + memory + mention + menu + mercy + merge + merit + merry + mesh + message + metal + method + middle + midnight + milk + million + mimic + mind + minimum + minor + minute + miracle + mirror + misery + miss + mistake + mix + mixed + mixture + mobile + model + modify + mom + moment + monitor + monkey + monster + month + moon + moral + more + morning + mosquito + mother + motion + motor + mountain + mouse + move + movie + much + muffin + mule + multiply + muscle + museum + mushroom + music + must + mutual + myself + mystery + myth + naive + name + napkin + narrow + nasty + nation + nature + near + neck + need + negative + neglect + neither + nephew + nerve + nest + net + network + neutral + never + news + next + nice + night + noble + noise + nominee + noodle + normal + north + nose + notable + note + nothing + notice + novel + now + nuclear + number + nurse + nut + oak + obey + object + oblige + obscure + observe + obtain + obvious + occur + ocean + october + odor + off + offer + office + often + oil + okay + old + olive + olympic + omit + once + one + onion + online + only + open + opera + opinion + oppose + option + orange + orbit + orchard + order + ordinary + organ + orient + original + orphan + ostrich + other + outdoor + outer + output + outside + oval + oven + over + own + owner + oxygen + oyster + ozone + pact + paddle + page + pair + palace + palm + panda + panel + panic + panther + paper + parade + parent + park + parrot + party + pass + patch + path + patient + patrol + pattern + pause + pave + payment + peace + peanut + pear + peasant + pelican + pen + penalty + pencil + people + pepper + perfect + permit + person + pet + phone + photo + phrase + physical + piano + picnic + picture + piece + pig + pigeon + pill + pilot + pink + pioneer + pipe + pistol + pitch + pizza + place + planet + plastic + plate + play + please + pledge + pluck + plug + plunge + poem + poet + point + polar + pole + police + pond + pony + pool + popular + portion + position + possible + post + potato + pottery + poverty + powder + power + practice + praise + predict + prefer + prepare + present + pretty + prevent + price + pride + primary + print + priority + prison + private + prize + problem + process + produce + profit + program + project + promote + proof + property + prosper + protect + proud + provide + public + pudding + pull + pulp + pulse + pumpkin + punch + pupil + puppy + purchase + purity + purpose + purse + push + put + puzzle + pyramid + quality + quantum + quarter + question + quick + quit + quiz + quote + rabbit + raccoon + race + rack + radar + radio + rail + rain + raise + rally + ramp + ranch + random + range + rapid + rare + rate + rather + raven + raw + razor + ready + real + reason + rebel + rebuild + recall + receive + recipe + record + recycle + reduce + reflect + reform + refuse + region + regret + regular + reject + relax + release + relief + rely + remain + remember + remind + remove + render + renew + rent + reopen + repair + repeat + replace + report + require + rescue + resemble + resist + resource + response + result + retire + retreat + return + reunion + reveal + review + reward + rhythm + rib + ribbon + rice + rich + ride + ridge + rifle + right + rigid + ring + riot + ripple + risk + ritual + rival + river + road + roast + robot + robust + rocket + romance + roof + rookie + room + rose + rotate + rough + round + route + royal + rubber + rude + rug + rule + run + runway + rural + sad + saddle + sadness + safe + sail + salad + salmon + salon + salt + salute + same + sample + sand + satisfy + satoshi + sauce + sausage + save + say + scale + scan + scare + scatter + scene + scheme + school + science + scissors + scorpion + scout + scrap + screen + script + scrub + sea + search + season + seat + second + secret + section + security + seed + seek + segment + select + sell + seminar + senior + sense + sentence + series + service + session + settle + setup + seven + shadow + shaft + shallow + share + shed + shell + sheriff + shield + shift + shine + ship + shiver + shock + shoe + shoot + shop + short + shoulder + shove + shrimp + shrug + shuffle + shy + sibling + sick + side + siege + sight + sign + silent + silk + silly + silver + similar + simple + since + sing + siren + sister + situate + six + size + skate + sketch + ski + skill + skin + skirt + skull + slab + slam + sleep + slender + slice + slide + slight + slim + slogan + slot + slow + slush + small + smart + smile + smoke + smooth + snack + snake + snap + sniff + snow + soap + soccer + social + sock + soda + soft + solar + soldier + solid + solution + solve + someone + song + soon + sorry + sort + soul + sound + soup + source + south + space + spare + spatial + spawn + speak + special + speed + spell + spend + sphere + spice + spider + spike + spin + spirit + split + spoil + sponsor + spoon + sport + spot + spray + spread + spring + spy + square + squeeze + squirrel + stable + stadium + staff + stage + stairs + stamp + stand + start + state + stay + steak + steel + stem + step + stereo + stick + still + sting + stock + stomach + stone + stool + story + stove + strategy + street + strike + strong + struggle + student + stuff + stumble + style + subject + submit + subway + success + such + sudden + suffer + sugar + suggest + suit + summer + sun + sunny + sunset + super + supply + supreme + sure + surface + surge + surprise + surround + survey + suspect + sustain + swallow + swamp + swap + swarm + swear + sweet + swift + swim + swing + switch + sword + symbol + symptom + syrup + system + table + tackle + tag + tail + talent + talk + tank + tape + target + task + taste + tattoo + taxi + teach + team + tell + ten + tenant + tennis + tent + term + test + text + thank + that + theme + then + theory + there + they + thing + this + thought + three + thrive + throw + thumb + thunder + ticket + tide + tiger + tilt + timber + time + tiny + tip + tired + tissue + title + toast + tobacco + today + toddler + toe + together + toilet + token + tomato + tomorrow + tone + tongue + tonight + tool + tooth + top + topic + topple + torch + tornado + tortoise + toss + total + tourist + toward + tower + town + toy + track + trade + traffic + tragic + train + transfer + trap + trash + travel + tray + treat + tree + trend + trial + tribe + trick + trigger + trim + trip + trophy + trouble + truck + true + truly + trumpet + trust + truth + try + tube + tuition + tumble + tuna + tunnel + turkey + turn + turtle + twelve + twenty + twice + twin + twist + two + type + typical + ugly + umbrella + unable + unaware + uncle + uncover + under + undo + unfair + unfold + unhappy + uniform + unique + unit + universe + unknown + unlock + until + unusual + unveil + update + upgrade + uphold + upon + upper + upset + urban + urge + usage + use + used + useful + useless + usual + utility + vacant + vacuum + vague + valid + valley + valve + van + vanish + vapor + various + vast + vault + vehicle + velvet + vendor + venture + venue + verb + verify + version + very + vessel + veteran + viable + vibrant + vicious + victory + video + view + village + vintage + violin + virtual + virus + visa + visit + visual + vital + vivid + vocal + voice + void + volcano + volume + vote + voyage + wage + wagon + wait + walk + wall + walnut + want + warfare + warm + warrior + wash + wasp + waste + water + wave + way + wealth + weapon + wear + weasel + weather + web + wedding + weekend + weird + welcome + west + wet + whale + what + wheat + wheel + when + where + whip + whisper + wide + width + wife + wild + will + win + window + wine + wing + wink + winner + winter + wire + wisdom + wise + wish + witness + wolf + woman + wonder + wood + wool + word + work + world + worry + worth + wrap + wreck + wrestle + wrist + write + wrong + yard + year + yellow + you + young + youth + zebra + zero + zone + zoo + """ + + return words.split(separator: "\n").map { String($0) } + }() +} diff --git a/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/WordList/WordList+French.swift b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/WordList/WordList+French.swift new file mode 100644 index 00000000..ebb18ad4 --- /dev/null +++ b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/WordList/WordList+French.swift @@ -0,0 +1,2085 @@ +// +// WordList.swift +// +// Copyright © 2018 Kishikawa Katsumi +// Copyright © 2018 BitcoinKit developers +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// + +import Foundation + +// swiftlint:disable file_length +extension Mnemonic.WordList { + static var french: [String] = { + let words = + """ + abaisser + abandon + abdiquer + abeille + abolir + aborder + aboutir + aboyer + abrasif + abreuver + abriter + abroger + abrupt + absence + absolu + absurde + abusif + abyssal + académie + acajou + acarien + accabler + accepter + acclamer + accolade + accroche + accuser + acerbe + achat + acheter + aciduler + acier + acompte + acquérir + acronyme + acteur + actif + actuel + adepte + adéquat + adhésif + adjectif + adjuger + admettre + admirer + adopter + adorer + adoucir + adresse + adroit + adulte + adverbe + aérer + aéronef + affaire + affecter + affiche + affreux + affubler + agacer + agencer + agile + agiter + agrafer + agréable + agrume + aider + aiguille + ailier + aimable + aisance + ajouter + ajuster + alarmer + alchimie + alerte + algèbre + algue + aliéner + aliment + alléger + alliage + allouer + allumer + alourdir + alpaga + altesse + alvéole + amateur + ambigu + ambre + aménager + amertume + amidon + amiral + amorcer + amour + amovible + amphibie + ampleur + amusant + analyse + anaphore + anarchie + anatomie + ancien + anéantir + angle + angoisse + anguleux + animal + annexer + annonce + annuel + anodin + anomalie + anonyme + anormal + antenne + antidote + anxieux + apaiser + apéritif + aplanir + apologie + appareil + appeler + apporter + appuyer + aquarium + aqueduc + arbitre + arbuste + ardeur + ardoise + argent + arlequin + armature + armement + armoire + armure + arpenter + arracher + arriver + arroser + arsenic + artériel + article + aspect + asphalte + aspirer + assaut + asservir + assiette + associer + assurer + asticot + astre + astuce + atelier + atome + atrium + atroce + attaque + attentif + attirer + attraper + aubaine + auberge + audace + audible + augurer + aurore + automne + autruche + avaler + avancer + avarice + avenir + averse + aveugle + aviateur + avide + avion + aviser + avoine + avouer + avril + axial + axiome + badge + bafouer + bagage + baguette + baignade + balancer + balcon + baleine + balisage + bambin + bancaire + bandage + banlieue + bannière + banquier + barbier + baril + baron + barque + barrage + bassin + bastion + bataille + bateau + batterie + baudrier + bavarder + belette + bélier + belote + bénéfice + berceau + berger + berline + bermuda + besace + besogne + bétail + beurre + biberon + bicycle + bidule + bijou + bilan + bilingue + billard + binaire + biologie + biopsie + biotype + biscuit + bison + bistouri + bitume + bizarre + blafard + blague + blanchir + blessant + blinder + blond + bloquer + blouson + bobard + bobine + boire + boiser + bolide + bonbon + bondir + bonheur + bonifier + bonus + bordure + borne + botte + boucle + boueux + bougie + boulon + bouquin + bourse + boussole + boutique + boxeur + branche + brasier + brave + brebis + brèche + breuvage + bricoler + brigade + brillant + brioche + brique + brochure + broder + bronzer + brousse + broyeur + brume + brusque + brutal + bruyant + buffle + buisson + bulletin + bureau + burin + bustier + butiner + butoir + buvable + buvette + cabanon + cabine + cachette + cadeau + cadre + caféine + caillou + caisson + calculer + calepin + calibre + calmer + calomnie + calvaire + camarade + caméra + camion + campagne + canal + caneton + canon + cantine + canular + capable + caporal + caprice + capsule + capter + capuche + carabine + carbone + caresser + caribou + carnage + carotte + carreau + carton + cascade + casier + casque + cassure + causer + caution + cavalier + caverne + caviar + cédille + ceinture + céleste + cellule + cendrier + censurer + central + cercle + cérébral + cerise + cerner + cerveau + cesser + chagrin + chaise + chaleur + chambre + chance + chapitre + charbon + chasseur + chaton + chausson + chavirer + chemise + chenille + chéquier + chercher + cheval + chien + chiffre + chignon + chimère + chiot + chlorure + chocolat + choisir + chose + chouette + chrome + chute + cigare + cigogne + cimenter + cinéma + cintrer + circuler + cirer + cirque + citerne + citoyen + citron + civil + clairon + clameur + claquer + classe + clavier + client + cligner + climat + clivage + cloche + clonage + cloporte + cobalt + cobra + cocasse + cocotier + coder + codifier + coffre + cogner + cohésion + coiffer + coincer + colère + colibri + colline + colmater + colonel + combat + comédie + commande + compact + concert + conduire + confier + congeler + connoter + consonne + contact + convexe + copain + copie + corail + corbeau + cordage + corniche + corpus + correct + cortège + cosmique + costume + coton + coude + coupure + courage + couteau + couvrir + coyote + crabe + crainte + cravate + crayon + créature + créditer + crémeux + creuser + crevette + cribler + crier + cristal + critère + croire + croquer + crotale + crucial + cruel + crypter + cubique + cueillir + cuillère + cuisine + cuivre + culminer + cultiver + cumuler + cupide + curatif + curseur + cyanure + cycle + cylindre + cynique + daigner + damier + danger + danseur + dauphin + débattre + débiter + déborder + débrider + débutant + décaler + décembre + déchirer + décider + déclarer + décorer + décrire + décupler + dédale + déductif + déesse + défensif + défiler + défrayer + dégager + dégivrer + déglutir + dégrafer + déjeuner + délice + déloger + demander + demeurer + démolir + dénicher + dénouer + dentelle + dénuder + départ + dépenser + déphaser + déplacer + déposer + déranger + dérober + désastre + descente + désert + désigner + désobéir + dessiner + destrier + détacher + détester + détourer + détresse + devancer + devenir + deviner + devoir + diable + dialogue + diamant + dicter + différer + digérer + digital + digne + diluer + dimanche + diminuer + dioxyde + directif + diriger + discuter + disposer + dissiper + distance + divertir + diviser + docile + docteur + dogme + doigt + domaine + domicile + dompter + donateur + donjon + donner + dopamine + dortoir + dorure + dosage + doseur + dossier + dotation + douanier + double + douceur + douter + doyen + dragon + draper + dresser + dribbler + droiture + duperie + duplexe + durable + durcir + dynastie + éblouir + écarter + écharpe + échelle + éclairer + éclipse + éclore + écluse + école + économie + écorce + écouter + écraser + écrémer + écrivain + écrou + écume + écureuil + édifier + éduquer + effacer + effectif + effigie + effort + effrayer + effusion + égaliser + égarer + éjecter + élaborer + élargir + électron + élégant + éléphant + élève + éligible + élitisme + éloge + élucider + éluder + emballer + embellir + embryon + émeraude + émission + emmener + émotion + émouvoir + empereur + employer + emporter + emprise + émulsion + encadrer + enchère + enclave + encoche + endiguer + endosser + endroit + enduire + énergie + enfance + enfermer + enfouir + engager + engin + englober + énigme + enjamber + enjeu + enlever + ennemi + ennuyeux + enrichir + enrobage + enseigne + entasser + entendre + entier + entourer + entraver + énumérer + envahir + enviable + envoyer + enzyme + éolien + épaissir + épargne + épatant + épaule + épicerie + épidémie + épier + épilogue + épine + épisode + épitaphe + époque + épreuve + éprouver + épuisant + équerre + équipe + ériger + érosion + erreur + éruption + escalier + espadon + espèce + espiègle + espoir + esprit + esquiver + essayer + essence + essieu + essorer + estime + estomac + estrade + étagère + étaler + étanche + étatique + éteindre + étendoir + éternel + éthanol + éthique + ethnie + étirer + étoffer + étoile + étonnant + étourdir + étrange + étroit + étude + euphorie + évaluer + évasion + éventail + évidence + éviter + évolutif + évoquer + exact + exagérer + exaucer + exceller + excitant + exclusif + excuse + exécuter + exemple + exercer + exhaler + exhorter + exigence + exiler + exister + exotique + expédier + explorer + exposer + exprimer + exquis + extensif + extraire + exulter + fable + fabuleux + facette + facile + facture + faiblir + falaise + fameux + famille + farceur + farfelu + farine + farouche + fasciner + fatal + fatigue + faucon + fautif + faveur + favori + fébrile + féconder + fédérer + félin + femme + fémur + fendoir + féodal + fermer + féroce + ferveur + festival + feuille + feutre + février + fiasco + ficeler + fictif + fidèle + figure + filature + filetage + filière + filleul + filmer + filou + filtrer + financer + finir + fiole + firme + fissure + fixer + flairer + flamme + flasque + flatteur + fléau + flèche + fleur + flexion + flocon + flore + fluctuer + fluide + fluvial + folie + fonderie + fongible + fontaine + forcer + forgeron + formuler + fortune + fossile + foudre + fougère + fouiller + foulure + fourmi + fragile + fraise + franchir + frapper + frayeur + frégate + freiner + frelon + frémir + frénésie + frère + friable + friction + frisson + frivole + froid + fromage + frontal + frotter + fruit + fugitif + fuite + fureur + furieux + furtif + fusion + futur + gagner + galaxie + galerie + gambader + garantir + gardien + garnir + garrigue + gazelle + gazon + géant + gélatine + gélule + gendarme + général + génie + genou + gentil + géologie + géomètre + géranium + germe + gestuel + geyser + gibier + gicler + girafe + givre + glace + glaive + glisser + globe + gloire + glorieux + golfeur + gomme + gonfler + gorge + gorille + goudron + gouffre + goulot + goupille + gourmand + goutte + graduel + graffiti + graine + grand + grappin + gratuit + gravir + grenat + griffure + griller + grimper + grogner + gronder + grotte + groupe + gruger + grutier + gruyère + guépard + guerrier + guide + guimauve + guitare + gustatif + gymnaste + gyrostat + habitude + hachoir + halte + hameau + hangar + hanneton + haricot + harmonie + harpon + hasard + hélium + hématome + herbe + hérisson + hermine + héron + hésiter + heureux + hiberner + hibou + hilarant + histoire + hiver + homard + hommage + homogène + honneur + honorer + honteux + horde + horizon + horloge + hormone + horrible + houleux + housse + hublot + huileux + humain + humble + humide + humour + hurler + hydromel + hygiène + hymne + hypnose + idylle + ignorer + iguane + illicite + illusion + image + imbiber + imiter + immense + immobile + immuable + impact + impérial + implorer + imposer + imprimer + imputer + incarner + incendie + incident + incliner + incolore + indexer + indice + inductif + inédit + ineptie + inexact + infini + infliger + informer + infusion + ingérer + inhaler + inhiber + injecter + injure + innocent + inoculer + inonder + inscrire + insecte + insigne + insolite + inspirer + instinct + insulter + intact + intense + intime + intrigue + intuitif + inutile + invasion + inventer + inviter + invoquer + ironique + irradier + irréel + irriter + isoler + ivoire + ivresse + jaguar + jaillir + jambe + janvier + jardin + jauger + jaune + javelot + jetable + jeton + jeudi + jeunesse + joindre + joncher + jongler + joueur + jouissif + journal + jovial + joyau + joyeux + jubiler + jugement + junior + jupon + juriste + justice + juteux + juvénile + kayak + kimono + kiosque + label + labial + labourer + lacérer + lactose + lagune + laine + laisser + laitier + lambeau + lamelle + lampe + lanceur + langage + lanterne + lapin + largeur + larme + laurier + lavabo + lavoir + lecture + légal + léger + légume + lessive + lettre + levier + lexique + lézard + liasse + libérer + libre + licence + licorne + liège + lièvre + ligature + ligoter + ligue + limer + limite + limonade + limpide + linéaire + lingot + lionceau + liquide + lisière + lister + lithium + litige + littoral + livreur + logique + lointain + loisir + lombric + loterie + louer + lourd + loutre + louve + loyal + lubie + lucide + lucratif + lueur + lugubre + luisant + lumière + lunaire + lundi + luron + lutter + luxueux + machine + magasin + magenta + magique + maigre + maillon + maintien + mairie + maison + majorer + malaxer + maléfice + malheur + malice + mallette + mammouth + mandater + maniable + manquant + manteau + manuel + marathon + marbre + marchand + mardi + maritime + marqueur + marron + marteler + mascotte + massif + matériel + matière + matraque + maudire + maussade + mauve + maximal + méchant + méconnu + médaille + médecin + méditer + méduse + meilleur + mélange + mélodie + membre + mémoire + menacer + mener + menhir + mensonge + mentor + mercredi + mérite + merle + messager + mesure + métal + météore + méthode + métier + meuble + miauler + microbe + miette + mignon + migrer + milieu + million + mimique + mince + minéral + minimal + minorer + minute + miracle + miroiter + missile + mixte + mobile + moderne + moelleux + mondial + moniteur + monnaie + monotone + monstre + montagne + monument + moqueur + morceau + morsure + mortier + moteur + motif + mouche + moufle + moulin + mousson + mouton + mouvant + multiple + munition + muraille + murène + murmure + muscle + muséum + musicien + mutation + muter + mutuel + myriade + myrtille + mystère + mythique + nageur + nappe + narquois + narrer + natation + nation + nature + naufrage + nautique + navire + nébuleux + nectar + néfaste + négation + négliger + négocier + neige + nerveux + nettoyer + neurone + neutron + neveu + niche + nickel + nitrate + niveau + noble + nocif + nocturne + noirceur + noisette + nomade + nombreux + nommer + normatif + notable + notifier + notoire + nourrir + nouveau + novateur + novembre + novice + nuage + nuancer + nuire + nuisible + numéro + nuptial + nuque + nutritif + obéir + objectif + obliger + obscur + observer + obstacle + obtenir + obturer + occasion + occuper + océan + octobre + octroyer + octupler + oculaire + odeur + odorant + offenser + officier + offrir + ogive + oiseau + oisillon + olfactif + olivier + ombrage + omettre + onctueux + onduler + onéreux + onirique + opale + opaque + opérer + opinion + opportun + opprimer + opter + optique + orageux + orange + orbite + ordonner + oreille + organe + orgueil + orifice + ornement + orque + ortie + osciller + osmose + ossature + otarie + ouragan + ourson + outil + outrager + ouvrage + ovation + oxyde + oxygène + ozone + paisible + palace + palmarès + palourde + palper + panache + panda + pangolin + paniquer + panneau + panorama + pantalon + papaye + papier + papoter + papyrus + paradoxe + parcelle + paresse + parfumer + parler + parole + parrain + parsemer + partager + parure + parvenir + passion + pastèque + paternel + patience + patron + pavillon + pavoiser + payer + paysage + peigne + peintre + pelage + pélican + pelle + pelouse + peluche + pendule + pénétrer + pénible + pensif + pénurie + pépite + péplum + perdrix + perforer + période + permuter + perplexe + persil + perte + peser + pétale + petit + pétrir + peuple + pharaon + phobie + phoque + photon + phrase + physique + piano + pictural + pièce + pierre + pieuvre + pilote + pinceau + pipette + piquer + pirogue + piscine + piston + pivoter + pixel + pizza + placard + plafond + plaisir + planer + plaque + plastron + plateau + pleurer + plexus + pliage + plomb + plonger + pluie + plumage + pochette + poésie + poète + pointe + poirier + poisson + poivre + polaire + policier + pollen + polygone + pommade + pompier + ponctuel + pondérer + poney + portique + position + posséder + posture + potager + poteau + potion + pouce + poulain + poumon + pourpre + poussin + pouvoir + prairie + pratique + précieux + prédire + préfixe + prélude + prénom + présence + prétexte + prévoir + primitif + prince + prison + priver + problème + procéder + prodige + profond + progrès + proie + projeter + prologue + promener + propre + prospère + protéger + prouesse + proverbe + prudence + pruneau + psychose + public + puceron + puiser + pulpe + pulsar + punaise + punitif + pupitre + purifier + puzzle + pyramide + quasar + querelle + question + quiétude + quitter + quotient + racine + raconter + radieux + ragondin + raideur + raisin + ralentir + rallonge + ramasser + rapide + rasage + ratisser + ravager + ravin + rayonner + réactif + réagir + réaliser + réanimer + recevoir + réciter + réclamer + récolter + recruter + reculer + recycler + rédiger + redouter + refaire + réflexe + réformer + refrain + refuge + régalien + région + réglage + régulier + réitérer + rejeter + rejouer + relatif + relever + relief + remarque + remède + remise + remonter + remplir + remuer + renard + renfort + renifler + renoncer + rentrer + renvoi + replier + reporter + reprise + reptile + requin + réserve + résineux + résoudre + respect + rester + résultat + rétablir + retenir + réticule + retomber + retracer + réunion + réussir + revanche + revivre + révolte + révulsif + richesse + rideau + rieur + rigide + rigoler + rincer + riposter + risible + risque + rituel + rival + rivière + rocheux + romance + rompre + ronce + rondin + roseau + rosier + rotatif + rotor + rotule + rouge + rouille + rouleau + routine + royaume + ruban + rubis + ruche + ruelle + rugueux + ruiner + ruisseau + ruser + rustique + rythme + sabler + saboter + sabre + sacoche + safari + sagesse + saisir + salade + salive + salon + saluer + samedi + sanction + sanglier + sarcasme + sardine + saturer + saugrenu + saumon + sauter + sauvage + savant + savonner + scalpel + scandale + scélérat + scénario + sceptre + schéma + science + scinder + score + scrutin + sculpter + séance + sécable + sécher + secouer + sécréter + sédatif + séduire + seigneur + séjour + sélectif + semaine + sembler + semence + séminal + sénateur + sensible + sentence + séparer + séquence + serein + sergent + sérieux + serrure + sérum + service + sésame + sévir + sevrage + sextuple + sidéral + siècle + siéger + siffler + sigle + signal + silence + silicium + simple + sincère + sinistre + siphon + sirop + sismique + situer + skier + social + socle + sodium + soigneux + soldat + soleil + solitude + soluble + sombre + sommeil + somnoler + sonde + songeur + sonnette + sonore + sorcier + sortir + sosie + sottise + soucieux + soudure + souffle + soulever + soupape + source + soutirer + souvenir + spacieux + spatial + spécial + sphère + spiral + stable + station + sternum + stimulus + stipuler + strict + studieux + stupeur + styliste + sublime + substrat + subtil + subvenir + succès + sucre + suffixe + suggérer + suiveur + sulfate + superbe + supplier + surface + suricate + surmener + surprise + sursaut + survie + suspect + syllabe + symbole + symétrie + synapse + syntaxe + système + tabac + tablier + tactile + tailler + talent + talisman + talonner + tambour + tamiser + tangible + tapis + taquiner + tarder + tarif + tartine + tasse + tatami + tatouage + taupe + taureau + taxer + témoin + temporel + tenaille + tendre + teneur + tenir + tension + terminer + terne + terrible + tétine + texte + thème + théorie + thérapie + thorax + tibia + tiède + timide + tirelire + tiroir + tissu + titane + titre + tituber + toboggan + tolérant + tomate + tonique + tonneau + toponyme + torche + tordre + tornade + torpille + torrent + torse + tortue + totem + toucher + tournage + tousser + toxine + traction + trafic + tragique + trahir + train + trancher + travail + trèfle + tremper + trésor + treuil + triage + tribunal + tricoter + trilogie + triomphe + tripler + triturer + trivial + trombone + tronc + tropical + troupeau + tuile + tulipe + tumulte + tunnel + turbine + tuteur + tutoyer + tuyau + tympan + typhon + typique + tyran + ubuesque + ultime + ultrason + unanime + unifier + union + unique + unitaire + univers + uranium + urbain + urticant + usage + usine + usuel + usure + utile + utopie + vacarme + vaccin + vagabond + vague + vaillant + vaincre + vaisseau + valable + valise + vallon + valve + vampire + vanille + vapeur + varier + vaseux + vassal + vaste + vecteur + vedette + végétal + véhicule + veinard + véloce + vendredi + vénérer + venger + venimeux + ventouse + verdure + vérin + vernir + verrou + verser + vertu + veston + vétéran + vétuste + vexant + vexer + viaduc + viande + victoire + vidange + vidéo + vignette + vigueur + vilain + village + vinaigre + violon + vipère + virement + virtuose + virus + visage + viseur + vision + visqueux + visuel + vital + vitesse + viticole + vitrine + vivace + vivipare + vocation + voguer + voile + voisin + voiture + volaille + volcan + voltiger + volume + vorace + vortex + voter + vouloir + voyage + voyelle + wagon + xénon + yacht + zèbre + zénith + zeste + zoologie + """ + return words.split(separator: "\n").map { String($0) } + }() + +} diff --git a/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/WordList/WordList+Italian.swift b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/WordList/WordList+Italian.swift new file mode 100644 index 00000000..b6aafb4a --- /dev/null +++ b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/WordList/WordList+Italian.swift @@ -0,0 +1,2084 @@ +// +// WordList.swift +// +// Copyright © 2018 Kishikawa Katsumi +// Copyright © 2018 BitcoinKit developers +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// + +import Foundation + +// swiftlint:disable file_length +extension Mnemonic.WordList { + static var italian: [String] = { + let words = + """ + abaco + abbaglio + abbinato + abete + abisso + abolire + abrasivo + abrogato + accadere + accenno + accusato + acetone + achille + acido + acqua + acre + acrilico + acrobata + acuto + adagio + addebito + addome + adeguato + aderire + adipe + adottare + adulare + affabile + affetto + affisso + affranto + aforisma + afoso + africano + agave + agente + agevole + aggancio + agire + agitare + agonismo + agricolo + agrumeto + aguzzo + alabarda + alato + albatro + alberato + albo + albume + alce + alcolico + alettone + alfa + algebra + aliante + alibi + alimento + allagato + allegro + allievo + allodola + allusivo + almeno + alogeno + alpaca + alpestre + altalena + alterno + alticcio + altrove + alunno + alveolo + alzare + amalgama + amanita + amarena + ambito + ambrato + ameba + america + ametista + amico + ammasso + ammenda + ammirare + ammonito + amore + ampio + ampliare + amuleto + anacardo + anagrafe + analista + anarchia + anatra + anca + ancella + ancora + andare + andrea + anello + angelo + angolare + angusto + anima + annegare + annidato + anno + annuncio + anonimo + anticipo + anzi + apatico + apertura + apode + apparire + appetito + appoggio + approdo + appunto + aprile + arabica + arachide + aragosta + araldica + arancio + aratura + arazzo + arbitro + archivio + ardito + arenile + argento + argine + arguto + aria + armonia + arnese + arredato + arringa + arrosto + arsenico + arso + artefice + arzillo + asciutto + ascolto + asepsi + asettico + asfalto + asino + asola + aspirato + aspro + assaggio + asse + assoluto + assurdo + asta + astenuto + astice + astratto + atavico + ateismo + atomico + atono + attesa + attivare + attorno + attrito + attuale + ausilio + austria + autista + autonomo + autunno + avanzato + avere + avvenire + avviso + avvolgere + azione + azoto + azzimo + azzurro + babele + baccano + bacino + baco + badessa + badilata + bagnato + baita + balcone + baldo + balena + ballata + balzano + bambino + bandire + baraonda + barbaro + barca + baritono + barlume + barocco + basilico + basso + batosta + battuto + baule + bava + bavosa + becco + beffa + belgio + belva + benda + benevole + benigno + benzina + bere + berlina + beta + bibita + bici + bidone + bifido + biga + bilancia + bimbo + binocolo + biologo + bipede + bipolare + birbante + birra + biscotto + bisesto + bisnonno + bisonte + bisturi + bizzarro + blando + blatta + bollito + bonifico + bordo + bosco + botanico + bottino + bozzolo + braccio + bradipo + brama + branca + bravura + bretella + brevetto + brezza + briglia + brillante + brindare + broccolo + brodo + bronzina + brullo + bruno + bubbone + buca + budino + buffone + buio + bulbo + buono + burlone + burrasca + bussola + busta + cadetto + caduco + calamaro + calcolo + calesse + calibro + calmo + caloria + cambusa + camerata + camicia + cammino + camola + campale + canapa + candela + cane + canino + canotto + cantina + capace + capello + capitolo + capogiro + cappero + capra + capsula + carapace + carcassa + cardo + carisma + carovana + carretto + cartolina + casaccio + cascata + caserma + caso + cassone + castello + casuale + catasta + catena + catrame + cauto + cavillo + cedibile + cedrata + cefalo + celebre + cellulare + cena + cenone + centesimo + ceramica + cercare + certo + cerume + cervello + cesoia + cespo + ceto + chela + chiaro + chicca + chiedere + chimera + china + chirurgo + chitarra + ciao + ciclismo + cifrare + cigno + cilindro + ciottolo + circa + cirrosi + citrico + cittadino + ciuffo + civetta + civile + classico + clinica + cloro + cocco + codardo + codice + coerente + cognome + collare + colmato + colore + colposo + coltivato + colza + coma + cometa + commando + comodo + computer + comune + conciso + condurre + conferma + congelare + coniuge + connesso + conoscere + consumo + continuo + convegno + coperto + copione + coppia + copricapo + corazza + cordata + coricato + cornice + corolla + corpo + corredo + corsia + cortese + cosmico + costante + cottura + covato + cratere + cravatta + creato + credere + cremoso + crescita + creta + criceto + crinale + crisi + critico + croce + cronaca + crostata + cruciale + crusca + cucire + cuculo + cugino + cullato + cupola + curatore + cursore + curvo + cuscino + custode + dado + daino + dalmata + damerino + daniela + dannoso + danzare + datato + davanti + davvero + debutto + decennio + deciso + declino + decollo + decreto + dedicato + definito + deforme + degno + delegare + delfino + delirio + delta + demenza + denotato + dentro + deposito + derapata + derivare + deroga + descritto + deserto + desiderio + desumere + detersivo + devoto + diametro + dicembre + diedro + difeso + diffuso + digerire + digitale + diluvio + dinamico + dinnanzi + dipinto + diploma + dipolo + diradare + dire + dirotto + dirupo + disagio + discreto + disfare + disgelo + disposto + distanza + disumano + dito + divano + divelto + dividere + divorato + doblone + docente + doganale + dogma + dolce + domato + domenica + dominare + dondolo + dono + dormire + dote + dottore + dovuto + dozzina + drago + druido + dubbio + dubitare + ducale + duna + duomo + duplice + duraturo + ebano + eccesso + ecco + eclissi + economia + edera + edicola + edile + editoria + educare + egemonia + egli + egoismo + egregio + elaborato + elargire + elegante + elencato + eletto + elevare + elfico + elica + elmo + elsa + eluso + emanato + emblema + emesso + emiro + emotivo + emozione + empirico + emulo + endemico + enduro + energia + enfasi + enoteca + entrare + enzima + epatite + epilogo + episodio + epocale + eppure + equatore + erario + erba + erboso + erede + eremita + erigere + ermetico + eroe + erosivo + errante + esagono + esame + esanime + esaudire + esca + esempio + esercito + esibito + esigente + esistere + esito + esofago + esortato + esoso + espanso + espresso + essenza + esso + esteso + estimare + estonia + estroso + esultare + etilico + etnico + etrusco + etto + euclideo + europa + evaso + evidenza + evitato + evoluto + evviva + fabbrica + faccenda + fachiro + falco + famiglia + fanale + fanfara + fango + fantasma + fare + farfalla + farinoso + farmaco + fascia + fastoso + fasullo + faticare + fato + favoloso + febbre + fecola + fede + fegato + felpa + feltro + femmina + fendere + fenomeno + fermento + ferro + fertile + fessura + festivo + fetta + feudo + fiaba + fiducia + fifa + figurato + filo + finanza + finestra + finire + fiore + fiscale + fisico + fiume + flacone + flamenco + flebo + flemma + florido + fluente + fluoro + fobico + focaccia + focoso + foderato + foglio + folata + folclore + folgore + fondente + fonetico + fonia + fontana + forbito + forchetta + foresta + formica + fornaio + foro + fortezza + forzare + fosfato + fosso + fracasso + frana + frassino + fratello + freccetta + frenata + fresco + frigo + frollino + fronde + frugale + frutta + fucilata + fucsia + fuggente + fulmine + fulvo + fumante + fumetto + fumoso + fune + funzione + fuoco + furbo + furgone + furore + fuso + futile + gabbiano + gaffe + galateo + gallina + galoppo + gambero + gamma + garanzia + garbo + garofano + garzone + gasdotto + gasolio + gastrico + gatto + gaudio + gazebo + gazzella + geco + gelatina + gelso + gemello + gemmato + gene + genitore + gennaio + genotipo + gergo + ghepardo + ghiaccio + ghisa + giallo + gilda + ginepro + giocare + gioiello + giorno + giove + girato + girone + gittata + giudizio + giurato + giusto + globulo + glutine + gnomo + gobba + golf + gomito + gommone + gonfio + gonna + governo + gracile + grado + grafico + grammo + grande + grattare + gravoso + grazia + greca + gregge + grifone + grigio + grinza + grotta + gruppo + guadagno + guaio + guanto + guardare + gufo + guidare + ibernato + icona + identico + idillio + idolo + idra + idrico + idrogeno + igiene + ignaro + ignorato + ilare + illeso + illogico + illudere + imballo + imbevuto + imbocco + imbuto + immane + immerso + immolato + impacco + impeto + impiego + importo + impronta + inalare + inarcare + inattivo + incanto + incendio + inchino + incisivo + incluso + incontro + incrocio + incubo + indagine + india + indole + inedito + infatti + infilare + inflitto + ingaggio + ingegno + inglese + ingordo + ingrosso + innesco + inodore + inoltrare + inondato + insano + insetto + insieme + insonnia + insulina + intasato + intero + intonaco + intuito + inumidire + invalido + invece + invito + iperbole + ipnotico + ipotesi + ippica + iride + irlanda + ironico + irrigato + irrorare + isolato + isotopo + isterico + istituto + istrice + italia + iterare + labbro + labirinto + lacca + lacerato + lacrima + lacuna + laddove + lago + lampo + lancetta + lanterna + lardoso + larga + laringe + lastra + latenza + latino + lattuga + lavagna + lavoro + legale + leggero + lembo + lentezza + lenza + leone + lepre + lesivo + lessato + lesto + letterale + leva + levigato + libero + lido + lievito + lilla + limatura + limitare + limpido + lineare + lingua + liquido + lira + lirica + lisca + lite + litigio + livrea + locanda + lode + logica + lombare + londra + longevo + loquace + lorenzo + loto + lotteria + luce + lucidato + lumaca + luminoso + lungo + lupo + luppolo + lusinga + lusso + lutto + macabro + macchina + macero + macinato + madama + magico + maglia + magnete + magro + maiolica + malafede + malgrado + malinteso + malsano + malto + malumore + mana + mancia + mandorla + mangiare + manifesto + mannaro + manovra + mansarda + mantide + manubrio + mappa + maratona + marcire + maretta + marmo + marsupio + maschera + massaia + mastino + materasso + matricola + mattone + maturo + mazurca + meandro + meccanico + mecenate + medesimo + meditare + mega + melassa + melis + melodia + meninge + meno + mensola + mercurio + merenda + merlo + meschino + mese + messere + mestolo + metallo + metodo + mettere + miagolare + mica + micelio + michele + microbo + midollo + miele + migliore + milano + milite + mimosa + minerale + mini + minore + mirino + mirtillo + miscela + missiva + misto + misurare + mitezza + mitigare + mitra + mittente + mnemonico + modello + modifica + modulo + mogano + mogio + mole + molosso + monastero + monco + mondina + monetario + monile + monotono + monsone + montato + monviso + mora + mordere + morsicato + mostro + motivato + motosega + motto + movenza + movimento + mozzo + mucca + mucosa + muffa + mughetto + mugnaio + mulatto + mulinello + multiplo + mummia + munto + muovere + murale + musa + muscolo + musica + mutevole + muto + nababbo + nafta + nanometro + narciso + narice + narrato + nascere + nastrare + naturale + nautica + naviglio + nebulosa + necrosi + negativo + negozio + nemmeno + neofita + neretto + nervo + nessuno + nettuno + neutrale + neve + nevrotico + nicchia + ninfa + nitido + nobile + nocivo + nodo + nome + nomina + nordico + normale + norvegese + nostrano + notare + notizia + notturno + novella + nucleo + nulla + numero + nuovo + nutrire + nuvola + nuziale + oasi + obbedire + obbligo + obelisco + oblio + obolo + obsoleto + occasione + occhio + occidente + occorrere + occultare + ocra + oculato + odierno + odorare + offerta + offrire + offuscato + oggetto + oggi + ognuno + olandese + olfatto + oliato + oliva + ologramma + oltre + omaggio + ombelico + ombra + omega + omissione + ondoso + onere + onice + onnivoro + onorevole + onta + operato + opinione + opposto + oracolo + orafo + ordine + orecchino + orefice + orfano + organico + origine + orizzonte + orma + ormeggio + ornativo + orologio + orrendo + orribile + ortensia + ortica + orzata + orzo + osare + oscurare + osmosi + ospedale + ospite + ossa + ossidare + ostacolo + oste + otite + otre + ottagono + ottimo + ottobre + ovale + ovest + ovino + oviparo + ovocito + ovunque + ovviare + ozio + pacchetto + pace + pacifico + padella + padrone + paese + paga + pagina + palazzina + palesare + pallido + palo + palude + pandoro + pannello + paolo + paonazzo + paprica + parabola + parcella + parere + pargolo + pari + parlato + parola + partire + parvenza + parziale + passivo + pasticca + patacca + patologia + pattume + pavone + peccato + pedalare + pedonale + peggio + peloso + penare + pendice + penisola + pennuto + penombra + pensare + pentola + pepe + pepita + perbene + percorso + perdonato + perforare + pergamena + periodo + permesso + perno + perplesso + persuaso + pertugio + pervaso + pesatore + pesista + peso + pestifero + petalo + pettine + petulante + pezzo + piacere + pianta + piattino + piccino + picozza + piega + pietra + piffero + pigiama + pigolio + pigro + pila + pilifero + pillola + pilota + pimpante + pineta + pinna + pinolo + pioggia + piombo + piramide + piretico + pirite + pirolisi + pitone + pizzico + placebo + planare + plasma + platano + plenario + pochezza + poderoso + podismo + poesia + poggiare + polenta + poligono + pollice + polmonite + polpetta + polso + poltrona + polvere + pomice + pomodoro + ponte + popoloso + porfido + poroso + porpora + porre + portata + posa + positivo + possesso + postulato + potassio + potere + pranzo + prassi + pratica + precluso + predica + prefisso + pregiato + prelievo + premere + prenotare + preparato + presenza + pretesto + prevalso + prima + principe + privato + problema + procura + produrre + profumo + progetto + prolunga + promessa + pronome + proposta + proroga + proteso + prova + prudente + prugna + prurito + psiche + pubblico + pudica + pugilato + pugno + pulce + pulito + pulsante + puntare + pupazzo + pupilla + puro + quadro + qualcosa + quasi + querela + quota + raccolto + raddoppio + radicale + radunato + raffica + ragazzo + ragione + ragno + ramarro + ramingo + ramo + randagio + rantolare + rapato + rapina + rappreso + rasatura + raschiato + rasente + rassegna + rastrello + rata + ravveduto + reale + recepire + recinto + recluta + recondito + recupero + reddito + redimere + regalato + registro + regola + regresso + relazione + remare + remoto + renna + replica + reprimere + reputare + resa + residente + responso + restauro + rete + retina + retorica + rettifica + revocato + riassunto + ribadire + ribelle + ribrezzo + ricarica + ricco + ricevere + riciclato + ricordo + ricreduto + ridicolo + ridurre + rifasare + riflesso + riforma + rifugio + rigare + rigettato + righello + rilassato + rilevato + rimanere + rimbalzo + rimedio + rimorchio + rinascita + rincaro + rinforzo + rinnovo + rinomato + rinsavito + rintocco + rinuncia + rinvenire + riparato + ripetuto + ripieno + riportare + ripresa + ripulire + risata + rischio + riserva + risibile + riso + rispetto + ristoro + risultato + risvolto + ritardo + ritegno + ritmico + ritrovo + riunione + riva + riverso + rivincita + rivolto + rizoma + roba + robotico + robusto + roccia + roco + rodaggio + rodere + roditore + rogito + rollio + romantico + rompere + ronzio + rosolare + rospo + rotante + rotondo + rotula + rovescio + rubizzo + rubrica + ruga + rullino + rumine + rumoroso + ruolo + rupe + russare + rustico + sabato + sabbiare + sabotato + sagoma + salasso + saldatura + salgemma + salivare + salmone + salone + saltare + saluto + salvo + sapere + sapido + saporito + saraceno + sarcasmo + sarto + sassoso + satellite + satira + satollo + saturno + savana + savio + saziato + sbadiglio + sbalzo + sbancato + sbarra + sbattere + sbavare + sbendare + sbirciare + sbloccato + sbocciato + sbrinare + sbruffone + sbuffare + scabroso + scadenza + scala + scambiare + scandalo + scapola + scarso + scatenare + scavato + scelto + scenico + scettro + scheda + schiena + sciarpa + scienza + scindere + scippo + sciroppo + scivolo + sclerare + scodella + scolpito + scomparto + sconforto + scoprire + scorta + scossone + scozzese + scriba + scrollare + scrutinio + scuderia + scultore + scuola + scuro + scusare + sdebitare + sdoganare + seccatura + secondo + sedano + seggiola + segnalato + segregato + seguito + selciato + selettivo + sella + selvaggio + semaforo + sembrare + seme + seminato + sempre + senso + sentire + sepolto + sequenza + serata + serbato + sereno + serio + serpente + serraglio + servire + sestina + setola + settimana + sfacelo + sfaldare + sfamato + sfarzoso + sfaticato + sfera + sfida + sfilato + sfinge + sfocato + sfoderare + sfogo + sfoltire + sforzato + sfratto + sfruttato + sfuggito + sfumare + sfuso + sgabello + sgarbato + sgonfiare + sgorbio + sgrassato + sguardo + sibilo + siccome + sierra + sigla + signore + silenzio + sillaba + simbolo + simpatico + simulato + sinfonia + singolo + sinistro + sino + sintesi + sinusoide + sipario + sisma + sistole + situato + slitta + slogatura + sloveno + smarrito + smemorato + smentito + smeraldo + smilzo + smontare + smottato + smussato + snellire + snervato + snodo + sobbalzo + sobrio + soccorso + sociale + sodale + soffitto + sogno + soldato + solenne + solido + sollazzo + solo + solubile + solvente + somatico + somma + sonda + sonetto + sonnifero + sopire + soppeso + sopra + sorgere + sorpasso + sorriso + sorso + sorteggio + sorvolato + sospiro + sosta + sottile + spada + spalla + spargere + spatola + spavento + spazzola + specie + spedire + spegnere + spelatura + speranza + spessore + spettrale + spezzato + spia + spigoloso + spillato + spinoso + spirale + splendido + sportivo + sposo + spranga + sprecare + spronato + spruzzo + spuntino + squillo + sradicare + srotolato + stabile + stacco + staffa + stagnare + stampato + stantio + starnuto + stasera + statuto + stelo + steppa + sterzo + stiletto + stima + stirpe + stivale + stizzoso + stonato + storico + strappo + stregato + stridulo + strozzare + strutto + stuccare + stufo + stupendo + subentro + succoso + sudore + suggerito + sugo + sultano + suonare + superbo + supporto + surgelato + surrogato + sussurro + sutura + svagare + svedese + sveglio + svelare + svenuto + svezia + sviluppo + svista + svizzera + svolta + svuotare + tabacco + tabulato + tacciare + taciturno + tale + talismano + tampone + tannino + tara + tardivo + targato + tariffa + tarpare + tartaruga + tasto + tattico + taverna + tavolata + tazza + teca + tecnico + telefono + temerario + tempo + temuto + tendone + tenero + tensione + tentacolo + teorema + terme + terrazzo + terzetto + tesi + tesserato + testato + tetro + tettoia + tifare + tigella + timbro + tinto + tipico + tipografo + tiraggio + tiro + titanio + titolo + titubante + tizio + tizzone + toccare + tollerare + tolto + tombola + tomo + tonfo + tonsilla + topazio + topologia + toppa + torba + tornare + torrone + tortora + toscano + tossire + tostatura + totano + trabocco + trachea + trafila + tragedia + tralcio + tramonto + transito + trapano + trarre + trasloco + trattato + trave + treccia + tremolio + trespolo + tributo + tricheco + trifoglio + trillo + trincea + trio + tristezza + triturato + trivella + tromba + trono + troppo + trottola + trovare + truccato + tubatura + tuffato + tulipano + tumulto + tunisia + turbare + turchino + tuta + tutela + ubicato + uccello + uccisore + udire + uditivo + uffa + ufficio + uguale + ulisse + ultimato + umano + umile + umorismo + uncinetto + ungere + ungherese + unicorno + unificato + unisono + unitario + unte + uovo + upupa + uragano + urgenza + urlo + usanza + usato + uscito + usignolo + usuraio + utensile + utilizzo + utopia + vacante + vaccinato + vagabondo + vagliato + valanga + valgo + valico + valletta + valoroso + valutare + valvola + vampata + vangare + vanitoso + vano + vantaggio + vanvera + vapore + varano + varcato + variante + vasca + vedetta + vedova + veduto + vegetale + veicolo + velcro + velina + velluto + veloce + venato + vendemmia + vento + verace + verbale + vergogna + verifica + vero + verruca + verticale + vescica + vessillo + vestale + veterano + vetrina + vetusto + viandante + vibrante + vicenda + vichingo + vicinanza + vidimare + vigilia + vigneto + vigore + vile + villano + vimini + vincitore + viola + vipera + virgola + virologo + virulento + viscoso + visione + vispo + vissuto + visura + vita + vitello + vittima + vivanda + vivido + viziare + voce + voga + volatile + volere + volpe + voragine + vulcano + zampogna + zanna + zappato + zattera + zavorra + zefiro + zelante + zelo + zenzero + zerbino + zibetto + zinco + zircone + zitto + zolla + zotico + zucchero + zufolo + zulu + zuppa + """ + return words.split(separator: "\n").map { String($0) } + }() +} diff --git a/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/WordList/WordList+Japanese.swift b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/WordList/WordList+Japanese.swift new file mode 100644 index 00000000..4dc469c1 --- /dev/null +++ b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/WordList/WordList+Japanese.swift @@ -0,0 +1,2085 @@ +// +// WordList.swift +// +// Copyright © 2018 Kishikawa Katsumi +// Copyright © 2018 BitcoinKit developers +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// + +import Foundation + +// swiftlint:disable file_length +extension Mnemonic.WordList { + static var japanese: [String] = { + let words = + """ + あいこくしん + あいさつ + あいだ + あおぞら + あかちゃん + あきる + あけがた + あける + あこがれる + あさい + あさひ + あしあと + あじわう + あずかる + あずき + あそぶ + あたえる + あたためる + あたりまえ + あたる + あつい + あつかう + あっしゅく + あつまり + あつめる + あてな + あてはまる + あひる + あぶら + あぶる + あふれる + あまい + あまど + あまやかす + あまり + あみもの + あめりか + あやまる + あゆむ + あらいぐま + あらし + あらすじ + あらためる + あらゆる + あらわす + ありがとう + あわせる + あわてる + あんい + あんがい + あんこ + あんぜん + あんてい + あんない + あんまり + いいだす + いおん + いがい + いがく + いきおい + いきなり + いきもの + いきる + いくじ + いくぶん + いけばな + いけん + いこう + いこく + いこつ + いさましい + いさん + いしき + いじゅう + いじょう + いじわる + いずみ + いずれ + いせい + いせえび + いせかい + いせき + いぜん + いそうろう + いそがしい + いだい + いだく + いたずら + いたみ + いたりあ + いちおう + いちじ + いちど + いちば + いちぶ + いちりゅう + いつか + いっしゅん + いっせい + いっそう + いったん + いっち + いってい + いっぽう + いてざ + いてん + いどう + いとこ + いない + いなか + いねむり + いのち + いのる + いはつ + いばる + いはん + いびき + いひん + いふく + いへん + いほう + いみん + いもうと + いもたれ + いもり + いやがる + いやす + いよかん + いよく + いらい + いらすと + いりぐち + いりょう + いれい + いれもの + いれる + いろえんぴつ + いわい + いわう + いわかん + いわば + いわゆる + いんげんまめ + いんさつ + いんしょう + いんよう + うえき + うえる + うおざ + うがい + うかぶ + うかべる + うきわ + うくらいな + うくれれ + うけたまわる + うけつけ + うけとる + うけもつ + うける + うごかす + うごく + うこん + うさぎ + うしなう + うしろがみ + うすい + うすぎ + うすぐらい + うすめる + うせつ + うちあわせ + うちがわ + うちき + うちゅう + うっかり + うつくしい + うったえる + うつる + うどん + うなぎ + うなじ + うなずく + うなる + うねる + うのう + うぶげ + うぶごえ + うまれる + うめる + うもう + うやまう + うよく + うらがえす + うらぐち + うらない + うりあげ + うりきれ + うるさい + うれしい + うれゆき + うれる + うろこ + うわき + うわさ + うんこう + うんちん + うんてん + うんどう + えいえん + えいが + えいきょう + えいご + えいせい + えいぶん + えいよう + えいわ + えおり + えがお + えがく + えきたい + えくせる + えしゃく + えすて + えつらん + えのぐ + えほうまき + えほん + えまき + えもじ + えもの + えらい + えらぶ + えりあ + えんえん + えんかい + えんぎ + えんげき + えんしゅう + えんぜつ + えんそく + えんちょう + えんとつ + おいかける + おいこす + おいしい + おいつく + おうえん + おうさま + おうじ + おうせつ + おうたい + おうふく + おうべい + おうよう + おえる + おおい + おおう + おおどおり + おおや + おおよそ + おかえり + おかず + おがむ + おかわり + おぎなう + おきる + おくさま + おくじょう + おくりがな + おくる + おくれる + おこす + おこなう + おこる + おさえる + おさない + おさめる + おしいれ + おしえる + おじぎ + おじさん + おしゃれ + おそらく + おそわる + おたがい + おたく + おだやか + おちつく + おっと + おつり + おでかけ + おとしもの + おとなしい + おどり + おどろかす + おばさん + おまいり + おめでとう + おもいで + おもう + おもたい + おもちゃ + おやつ + おやゆび + およぼす + おらんだ + おろす + おんがく + おんけい + おんしゃ + おんせん + おんだん + おんちゅう + おんどけい + かあつ + かいが + がいき + がいけん + がいこう + かいさつ + かいしゃ + かいすいよく + かいぜん + かいぞうど + かいつう + かいてん + かいとう + かいふく + がいへき + かいほう + かいよう + がいらい + かいわ + かえる + かおり + かかえる + かがく + かがし + かがみ + かくご + かくとく + かざる + がぞう + かたい + かたち + がちょう + がっきゅう + がっこう + がっさん + がっしょう + かなざわし + かのう + がはく + かぶか + かほう + かほご + かまう + かまぼこ + かめれおん + かゆい + かようび + からい + かるい + かろう + かわく + かわら + がんか + かんけい + かんこう + かんしゃ + かんそう + かんたん + かんち + がんばる + きあい + きあつ + きいろ + ぎいん + きうい + きうん + きえる + きおう + きおく + きおち + きおん + きかい + きかく + きかんしゃ + ききて + きくばり + きくらげ + きけんせい + きこう + きこえる + きこく + きさい + きさく + きさま + きさらぎ + ぎじかがく + ぎしき + ぎじたいけん + ぎじにってい + ぎじゅつしゃ + きすう + きせい + きせき + きせつ + きそう + きぞく + きぞん + きたえる + きちょう + きつえん + ぎっちり + きつつき + きつね + きてい + きどう + きどく + きない + きなが + きなこ + きぬごし + きねん + きのう + きのした + きはく + きびしい + きひん + きふく + きぶん + きぼう + きほん + きまる + きみつ + きむずかしい + きめる + きもだめし + きもち + きもの + きゃく + きやく + ぎゅうにく + きよう + きょうりゅう + きらい + きらく + きりん + きれい + きれつ + きろく + ぎろん + きわめる + ぎんいろ + きんかくじ + きんじょ + きんようび + ぐあい + くいず + くうかん + くうき + くうぐん + くうこう + ぐうせい + くうそう + ぐうたら + くうふく + くうぼ + くかん + くきょう + くげん + ぐこう + くさい + くさき + くさばな + くさる + くしゃみ + くしょう + くすのき + くすりゆび + くせげ + くせん + ぐたいてき + くださる + くたびれる + くちこみ + くちさき + くつした + ぐっすり + くつろぐ + くとうてん + くどく + くなん + くねくね + くのう + くふう + くみあわせ + くみたてる + くめる + くやくしょ + くらす + くらべる + くるま + くれる + くろう + くわしい + ぐんかん + ぐんしょく + ぐんたい + ぐんて + けあな + けいかく + けいけん + けいこ + けいさつ + げいじゅつ + けいたい + げいのうじん + けいれき + けいろ + けおとす + けおりもの + げきか + げきげん + げきだん + げきちん + げきとつ + げきは + げきやく + げこう + げこくじょう + げざい + けさき + げざん + けしき + けしごむ + けしょう + げすと + けたば + けちゃっぷ + けちらす + けつあつ + けつい + けつえき + けっこん + けつじょ + けっせき + けってい + けつまつ + げつようび + げつれい + けつろん + げどく + けとばす + けとる + けなげ + けなす + けなみ + けぬき + げねつ + けねん + けはい + げひん + けぶかい + げぼく + けまり + けみかる + けむし + けむり + けもの + けらい + けろけろ + けわしい + けんい + けんえつ + けんお + けんか + げんき + けんげん + けんこう + けんさく + けんしゅう + けんすう + げんそう + けんちく + けんてい + けんとう + けんない + けんにん + げんぶつ + けんま + けんみん + けんめい + けんらん + けんり + こあくま + こいぬ + こいびと + ごうい + こうえん + こうおん + こうかん + ごうきゅう + ごうけい + こうこう + こうさい + こうじ + こうすい + ごうせい + こうそく + こうたい + こうちゃ + こうつう + こうてい + こうどう + こうない + こうはい + ごうほう + ごうまん + こうもく + こうりつ + こえる + こおり + ごかい + ごがつ + ごかん + こくご + こくさい + こくとう + こくない + こくはく + こぐま + こけい + こける + ここのか + こころ + こさめ + こしつ + こすう + こせい + こせき + こぜん + こそだて + こたい + こたえる + こたつ + こちょう + こっか + こつこつ + こつばん + こつぶ + こてい + こてん + ことがら + ことし + ことば + ことり + こなごな + こねこね + このまま + このみ + このよ + ごはん + こひつじ + こふう + こふん + こぼれる + ごまあぶら + こまかい + ごますり + こまつな + こまる + こむぎこ + こもじ + こもち + こもの + こもん + こやく + こやま + こゆう + こゆび + こよい + こよう + こりる + これくしょん + ころっけ + こわもて + こわれる + こんいん + こんかい + こんき + こんしゅう + こんすい + こんだて + こんとん + こんなん + こんびに + こんぽん + こんまけ + こんや + こんれい + こんわく + ざいえき + さいかい + さいきん + ざいげん + ざいこ + さいしょ + さいせい + ざいたく + ざいちゅう + さいてき + ざいりょう + さうな + さかいし + さがす + さかな + さかみち + さがる + さぎょう + さくし + さくひん + さくら + さこく + さこつ + さずかる + ざせき + さたん + さつえい + ざつおん + ざっか + ざつがく + さっきょく + ざっし + さつじん + ざっそう + さつたば + さつまいも + さてい + さといも + さとう + さとおや + さとし + さとる + さのう + さばく + さびしい + さべつ + さほう + さほど + さます + さみしい + さみだれ + さむけ + さめる + さやえんどう + さゆう + さよう + さよく + さらだ + ざるそば + さわやか + さわる + さんいん + さんか + さんきゃく + さんこう + さんさい + ざんしょ + さんすう + さんせい + さんそ + さんち + さんま + さんみ + さんらん + しあい + しあげ + しあさって + しあわせ + しいく + しいん + しうち + しえい + しおけ + しかい + しかく + じかん + しごと + しすう + じだい + したうけ + したぎ + したて + したみ + しちょう + しちりん + しっかり + しつじ + しつもん + してい + してき + してつ + じてん + じどう + しなぎれ + しなもの + しなん + しねま + しねん + しのぐ + しのぶ + しはい + しばかり + しはつ + しはらい + しはん + しひょう + しふく + じぶん + しへい + しほう + しほん + しまう + しまる + しみん + しむける + じむしょ + しめい + しめる + しもん + しゃいん + しゃうん + しゃおん + じゃがいも + しやくしょ + しゃくほう + しゃけん + しゃこ + しゃざい + しゃしん + しゃせん + しゃそう + しゃたい + しゃちょう + しゃっきん + じゃま + しゃりん + しゃれい + じゆう + じゅうしょ + しゅくはく + じゅしん + しゅっせき + しゅみ + しゅらば + じゅんばん + しょうかい + しょくたく + しょっけん + しょどう + しょもつ + しらせる + しらべる + しんか + しんこう + じんじゃ + しんせいじ + しんちく + しんりん + すあげ + すあし + すあな + ずあん + すいえい + すいか + すいとう + ずいぶん + すいようび + すうがく + すうじつ + すうせん + すおどり + すきま + すくう + すくない + すける + すごい + すこし + ずさん + すずしい + すすむ + すすめる + すっかり + ずっしり + ずっと + すてき + すてる + すねる + すのこ + すはだ + すばらしい + ずひょう + ずぶぬれ + すぶり + すふれ + すべて + すべる + ずほう + すぼん + すまい + すめし + すもう + すやき + すらすら + するめ + すれちがう + すろっと + すわる + すんぜん + すんぽう + せあぶら + せいかつ + せいげん + せいじ + せいよう + せおう + せかいかん + せきにん + せきむ + せきゆ + せきらんうん + せけん + せこう + せすじ + せたい + せたけ + せっかく + せっきゃく + ぜっく + せっけん + せっこつ + せっさたくま + せつぞく + せつだん + せつでん + せっぱん + せつび + せつぶん + せつめい + せつりつ + せなか + せのび + せはば + せびろ + せぼね + せまい + せまる + せめる + せもたれ + せりふ + ぜんあく + せんい + せんえい + せんか + せんきょ + せんく + せんげん + ぜんご + せんさい + せんしゅ + せんすい + せんせい + せんぞ + せんたく + せんちょう + せんてい + せんとう + せんぬき + せんねん + せんぱい + ぜんぶ + ぜんぽう + せんむ + せんめんじょ + せんもん + せんやく + せんゆう + せんよう + ぜんら + ぜんりゃく + せんれい + せんろ + そあく + そいとげる + そいね + そうがんきょう + そうき + そうご + そうしん + そうだん + そうなん + そうび + そうめん + そうり + そえもの + そえん + そがい + そげき + そこう + そこそこ + そざい + そしな + そせい + そせん + そそぐ + そだてる + そつう + そつえん + そっかん + そつぎょう + そっけつ + そっこう + そっせん + そっと + そとがわ + そとづら + そなえる + そなた + そふぼ + そぼく + そぼろ + そまつ + そまる + そむく + そむりえ + そめる + そもそも + そよかぜ + そらまめ + そろう + そんかい + そんけい + そんざい + そんしつ + そんぞく + そんちょう + ぞんび + ぞんぶん + そんみん + たあい + たいいん + たいうん + たいえき + たいおう + だいがく + たいき + たいぐう + たいけん + たいこ + たいざい + だいじょうぶ + だいすき + たいせつ + たいそう + だいたい + たいちょう + たいてい + だいどころ + たいない + たいねつ + たいのう + たいはん + だいひょう + たいふう + たいへん + たいほ + たいまつばな + たいみんぐ + たいむ + たいめん + たいやき + たいよう + たいら + たいりょく + たいる + たいわん + たうえ + たえる + たおす + たおる + たおれる + たかい + たかね + たきび + たくさん + たこく + たこやき + たさい + たしざん + だじゃれ + たすける + たずさわる + たそがれ + たたかう + たたく + ただしい + たたみ + たちばな + だっかい + だっきゃく + だっこ + だっしゅつ + だったい + たてる + たとえる + たなばた + たにん + たぬき + たのしみ + たはつ + たぶん + たべる + たぼう + たまご + たまる + だむる + ためいき + ためす + ためる + たもつ + たやすい + たよる + たらす + たりきほんがん + たりょう + たりる + たると + たれる + たれんと + たろっと + たわむれる + だんあつ + たんい + たんおん + たんか + たんき + たんけん + たんご + たんさん + たんじょうび + だんせい + たんそく + たんたい + だんち + たんてい + たんとう + だんな + たんにん + だんねつ + たんのう + たんぴん + だんぼう + たんまつ + たんめい + だんれつ + だんろ + だんわ + ちあい + ちあん + ちいき + ちいさい + ちえん + ちかい + ちから + ちきゅう + ちきん + ちけいず + ちけん + ちこく + ちさい + ちしき + ちしりょう + ちせい + ちそう + ちたい + ちたん + ちちおや + ちつじょ + ちてき + ちてん + ちぬき + ちぬり + ちのう + ちひょう + ちへいせん + ちほう + ちまた + ちみつ + ちみどろ + ちめいど + ちゃんこなべ + ちゅうい + ちゆりょく + ちょうし + ちょさくけん + ちらし + ちらみ + ちりがみ + ちりょう + ちるど + ちわわ + ちんたい + ちんもく + ついか + ついたち + つうか + つうじょう + つうはん + つうわ + つかう + つかれる + つくね + つくる + つけね + つける + つごう + つたえる + つづく + つつじ + つつむ + つとめる + つながる + つなみ + つねづね + つのる + つぶす + つまらない + つまる + つみき + つめたい + つもり + つもる + つよい + つるぼ + つるみく + つわもの + つわり + てあし + てあて + てあみ + ていおん + ていか + ていき + ていけい + ていこく + ていさつ + ていし + ていせい + ていたい + ていど + ていねい + ていひょう + ていへん + ていぼう + てうち + ておくれ + てきとう + てくび + でこぼこ + てさぎょう + てさげ + てすり + てそう + てちがい + てちょう + てつがく + てつづき + でっぱ + てつぼう + てつや + でぬかえ + てぬき + てぬぐい + てのひら + てはい + てぶくろ + てふだ + てほどき + てほん + てまえ + てまきずし + てみじか + てみやげ + てらす + てれび + てわけ + てわたし + でんあつ + てんいん + てんかい + てんき + てんぐ + てんけん + てんごく + てんさい + てんし + てんすう + でんち + てんてき + てんとう + てんない + てんぷら + てんぼうだい + てんめつ + てんらんかい + でんりょく + でんわ + どあい + といれ + どうかん + とうきゅう + どうぐ + とうし + とうむぎ + とおい + とおか + とおく + とおす + とおる + とかい + とかす + ときおり + ときどき + とくい + とくしゅう + とくてん + とくに + とくべつ + とけい + とける + とこや + とさか + としょかん + とそう + とたん + とちゅう + とっきゅう + とっくん + とつぜん + とつにゅう + とどける + ととのえる + とない + となえる + となり + とのさま + とばす + どぶがわ + とほう + とまる + とめる + ともだち + ともる + どようび + とらえる + とんかつ + どんぶり + ないかく + ないこう + ないしょ + ないす + ないせん + ないそう + なおす + ながい + なくす + なげる + なこうど + なさけ + なたでここ + なっとう + なつやすみ + ななおし + なにごと + なにもの + なにわ + なのか + なふだ + なまいき + なまえ + なまみ + なみだ + なめらか + なめる + なやむ + ならう + ならび + ならぶ + なれる + なわとび + なわばり + にあう + にいがた + にうけ + におい + にかい + にがて + にきび + にくしみ + にくまん + にげる + にさんかたんそ + にしき + にせもの + にちじょう + にちようび + にっか + にっき + にっけい + にっこう + にっさん + にっしょく + にっすう + にっせき + にってい + になう + にほん + にまめ + にもつ + にやり + にゅういん + にりんしゃ + にわとり + にんい + にんか + にんき + にんげん + にんしき + にんずう + にんそう + にんたい + にんち + にんてい + にんにく + にんぷ + にんまり + にんむ + にんめい + にんよう + ぬいくぎ + ぬかす + ぬぐいとる + ぬぐう + ぬくもり + ぬすむ + ぬまえび + ぬめり + ぬらす + ぬんちゃく + ねあげ + ねいき + ねいる + ねいろ + ねぐせ + ねくたい + ねくら + ねこぜ + ねこむ + ねさげ + ねすごす + ねそべる + ねだん + ねつい + ねっしん + ねつぞう + ねったいぎょ + ねぶそく + ねふだ + ねぼう + ねほりはほり + ねまき + ねまわし + ねみみ + ねむい + ねむたい + ねもと + ねらう + ねわざ + ねんいり + ねんおし + ねんかん + ねんきん + ねんぐ + ねんざ + ねんし + ねんちゃく + ねんど + ねんぴ + ねんぶつ + ねんまつ + ねんりょう + ねんれい + のいず + のおづま + のがす + のきなみ + のこぎり + のこす + のこる + のせる + のぞく + のぞむ + のたまう + のちほど + のっく + のばす + のはら + のべる + のぼる + のみもの + のやま + のらいぬ + のらねこ + のりもの + のりゆき + のれん + のんき + ばあい + はあく + ばあさん + ばいか + ばいく + はいけん + はいご + はいしん + はいすい + はいせん + はいそう + はいち + ばいばい + はいれつ + はえる + はおる + はかい + ばかり + はかる + はくしゅ + はけん + はこぶ + はさみ + はさん + はしご + ばしょ + はしる + はせる + ぱそこん + はそん + はたん + はちみつ + はつおん + はっかく + はづき + はっきり + はっくつ + はっけん + はっこう + はっさん + はっしん + はったつ + はっちゅう + はってん + はっぴょう + はっぽう + はなす + はなび + はにかむ + はぶらし + はみがき + はむかう + はめつ + はやい + はやし + はらう + はろうぃん + はわい + はんい + はんえい + はんおん + はんかく + はんきょう + ばんぐみ + はんこ + はんしゃ + はんすう + はんだん + ぱんち + ぱんつ + はんてい + はんとし + はんのう + はんぱ + はんぶん + はんぺん + はんぼうき + はんめい + はんらん + はんろん + ひいき + ひうん + ひえる + ひかく + ひかり + ひかる + ひかん + ひくい + ひけつ + ひこうき + ひこく + ひさい + ひさしぶり + ひさん + びじゅつかん + ひしょ + ひそか + ひそむ + ひたむき + ひだり + ひたる + ひつぎ + ひっこし + ひっし + ひつじゅひん + ひっす + ひつぜん + ぴったり + ぴっちり + ひつよう + ひてい + ひとごみ + ひなまつり + ひなん + ひねる + ひはん + ひびく + ひひょう + ひほう + ひまわり + ひまん + ひみつ + ひめい + ひめじし + ひやけ + ひやす + ひよう + びょうき + ひらがな + ひらく + ひりつ + ひりょう + ひるま + ひるやすみ + ひれい + ひろい + ひろう + ひろき + ひろゆき + ひんかく + ひんけつ + ひんこん + ひんしゅ + ひんそう + ぴんち + ひんぱん + びんぼう + ふあん + ふいうち + ふうけい + ふうせん + ぷうたろう + ふうとう + ふうふ + ふえる + ふおん + ふかい + ふきん + ふくざつ + ふくぶくろ + ふこう + ふさい + ふしぎ + ふじみ + ふすま + ふせい + ふせぐ + ふそく + ぶたにく + ふたん + ふちょう + ふつう + ふつか + ふっかつ + ふっき + ふっこく + ぶどう + ふとる + ふとん + ふのう + ふはい + ふひょう + ふへん + ふまん + ふみん + ふめつ + ふめん + ふよう + ふりこ + ふりる + ふるい + ふんいき + ぶんがく + ぶんぐ + ふんしつ + ぶんせき + ふんそう + ぶんぽう + へいあん + へいおん + へいがい + へいき + へいげん + へいこう + へいさ + へいしゃ + へいせつ + へいそ + へいたく + へいてん + へいねつ + へいわ + へきが + へこむ + べにいろ + べにしょうが + へらす + へんかん + べんきょう + べんごし + へんさい + へんたい + べんり + ほあん + ほいく + ぼうぎょ + ほうこく + ほうそう + ほうほう + ほうもん + ほうりつ + ほえる + ほおん + ほかん + ほきょう + ぼきん + ほくろ + ほけつ + ほけん + ほこう + ほこる + ほしい + ほしつ + ほしゅ + ほしょう + ほせい + ほそい + ほそく + ほたて + ほたる + ぽちぶくろ + ほっきょく + ほっさ + ほったん + ほとんど + ほめる + ほんい + ほんき + ほんけ + ほんしつ + ほんやく + まいにち + まかい + まかせる + まがる + まける + まこと + まさつ + まじめ + ますく + まぜる + まつり + まとめ + まなぶ + まぬけ + まねく + まほう + まもる + まゆげ + まよう + まろやか + まわす + まわり + まわる + まんが + まんきつ + まんぞく + まんなか + みいら + みうち + みえる + みがく + みかた + みかん + みけん + みこん + みじかい + みすい + みすえる + みせる + みっか + みつかる + みつける + みてい + みとめる + みなと + みなみかさい + みねらる + みのう + みのがす + みほん + みもと + みやげ + みらい + みりょく + みわく + みんか + みんぞく + むいか + むえき + むえん + むかい + むかう + むかえ + むかし + むぎちゃ + むける + むげん + むさぼる + むしあつい + むしば + むじゅん + むしろ + むすう + むすこ + むすぶ + むすめ + むせる + むせん + むちゅう + むなしい + むのう + むやみ + むよう + むらさき + むりょう + むろん + めいあん + めいうん + めいえん + めいかく + めいきょく + めいさい + めいし + めいそう + めいぶつ + めいれい + めいわく + めぐまれる + めざす + めした + めずらしい + めだつ + めまい + めやす + めんきょ + めんせき + めんどう + もうしあげる + もうどうけん + もえる + もくし + もくてき + もくようび + もちろん + もどる + もらう + もんく + もんだい + やおや + やける + やさい + やさしい + やすい + やすたろう + やすみ + やせる + やそう + やたい + やちん + やっと + やっぱり + やぶる + やめる + ややこしい + やよい + やわらかい + ゆうき + ゆうびんきょく + ゆうべ + ゆうめい + ゆけつ + ゆしゅつ + ゆせん + ゆそう + ゆたか + ゆちゃく + ゆでる + ゆにゅう + ゆびわ + ゆらい + ゆれる + ようい + ようか + ようきゅう + ようじ + ようす + ようちえん + よかぜ + よかん + よきん + よくせい + よくぼう + よけい + よごれる + よさん + よしゅう + よそう + よそく + よっか + よてい + よどがわく + よねつ + よやく + よゆう + よろこぶ + よろしい + らいう + らくがき + らくご + らくさつ + らくだ + らしんばん + らせん + らぞく + らたい + らっか + られつ + りえき + りかい + りきさく + りきせつ + りくぐん + りくつ + りけん + りこう + りせい + りそう + りそく + りてん + りねん + りゆう + りゅうがく + りよう + りょうり + りょかん + りょくちゃ + りょこう + りりく + りれき + りろん + りんご + るいけい + るいさい + るいじ + るいせき + るすばん + るりがわら + れいかん + れいぎ + れいせい + れいぞうこ + れいとう + れいぼう + れきし + れきだい + れんあい + れんけい + れんこん + れんさい + れんしゅう + れんぞく + れんらく + ろうか + ろうご + ろうじん + ろうそく + ろくが + ろこつ + ろじうら + ろしゅつ + ろせん + ろてん + ろめん + ろれつ + ろんぎ + ろんぱ + ろんぶん + ろんり + わかす + わかめ + わかやま + わかれる + わしつ + わじまし + わすれもの + わらう + われる + """ + + return words.split(separator: "\n").map { String($0) } + }() +} diff --git a/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/WordList/WordList+Korean.swift b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/WordList/WordList+Korean.swift new file mode 100644 index 00000000..b6436848 --- /dev/null +++ b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/WordList/WordList+Korean.swift @@ -0,0 +1,2085 @@ +// +// WordList.swift +// +// Copyright © 2018 Kishikawa Katsumi +// Copyright © 2018 BitcoinKit developers +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// + +import Foundation + +// swiftlint:disable file_length +extension Mnemonic.WordList { + static var korean: [String] = { + let words = + """ + 가격 + 가끔 + 가난 + 가능 + 가득 + 가르침 + 가뭄 + 가방 + 가상 + 가슴 + 가운데 + 가을 + 가이드 + 가입 + 가장 + 가정 + 가족 + 가죽 + 각오 + 각자 + 간격 + 간부 + 간섭 + 간장 + 간접 + 간판 + 갈등 + 갈비 + 갈색 + 갈증 + 감각 + 감기 + 감소 + 감수성 + 감자 + 감정 + 갑자기 + 강남 + 강당 + 강도 + 강력히 + 강변 + 강북 + 강사 + 강수량 + 강아지 + 강원도 + 강의 + 강제 + 강조 + 같이 + 개구리 + 개나리 + 개방 + 개별 + 개선 + 개성 + 개인 + 객관적 + 거실 + 거액 + 거울 + 거짓 + 거품 + 걱정 + 건강 + 건물 + 건설 + 건조 + 건축 + 걸음 + 검사 + 검토 + 게시판 + 게임 + 겨울 + 견해 + 결과 + 결국 + 결론 + 결석 + 결승 + 결심 + 결정 + 결혼 + 경계 + 경고 + 경기 + 경력 + 경복궁 + 경비 + 경상도 + 경영 + 경우 + 경쟁 + 경제 + 경주 + 경찰 + 경치 + 경향 + 경험 + 계곡 + 계단 + 계란 + 계산 + 계속 + 계약 + 계절 + 계층 + 계획 + 고객 + 고구려 + 고궁 + 고급 + 고등학생 + 고무신 + 고민 + 고양이 + 고장 + 고전 + 고집 + 고춧가루 + 고통 + 고향 + 곡식 + 골목 + 골짜기 + 골프 + 공간 + 공개 + 공격 + 공군 + 공급 + 공기 + 공동 + 공무원 + 공부 + 공사 + 공식 + 공업 + 공연 + 공원 + 공장 + 공짜 + 공책 + 공통 + 공포 + 공항 + 공휴일 + 과목 + 과일 + 과장 + 과정 + 과학 + 관객 + 관계 + 관광 + 관념 + 관람 + 관련 + 관리 + 관습 + 관심 + 관점 + 관찰 + 광경 + 광고 + 광장 + 광주 + 괴로움 + 굉장히 + 교과서 + 교문 + 교복 + 교실 + 교양 + 교육 + 교장 + 교직 + 교통 + 교환 + 교훈 + 구경 + 구름 + 구멍 + 구별 + 구분 + 구석 + 구성 + 구속 + 구역 + 구입 + 구청 + 구체적 + 국가 + 국기 + 국내 + 국립 + 국물 + 국민 + 국수 + 국어 + 국왕 + 국적 + 국제 + 국회 + 군대 + 군사 + 군인 + 궁극적 + 권리 + 권위 + 권투 + 귀국 + 귀신 + 규정 + 규칙 + 균형 + 그날 + 그냥 + 그늘 + 그러나 + 그룹 + 그릇 + 그림 + 그제서야 + 그토록 + 극복 + 극히 + 근거 + 근교 + 근래 + 근로 + 근무 + 근본 + 근원 + 근육 + 근처 + 글씨 + 글자 + 금강산 + 금고 + 금년 + 금메달 + 금액 + 금연 + 금요일 + 금지 + 긍정적 + 기간 + 기관 + 기념 + 기능 + 기독교 + 기둥 + 기록 + 기름 + 기법 + 기본 + 기분 + 기쁨 + 기숙사 + 기술 + 기억 + 기업 + 기온 + 기운 + 기원 + 기적 + 기준 + 기침 + 기혼 + 기획 + 긴급 + 긴장 + 길이 + 김밥 + 김치 + 김포공항 + 깍두기 + 깜빡 + 깨달음 + 깨소금 + 껍질 + 꼭대기 + 꽃잎 + 나들이 + 나란히 + 나머지 + 나물 + 나침반 + 나흘 + 낙엽 + 난방 + 날개 + 날씨 + 날짜 + 남녀 + 남대문 + 남매 + 남산 + 남자 + 남편 + 남학생 + 낭비 + 낱말 + 내년 + 내용 + 내일 + 냄비 + 냄새 + 냇물 + 냉동 + 냉면 + 냉방 + 냉장고 + 넥타이 + 넷째 + 노동 + 노란색 + 노력 + 노인 + 녹음 + 녹차 + 녹화 + 논리 + 논문 + 논쟁 + 놀이 + 농구 + 농담 + 농민 + 농부 + 농업 + 농장 + 농촌 + 높이 + 눈동자 + 눈물 + 눈썹 + 뉴욕 + 느낌 + 늑대 + 능동적 + 능력 + 다방 + 다양성 + 다음 + 다이어트 + 다행 + 단계 + 단골 + 단독 + 단맛 + 단순 + 단어 + 단위 + 단점 + 단체 + 단추 + 단편 + 단풍 + 달걀 + 달러 + 달력 + 달리 + 닭고기 + 담당 + 담배 + 담요 + 담임 + 답변 + 답장 + 당근 + 당분간 + 당연히 + 당장 + 대규모 + 대낮 + 대단히 + 대답 + 대도시 + 대략 + 대량 + 대륙 + 대문 + 대부분 + 대신 + 대응 + 대장 + 대전 + 대접 + 대중 + 대책 + 대출 + 대충 + 대통령 + 대학 + 대한민국 + 대합실 + 대형 + 덩어리 + 데이트 + 도대체 + 도덕 + 도둑 + 도망 + 도서관 + 도심 + 도움 + 도입 + 도자기 + 도저히 + 도전 + 도중 + 도착 + 독감 + 독립 + 독서 + 독일 + 독창적 + 동화책 + 뒷모습 + 뒷산 + 딸아이 + 마누라 + 마늘 + 마당 + 마라톤 + 마련 + 마무리 + 마사지 + 마약 + 마요네즈 + 마을 + 마음 + 마이크 + 마중 + 마지막 + 마찬가지 + 마찰 + 마흔 + 막걸리 + 막내 + 막상 + 만남 + 만두 + 만세 + 만약 + 만일 + 만점 + 만족 + 만화 + 많이 + 말기 + 말씀 + 말투 + 맘대로 + 망원경 + 매년 + 매달 + 매력 + 매번 + 매스컴 + 매일 + 매장 + 맥주 + 먹이 + 먼저 + 먼지 + 멀리 + 메일 + 며느리 + 며칠 + 면담 + 멸치 + 명단 + 명령 + 명예 + 명의 + 명절 + 명칭 + 명함 + 모금 + 모니터 + 모델 + 모든 + 모범 + 모습 + 모양 + 모임 + 모조리 + 모집 + 모퉁이 + 목걸이 + 목록 + 목사 + 목소리 + 목숨 + 목적 + 목표 + 몰래 + 몸매 + 몸무게 + 몸살 + 몸속 + 몸짓 + 몸통 + 몹시 + 무관심 + 무궁화 + 무더위 + 무덤 + 무릎 + 무슨 + 무엇 + 무역 + 무용 + 무조건 + 무지개 + 무척 + 문구 + 문득 + 문법 + 문서 + 문제 + 문학 + 문화 + 물가 + 물건 + 물결 + 물고기 + 물론 + 물리학 + 물음 + 물질 + 물체 + 미국 + 미디어 + 미사일 + 미술 + 미역 + 미용실 + 미움 + 미인 + 미팅 + 미혼 + 민간 + 민족 + 민주 + 믿음 + 밀가루 + 밀리미터 + 밑바닥 + 바가지 + 바구니 + 바나나 + 바늘 + 바닥 + 바닷가 + 바람 + 바이러스 + 바탕 + 박물관 + 박사 + 박수 + 반대 + 반드시 + 반말 + 반발 + 반성 + 반응 + 반장 + 반죽 + 반지 + 반찬 + 받침 + 발가락 + 발걸음 + 발견 + 발달 + 발레 + 발목 + 발바닥 + 발생 + 발음 + 발자국 + 발전 + 발톱 + 발표 + 밤하늘 + 밥그릇 + 밥맛 + 밥상 + 밥솥 + 방금 + 방면 + 방문 + 방바닥 + 방법 + 방송 + 방식 + 방안 + 방울 + 방지 + 방학 + 방해 + 방향 + 배경 + 배꼽 + 배달 + 배드민턴 + 백두산 + 백색 + 백성 + 백인 + 백제 + 백화점 + 버릇 + 버섯 + 버튼 + 번개 + 번역 + 번지 + 번호 + 벌금 + 벌레 + 벌써 + 범위 + 범인 + 범죄 + 법률 + 법원 + 법적 + 법칙 + 베이징 + 벨트 + 변경 + 변동 + 변명 + 변신 + 변호사 + 변화 + 별도 + 별명 + 별일 + 병실 + 병아리 + 병원 + 보관 + 보너스 + 보라색 + 보람 + 보름 + 보상 + 보안 + 보자기 + 보장 + 보전 + 보존 + 보통 + 보편적 + 보험 + 복도 + 복사 + 복숭아 + 복습 + 볶음 + 본격적 + 본래 + 본부 + 본사 + 본성 + 본인 + 본질 + 볼펜 + 봉사 + 봉지 + 봉투 + 부근 + 부끄러움 + 부담 + 부동산 + 부문 + 부분 + 부산 + 부상 + 부엌 + 부인 + 부작용 + 부장 + 부정 + 부족 + 부지런히 + 부친 + 부탁 + 부품 + 부회장 + 북부 + 북한 + 분노 + 분량 + 분리 + 분명 + 분석 + 분야 + 분위기 + 분필 + 분홍색 + 불고기 + 불과 + 불교 + 불꽃 + 불만 + 불법 + 불빛 + 불안 + 불이익 + 불행 + 브랜드 + 비극 + 비난 + 비닐 + 비둘기 + 비디오 + 비로소 + 비만 + 비명 + 비밀 + 비바람 + 비빔밥 + 비상 + 비용 + 비율 + 비중 + 비타민 + 비판 + 빌딩 + 빗물 + 빗방울 + 빗줄기 + 빛깔 + 빨간색 + 빨래 + 빨리 + 사건 + 사계절 + 사나이 + 사냥 + 사람 + 사랑 + 사립 + 사모님 + 사물 + 사방 + 사상 + 사생활 + 사설 + 사슴 + 사실 + 사업 + 사용 + 사월 + 사장 + 사전 + 사진 + 사촌 + 사춘기 + 사탕 + 사투리 + 사흘 + 산길 + 산부인과 + 산업 + 산책 + 살림 + 살인 + 살짝 + 삼계탕 + 삼국 + 삼십 + 삼월 + 삼촌 + 상관 + 상금 + 상대 + 상류 + 상반기 + 상상 + 상식 + 상업 + 상인 + 상자 + 상점 + 상처 + 상추 + 상태 + 상표 + 상품 + 상황 + 새벽 + 색깔 + 색연필 + 생각 + 생명 + 생물 + 생방송 + 생산 + 생선 + 생신 + 생일 + 생활 + 서랍 + 서른 + 서명 + 서민 + 서비스 + 서양 + 서울 + 서적 + 서점 + 서쪽 + 서클 + 석사 + 석유 + 선거 + 선물 + 선배 + 선생 + 선수 + 선원 + 선장 + 선전 + 선택 + 선풍기 + 설거지 + 설날 + 설렁탕 + 설명 + 설문 + 설사 + 설악산 + 설치 + 설탕 + 섭씨 + 성공 + 성당 + 성명 + 성별 + 성인 + 성장 + 성적 + 성질 + 성함 + 세금 + 세미나 + 세상 + 세월 + 세종대왕 + 세탁 + 센터 + 센티미터 + 셋째 + 소규모 + 소극적 + 소금 + 소나기 + 소년 + 소득 + 소망 + 소문 + 소설 + 소속 + 소아과 + 소용 + 소원 + 소음 + 소중히 + 소지품 + 소질 + 소풍 + 소형 + 속담 + 속도 + 속옷 + 손가락 + 손길 + 손녀 + 손님 + 손등 + 손목 + 손뼉 + 손실 + 손질 + 손톱 + 손해 + 솔직히 + 솜씨 + 송아지 + 송이 + 송편 + 쇠고기 + 쇼핑 + 수건 + 수년 + 수단 + 수돗물 + 수동적 + 수면 + 수명 + 수박 + 수상 + 수석 + 수술 + 수시로 + 수업 + 수염 + 수영 + 수입 + 수준 + 수집 + 수출 + 수컷 + 수필 + 수학 + 수험생 + 수화기 + 숙녀 + 숙소 + 숙제 + 순간 + 순서 + 순수 + 순식간 + 순위 + 숟가락 + 술병 + 술집 + 숫자 + 스님 + 스물 + 스스로 + 스승 + 스웨터 + 스위치 + 스케이트 + 스튜디오 + 스트레스 + 스포츠 + 슬쩍 + 슬픔 + 습관 + 습기 + 승객 + 승리 + 승부 + 승용차 + 승진 + 시각 + 시간 + 시골 + 시금치 + 시나리오 + 시댁 + 시리즈 + 시멘트 + 시민 + 시부모 + 시선 + 시설 + 시스템 + 시아버지 + 시어머니 + 시월 + 시인 + 시일 + 시작 + 시장 + 시절 + 시점 + 시중 + 시즌 + 시집 + 시청 + 시합 + 시험 + 식구 + 식기 + 식당 + 식량 + 식료품 + 식물 + 식빵 + 식사 + 식생활 + 식초 + 식탁 + 식품 + 신고 + 신규 + 신념 + 신문 + 신발 + 신비 + 신사 + 신세 + 신용 + 신제품 + 신청 + 신체 + 신화 + 실감 + 실내 + 실력 + 실례 + 실망 + 실수 + 실습 + 실시 + 실장 + 실정 + 실질적 + 실천 + 실체 + 실컷 + 실태 + 실패 + 실험 + 실현 + 심리 + 심부름 + 심사 + 심장 + 심정 + 심판 + 쌍둥이 + 씨름 + 씨앗 + 아가씨 + 아나운서 + 아드님 + 아들 + 아쉬움 + 아스팔트 + 아시아 + 아울러 + 아저씨 + 아줌마 + 아직 + 아침 + 아파트 + 아프리카 + 아픔 + 아홉 + 아흔 + 악기 + 악몽 + 악수 + 안개 + 안경 + 안과 + 안내 + 안녕 + 안동 + 안방 + 안부 + 안주 + 알루미늄 + 알코올 + 암시 + 암컷 + 압력 + 앞날 + 앞문 + 애인 + 애정 + 액수 + 앨범 + 야간 + 야단 + 야옹 + 약간 + 약국 + 약속 + 약수 + 약점 + 약품 + 약혼녀 + 양념 + 양력 + 양말 + 양배추 + 양주 + 양파 + 어둠 + 어려움 + 어른 + 어젯밤 + 어쨌든 + 어쩌다가 + 어쩐지 + 언니 + 언덕 + 언론 + 언어 + 얼굴 + 얼른 + 얼음 + 얼핏 + 엄마 + 업무 + 업종 + 업체 + 엉덩이 + 엉망 + 엉터리 + 엊그제 + 에너지 + 에어컨 + 엔진 + 여건 + 여고생 + 여관 + 여군 + 여권 + 여대생 + 여덟 + 여동생 + 여든 + 여론 + 여름 + 여섯 + 여성 + 여왕 + 여인 + 여전히 + 여직원 + 여학생 + 여행 + 역사 + 역시 + 역할 + 연결 + 연구 + 연극 + 연기 + 연락 + 연설 + 연세 + 연속 + 연습 + 연애 + 연예인 + 연인 + 연장 + 연주 + 연출 + 연필 + 연합 + 연휴 + 열기 + 열매 + 열쇠 + 열심히 + 열정 + 열차 + 열흘 + 염려 + 엽서 + 영국 + 영남 + 영상 + 영양 + 영역 + 영웅 + 영원히 + 영하 + 영향 + 영혼 + 영화 + 옆구리 + 옆방 + 옆집 + 예감 + 예금 + 예방 + 예산 + 예상 + 예선 + 예술 + 예습 + 예식장 + 예약 + 예전 + 예절 + 예정 + 예컨대 + 옛날 + 오늘 + 오락 + 오랫동안 + 오렌지 + 오로지 + 오른발 + 오븐 + 오십 + 오염 + 오월 + 오전 + 오직 + 오징어 + 오페라 + 오피스텔 + 오히려 + 옥상 + 옥수수 + 온갖 + 온라인 + 온몸 + 온종일 + 온통 + 올가을 + 올림픽 + 올해 + 옷차림 + 와이셔츠 + 와인 + 완성 + 완전 + 왕비 + 왕자 + 왜냐하면 + 왠지 + 외갓집 + 외국 + 외로움 + 외삼촌 + 외출 + 외침 + 외할머니 + 왼발 + 왼손 + 왼쪽 + 요금 + 요일 + 요즘 + 요청 + 용기 + 용서 + 용어 + 우산 + 우선 + 우승 + 우연히 + 우정 + 우체국 + 우편 + 운동 + 운명 + 운반 + 운전 + 운행 + 울산 + 울음 + 움직임 + 웃어른 + 웃음 + 워낙 + 원고 + 원래 + 원서 + 원숭이 + 원인 + 원장 + 원피스 + 월급 + 월드컵 + 월세 + 월요일 + 웨이터 + 위반 + 위법 + 위성 + 위원 + 위험 + 위협 + 윗사람 + 유난히 + 유럽 + 유명 + 유물 + 유산 + 유적 + 유치원 + 유학 + 유행 + 유형 + 육군 + 육상 + 육십 + 육체 + 은행 + 음력 + 음료 + 음반 + 음성 + 음식 + 음악 + 음주 + 의견 + 의논 + 의문 + 의복 + 의식 + 의심 + 의외로 + 의욕 + 의원 + 의학 + 이것 + 이곳 + 이념 + 이놈 + 이달 + 이대로 + 이동 + 이렇게 + 이력서 + 이론적 + 이름 + 이민 + 이발소 + 이별 + 이불 + 이빨 + 이상 + 이성 + 이슬 + 이야기 + 이용 + 이웃 + 이월 + 이윽고 + 이익 + 이전 + 이중 + 이튿날 + 이틀 + 이혼 + 인간 + 인격 + 인공 + 인구 + 인근 + 인기 + 인도 + 인류 + 인물 + 인생 + 인쇄 + 인연 + 인원 + 인재 + 인종 + 인천 + 인체 + 인터넷 + 인하 + 인형 + 일곱 + 일기 + 일단 + 일대 + 일등 + 일반 + 일본 + 일부 + 일상 + 일생 + 일손 + 일요일 + 일월 + 일정 + 일종 + 일주일 + 일찍 + 일체 + 일치 + 일행 + 일회용 + 임금 + 임무 + 입대 + 입력 + 입맛 + 입사 + 입술 + 입시 + 입원 + 입장 + 입학 + 자가용 + 자격 + 자극 + 자동 + 자랑 + 자부심 + 자식 + 자신 + 자연 + 자원 + 자율 + 자전거 + 자정 + 자존심 + 자판 + 작가 + 작년 + 작성 + 작업 + 작용 + 작은딸 + 작품 + 잔디 + 잔뜩 + 잔치 + 잘못 + 잠깐 + 잠수함 + 잠시 + 잠옷 + 잠자리 + 잡지 + 장관 + 장군 + 장기간 + 장래 + 장례 + 장르 + 장마 + 장면 + 장모 + 장미 + 장비 + 장사 + 장소 + 장식 + 장애인 + 장인 + 장점 + 장차 + 장학금 + 재능 + 재빨리 + 재산 + 재생 + 재작년 + 재정 + 재채기 + 재판 + 재학 + 재활용 + 저것 + 저고리 + 저곳 + 저녁 + 저런 + 저렇게 + 저번 + 저울 + 저절로 + 저축 + 적극 + 적당히 + 적성 + 적용 + 적응 + 전개 + 전공 + 전기 + 전달 + 전라도 + 전망 + 전문 + 전반 + 전부 + 전세 + 전시 + 전용 + 전자 + 전쟁 + 전주 + 전철 + 전체 + 전통 + 전혀 + 전후 + 절대 + 절망 + 절반 + 절약 + 절차 + 점검 + 점수 + 점심 + 점원 + 점점 + 점차 + 접근 + 접시 + 접촉 + 젓가락 + 정거장 + 정도 + 정류장 + 정리 + 정말 + 정면 + 정문 + 정반대 + 정보 + 정부 + 정비 + 정상 + 정성 + 정오 + 정원 + 정장 + 정지 + 정치 + 정확히 + 제공 + 제과점 + 제대로 + 제목 + 제발 + 제법 + 제삿날 + 제안 + 제일 + 제작 + 제주도 + 제출 + 제품 + 제한 + 조각 + 조건 + 조금 + 조깅 + 조명 + 조미료 + 조상 + 조선 + 조용히 + 조절 + 조정 + 조직 + 존댓말 + 존재 + 졸업 + 졸음 + 종교 + 종로 + 종류 + 종소리 + 종업원 + 종종 + 종합 + 좌석 + 죄인 + 주관적 + 주름 + 주말 + 주머니 + 주먹 + 주문 + 주민 + 주방 + 주변 + 주식 + 주인 + 주일 + 주장 + 주전자 + 주택 + 준비 + 줄거리 + 줄기 + 줄무늬 + 중간 + 중계방송 + 중국 + 중년 + 중단 + 중독 + 중반 + 중부 + 중세 + 중소기업 + 중순 + 중앙 + 중요 + 중학교 + 즉석 + 즉시 + 즐거움 + 증가 + 증거 + 증권 + 증상 + 증세 + 지각 + 지갑 + 지경 + 지극히 + 지금 + 지급 + 지능 + 지름길 + 지리산 + 지방 + 지붕 + 지식 + 지역 + 지우개 + 지원 + 지적 + 지점 + 지진 + 지출 + 직선 + 직업 + 직원 + 직장 + 진급 + 진동 + 진로 + 진료 + 진리 + 진짜 + 진찰 + 진출 + 진통 + 진행 + 질문 + 질병 + 질서 + 짐작 + 집단 + 집안 + 집중 + 짜증 + 찌꺼기 + 차남 + 차라리 + 차량 + 차림 + 차별 + 차선 + 차츰 + 착각 + 찬물 + 찬성 + 참가 + 참기름 + 참새 + 참석 + 참여 + 참외 + 참조 + 찻잔 + 창가 + 창고 + 창구 + 창문 + 창밖 + 창작 + 창조 + 채널 + 채점 + 책가방 + 책방 + 책상 + 책임 + 챔피언 + 처벌 + 처음 + 천국 + 천둥 + 천장 + 천재 + 천천히 + 철도 + 철저히 + 철학 + 첫날 + 첫째 + 청년 + 청바지 + 청소 + 청춘 + 체계 + 체력 + 체온 + 체육 + 체중 + 체험 + 초등학생 + 초반 + 초밥 + 초상화 + 초순 + 초여름 + 초원 + 초저녁 + 초점 + 초청 + 초콜릿 + 촛불 + 총각 + 총리 + 총장 + 촬영 + 최근 + 최상 + 최선 + 최신 + 최악 + 최종 + 추석 + 추억 + 추진 + 추천 + 추측 + 축구 + 축소 + 축제 + 축하 + 출근 + 출발 + 출산 + 출신 + 출연 + 출입 + 출장 + 출판 + 충격 + 충고 + 충돌 + 충분히 + 충청도 + 취업 + 취직 + 취향 + 치약 + 친구 + 친척 + 칠십 + 칠월 + 칠판 + 침대 + 침묵 + 침실 + 칫솔 + 칭찬 + 카메라 + 카운터 + 칼국수 + 캐릭터 + 캠퍼스 + 캠페인 + 커튼 + 컨디션 + 컬러 + 컴퓨터 + 코끼리 + 코미디 + 콘서트 + 콜라 + 콤플렉스 + 콩나물 + 쾌감 + 쿠데타 + 크림 + 큰길 + 큰딸 + 큰소리 + 큰아들 + 큰어머니 + 큰일 + 큰절 + 클래식 + 클럽 + 킬로 + 타입 + 타자기 + 탁구 + 탁자 + 탄생 + 태권도 + 태양 + 태풍 + 택시 + 탤런트 + 터널 + 터미널 + 테니스 + 테스트 + 테이블 + 텔레비전 + 토론 + 토마토 + 토요일 + 통계 + 통과 + 통로 + 통신 + 통역 + 통일 + 통장 + 통제 + 통증 + 통합 + 통화 + 퇴근 + 퇴원 + 퇴직금 + 튀김 + 트럭 + 특급 + 특별 + 특성 + 특수 + 특징 + 특히 + 튼튼히 + 티셔츠 + 파란색 + 파일 + 파출소 + 판결 + 판단 + 판매 + 판사 + 팔십 + 팔월 + 팝송 + 패션 + 팩스 + 팩시밀리 + 팬티 + 퍼센트 + 페인트 + 편견 + 편의 + 편지 + 편히 + 평가 + 평균 + 평생 + 평소 + 평양 + 평일 + 평화 + 포스터 + 포인트 + 포장 + 포함 + 표면 + 표정 + 표준 + 표현 + 품목 + 품질 + 풍경 + 풍속 + 풍습 + 프랑스 + 프린터 + 플라스틱 + 피곤 + 피망 + 피아노 + 필름 + 필수 + 필요 + 필자 + 필통 + 핑계 + 하느님 + 하늘 + 하드웨어 + 하룻밤 + 하반기 + 하숙집 + 하순 + 하여튼 + 하지만 + 하천 + 하품 + 하필 + 학과 + 학교 + 학급 + 학기 + 학년 + 학력 + 학번 + 학부모 + 학비 + 학생 + 학술 + 학습 + 학용품 + 학원 + 학위 + 학자 + 학점 + 한계 + 한글 + 한꺼번에 + 한낮 + 한눈 + 한동안 + 한때 + 한라산 + 한마디 + 한문 + 한번 + 한복 + 한식 + 한여름 + 한쪽 + 할머니 + 할아버지 + 할인 + 함께 + 함부로 + 합격 + 합리적 + 항공 + 항구 + 항상 + 항의 + 해결 + 해군 + 해답 + 해당 + 해물 + 해석 + 해설 + 해수욕장 + 해안 + 핵심 + 핸드백 + 햄버거 + 햇볕 + 햇살 + 행동 + 행복 + 행사 + 행운 + 행위 + 향기 + 향상 + 향수 + 허락 + 허용 + 헬기 + 현관 + 현금 + 현대 + 현상 + 현실 + 현장 + 현재 + 현지 + 혈액 + 협력 + 형부 + 형사 + 형수 + 형식 + 형제 + 형태 + 형편 + 혜택 + 호기심 + 호남 + 호랑이 + 호박 + 호텔 + 호흡 + 혹시 + 홀로 + 홈페이지 + 홍보 + 홍수 + 홍차 + 화면 + 화분 + 화살 + 화요일 + 화장 + 화학 + 확보 + 확인 + 확장 + 확정 + 환갑 + 환경 + 환영 + 환율 + 환자 + 활기 + 활동 + 활발히 + 활용 + 활짝 + 회견 + 회관 + 회복 + 회색 + 회원 + 회장 + 회전 + 횟수 + 횡단보도 + 효율적 + 후반 + 후춧가루 + 훈련 + 훨씬 + 휴식 + 휴일 + 흉내 + 흐름 + 흑백 + 흑인 + 흔적 + 흔히 + 흥미 + 흥분 + 희곡 + 희망 + 희생 + 흰색 + 힘껏 + """ + return words.split(separator: "\n").map { String($0) } + }() + +} diff --git a/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/WordList/WordList+SimplifiedChinese.swift b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/WordList/WordList+SimplifiedChinese.swift new file mode 100644 index 00000000..5e5ceff1 --- /dev/null +++ b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/WordList/WordList+SimplifiedChinese.swift @@ -0,0 +1,2085 @@ +// +// WordList.swift +// +// Copyright © 2018 Kishikawa Katsumi +// Copyright © 2018 BitcoinKit developers +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// + +import Foundation + +// swiftlint:disable file_length +extension Mnemonic.WordList { + static var simplifiedChinese: [String] = { + let words = + """ + 的 + 一 + 是 + 在 + 不 + 了 + 有 + 和 + 人 + 这 + 中 + 大 + 为 + 上 + 个 + 国 + 我 + 以 + 要 + 他 + 时 + 来 + 用 + 们 + 生 + 到 + 作 + 地 + 于 + 出 + 就 + 分 + 对 + 成 + 会 + 可 + 主 + 发 + 年 + 动 + 同 + 工 + 也 + 能 + 下 + 过 + 子 + 说 + 产 + 种 + 面 + 而 + 方 + 后 + 多 + 定 + 行 + 学 + 法 + 所 + 民 + 得 + 经 + 十 + 三 + 之 + 进 + 着 + 等 + 部 + 度 + 家 + 电 + 力 + 里 + 如 + 水 + 化 + 高 + 自 + 二 + 理 + 起 + 小 + 物 + 现 + 实 + 加 + 量 + 都 + 两 + 体 + 制 + 机 + 当 + 使 + 点 + 从 + 业 + 本 + 去 + 把 + 性 + 好 + 应 + 开 + 它 + 合 + 还 + 因 + 由 + 其 + 些 + 然 + 前 + 外 + 天 + 政 + 四 + 日 + 那 + 社 + 义 + 事 + 平 + 形 + 相 + 全 + 表 + 间 + 样 + 与 + 关 + 各 + 重 + 新 + 线 + 内 + 数 + 正 + 心 + 反 + 你 + 明 + 看 + 原 + 又 + 么 + 利 + 比 + 或 + 但 + 质 + 气 + 第 + 向 + 道 + 命 + 此 + 变 + 条 + 只 + 没 + 结 + 解 + 问 + 意 + 建 + 月 + 公 + 无 + 系 + 军 + 很 + 情 + 者 + 最 + 立 + 代 + 想 + 已 + 通 + 并 + 提 + 直 + 题 + 党 + 程 + 展 + 五 + 果 + 料 + 象 + 员 + 革 + 位 + 入 + 常 + 文 + 总 + 次 + 品 + 式 + 活 + 设 + 及 + 管 + 特 + 件 + 长 + 求 + 老 + 头 + 基 + 资 + 边 + 流 + 路 + 级 + 少 + 图 + 山 + 统 + 接 + 知 + 较 + 将 + 组 + 见 + 计 + 别 + 她 + 手 + 角 + 期 + 根 + 论 + 运 + 农 + 指 + 几 + 九 + 区 + 强 + 放 + 决 + 西 + 被 + 干 + 做 + 必 + 战 + 先 + 回 + 则 + 任 + 取 + 据 + 处 + 队 + 南 + 给 + 色 + 光 + 门 + 即 + 保 + 治 + 北 + 造 + 百 + 规 + 热 + 领 + 七 + 海 + 口 + 东 + 导 + 器 + 压 + 志 + 世 + 金 + 增 + 争 + 济 + 阶 + 油 + 思 + 术 + 极 + 交 + 受 + 联 + 什 + 认 + 六 + 共 + 权 + 收 + 证 + 改 + 清 + 美 + 再 + 采 + 转 + 更 + 单 + 风 + 切 + 打 + 白 + 教 + 速 + 花 + 带 + 安 + 场 + 身 + 车 + 例 + 真 + 务 + 具 + 万 + 每 + 目 + 至 + 达 + 走 + 积 + 示 + 议 + 声 + 报 + 斗 + 完 + 类 + 八 + 离 + 华 + 名 + 确 + 才 + 科 + 张 + 信 + 马 + 节 + 话 + 米 + 整 + 空 + 元 + 况 + 今 + 集 + 温 + 传 + 土 + 许 + 步 + 群 + 广 + 石 + 记 + 需 + 段 + 研 + 界 + 拉 + 林 + 律 + 叫 + 且 + 究 + 观 + 越 + 织 + 装 + 影 + 算 + 低 + 持 + 音 + 众 + 书 + 布 + 复 + 容 + 儿 + 须 + 际 + 商 + 非 + 验 + 连 + 断 + 深 + 难 + 近 + 矿 + 千 + 周 + 委 + 素 + 技 + 备 + 半 + 办 + 青 + 省 + 列 + 习 + 响 + 约 + 支 + 般 + 史 + 感 + 劳 + 便 + 团 + 往 + 酸 + 历 + 市 + 克 + 何 + 除 + 消 + 构 + 府 + 称 + 太 + 准 + 精 + 值 + 号 + 率 + 族 + 维 + 划 + 选 + 标 + 写 + 存 + 候 + 毛 + 亲 + 快 + 效 + 斯 + 院 + 查 + 江 + 型 + 眼 + 王 + 按 + 格 + 养 + 易 + 置 + 派 + 层 + 片 + 始 + 却 + 专 + 状 + 育 + 厂 + 京 + 识 + 适 + 属 + 圆 + 包 + 火 + 住 + 调 + 满 + 县 + 局 + 照 + 参 + 红 + 细 + 引 + 听 + 该 + 铁 + 价 + 严 + 首 + 底 + 液 + 官 + 德 + 随 + 病 + 苏 + 失 + 尔 + 死 + 讲 + 配 + 女 + 黄 + 推 + 显 + 谈 + 罪 + 神 + 艺 + 呢 + 席 + 含 + 企 + 望 + 密 + 批 + 营 + 项 + 防 + 举 + 球 + 英 + 氧 + 势 + 告 + 李 + 台 + 落 + 木 + 帮 + 轮 + 破 + 亚 + 师 + 围 + 注 + 远 + 字 + 材 + 排 + 供 + 河 + 态 + 封 + 另 + 施 + 减 + 树 + 溶 + 怎 + 止 + 案 + 言 + 士 + 均 + 武 + 固 + 叶 + 鱼 + 波 + 视 + 仅 + 费 + 紧 + 爱 + 左 + 章 + 早 + 朝 + 害 + 续 + 轻 + 服 + 试 + 食 + 充 + 兵 + 源 + 判 + 护 + 司 + 足 + 某 + 练 + 差 + 致 + 板 + 田 + 降 + 黑 + 犯 + 负 + 击 + 范 + 继 + 兴 + 似 + 余 + 坚 + 曲 + 输 + 修 + 故 + 城 + 夫 + 够 + 送 + 笔 + 船 + 占 + 右 + 财 + 吃 + 富 + 春 + 职 + 觉 + 汉 + 画 + 功 + 巴 + 跟 + 虽 + 杂 + 飞 + 检 + 吸 + 助 + 升 + 阳 + 互 + 初 + 创 + 抗 + 考 + 投 + 坏 + 策 + 古 + 径 + 换 + 未 + 跑 + 留 + 钢 + 曾 + 端 + 责 + 站 + 简 + 述 + 钱 + 副 + 尽 + 帝 + 射 + 草 + 冲 + 承 + 独 + 令 + 限 + 阿 + 宣 + 环 + 双 + 请 + 超 + 微 + 让 + 控 + 州 + 良 + 轴 + 找 + 否 + 纪 + 益 + 依 + 优 + 顶 + 础 + 载 + 倒 + 房 + 突 + 坐 + 粉 + 敌 + 略 + 客 + 袁 + 冷 + 胜 + 绝 + 析 + 块 + 剂 + 测 + 丝 + 协 + 诉 + 念 + 陈 + 仍 + 罗 + 盐 + 友 + 洋 + 错 + 苦 + 夜 + 刑 + 移 + 频 + 逐 + 靠 + 混 + 母 + 短 + 皮 + 终 + 聚 + 汽 + 村 + 云 + 哪 + 既 + 距 + 卫 + 停 + 烈 + 央 + 察 + 烧 + 迅 + 境 + 若 + 印 + 洲 + 刻 + 括 + 激 + 孔 + 搞 + 甚 + 室 + 待 + 核 + 校 + 散 + 侵 + 吧 + 甲 + 游 + 久 + 菜 + 味 + 旧 + 模 + 湖 + 货 + 损 + 预 + 阻 + 毫 + 普 + 稳 + 乙 + 妈 + 植 + 息 + 扩 + 银 + 语 + 挥 + 酒 + 守 + 拿 + 序 + 纸 + 医 + 缺 + 雨 + 吗 + 针 + 刘 + 啊 + 急 + 唱 + 误 + 训 + 愿 + 审 + 附 + 获 + 茶 + 鲜 + 粮 + 斤 + 孩 + 脱 + 硫 + 肥 + 善 + 龙 + 演 + 父 + 渐 + 血 + 欢 + 械 + 掌 + 歌 + 沙 + 刚 + 攻 + 谓 + 盾 + 讨 + 晚 + 粒 + 乱 + 燃 + 矛 + 乎 + 杀 + 药 + 宁 + 鲁 + 贵 + 钟 + 煤 + 读 + 班 + 伯 + 香 + 介 + 迫 + 句 + 丰 + 培 + 握 + 兰 + 担 + 弦 + 蛋 + 沉 + 假 + 穿 + 执 + 答 + 乐 + 谁 + 顺 + 烟 + 缩 + 征 + 脸 + 喜 + 松 + 脚 + 困 + 异 + 免 + 背 + 星 + 福 + 买 + 染 + 井 + 概 + 慢 + 怕 + 磁 + 倍 + 祖 + 皇 + 促 + 静 + 补 + 评 + 翻 + 肉 + 践 + 尼 + 衣 + 宽 + 扬 + 棉 + 希 + 伤 + 操 + 垂 + 秋 + 宜 + 氢 + 套 + 督 + 振 + 架 + 亮 + 末 + 宪 + 庆 + 编 + 牛 + 触 + 映 + 雷 + 销 + 诗 + 座 + 居 + 抓 + 裂 + 胞 + 呼 + 娘 + 景 + 威 + 绿 + 晶 + 厚 + 盟 + 衡 + 鸡 + 孙 + 延 + 危 + 胶 + 屋 + 乡 + 临 + 陆 + 顾 + 掉 + 呀 + 灯 + 岁 + 措 + 束 + 耐 + 剧 + 玉 + 赵 + 跳 + 哥 + 季 + 课 + 凯 + 胡 + 额 + 款 + 绍 + 卷 + 齐 + 伟 + 蒸 + 殖 + 永 + 宗 + 苗 + 川 + 炉 + 岩 + 弱 + 零 + 杨 + 奏 + 沿 + 露 + 杆 + 探 + 滑 + 镇 + 饭 + 浓 + 航 + 怀 + 赶 + 库 + 夺 + 伊 + 灵 + 税 + 途 + 灭 + 赛 + 归 + 召 + 鼓 + 播 + 盘 + 裁 + 险 + 康 + 唯 + 录 + 菌 + 纯 + 借 + 糖 + 盖 + 横 + 符 + 私 + 努 + 堂 + 域 + 枪 + 润 + 幅 + 哈 + 竟 + 熟 + 虫 + 泽 + 脑 + 壤 + 碳 + 欧 + 遍 + 侧 + 寨 + 敢 + 彻 + 虑 + 斜 + 薄 + 庭 + 纳 + 弹 + 饲 + 伸 + 折 + 麦 + 湿 + 暗 + 荷 + 瓦 + 塞 + 床 + 筑 + 恶 + 户 + 访 + 塔 + 奇 + 透 + 梁 + 刀 + 旋 + 迹 + 卡 + 氯 + 遇 + 份 + 毒 + 泥 + 退 + 洗 + 摆 + 灰 + 彩 + 卖 + 耗 + 夏 + 择 + 忙 + 铜 + 献 + 硬 + 予 + 繁 + 圈 + 雪 + 函 + 亦 + 抽 + 篇 + 阵 + 阴 + 丁 + 尺 + 追 + 堆 + 雄 + 迎 + 泛 + 爸 + 楼 + 避 + 谋 + 吨 + 野 + 猪 + 旗 + 累 + 偏 + 典 + 馆 + 索 + 秦 + 脂 + 潮 + 爷 + 豆 + 忽 + 托 + 惊 + 塑 + 遗 + 愈 + 朱 + 替 + 纤 + 粗 + 倾 + 尚 + 痛 + 楚 + 谢 + 奋 + 购 + 磨 + 君 + 池 + 旁 + 碎 + 骨 + 监 + 捕 + 弟 + 暴 + 割 + 贯 + 殊 + 释 + 词 + 亡 + 壁 + 顿 + 宝 + 午 + 尘 + 闻 + 揭 + 炮 + 残 + 冬 + 桥 + 妇 + 警 + 综 + 招 + 吴 + 付 + 浮 + 遭 + 徐 + 您 + 摇 + 谷 + 赞 + 箱 + 隔 + 订 + 男 + 吹 + 园 + 纷 + 唐 + 败 + 宋 + 玻 + 巨 + 耕 + 坦 + 荣 + 闭 + 湾 + 键 + 凡 + 驻 + 锅 + 救 + 恩 + 剥 + 凝 + 碱 + 齿 + 截 + 炼 + 麻 + 纺 + 禁 + 废 + 盛 + 版 + 缓 + 净 + 睛 + 昌 + 婚 + 涉 + 筒 + 嘴 + 插 + 岸 + 朗 + 庄 + 街 + 藏 + 姑 + 贸 + 腐 + 奴 + 啦 + 惯 + 乘 + 伙 + 恢 + 匀 + 纱 + 扎 + 辩 + 耳 + 彪 + 臣 + 亿 + 璃 + 抵 + 脉 + 秀 + 萨 + 俄 + 网 + 舞 + 店 + 喷 + 纵 + 寸 + 汗 + 挂 + 洪 + 贺 + 闪 + 柬 + 爆 + 烯 + 津 + 稻 + 墙 + 软 + 勇 + 像 + 滚 + 厘 + 蒙 + 芳 + 肯 + 坡 + 柱 + 荡 + 腿 + 仪 + 旅 + 尾 + 轧 + 冰 + 贡 + 登 + 黎 + 削 + 钻 + 勒 + 逃 + 障 + 氨 + 郭 + 峰 + 币 + 港 + 伏 + 轨 + 亩 + 毕 + 擦 + 莫 + 刺 + 浪 + 秘 + 援 + 株 + 健 + 售 + 股 + 岛 + 甘 + 泡 + 睡 + 童 + 铸 + 汤 + 阀 + 休 + 汇 + 舍 + 牧 + 绕 + 炸 + 哲 + 磷 + 绩 + 朋 + 淡 + 尖 + 启 + 陷 + 柴 + 呈 + 徒 + 颜 + 泪 + 稍 + 忘 + 泵 + 蓝 + 拖 + 洞 + 授 + 镜 + 辛 + 壮 + 锋 + 贫 + 虚 + 弯 + 摩 + 泰 + 幼 + 廷 + 尊 + 窗 + 纲 + 弄 + 隶 + 疑 + 氏 + 宫 + 姐 + 震 + 瑞 + 怪 + 尤 + 琴 + 循 + 描 + 膜 + 违 + 夹 + 腰 + 缘 + 珠 + 穷 + 森 + 枝 + 竹 + 沟 + 催 + 绳 + 忆 + 邦 + 剩 + 幸 + 浆 + 栏 + 拥 + 牙 + 贮 + 礼 + 滤 + 钠 + 纹 + 罢 + 拍 + 咱 + 喊 + 袖 + 埃 + 勤 + 罚 + 焦 + 潜 + 伍 + 墨 + 欲 + 缝 + 姓 + 刊 + 饱 + 仿 + 奖 + 铝 + 鬼 + 丽 + 跨 + 默 + 挖 + 链 + 扫 + 喝 + 袋 + 炭 + 污 + 幕 + 诸 + 弧 + 励 + 梅 + 奶 + 洁 + 灾 + 舟 + 鉴 + 苯 + 讼 + 抱 + 毁 + 懂 + 寒 + 智 + 埔 + 寄 + 届 + 跃 + 渡 + 挑 + 丹 + 艰 + 贝 + 碰 + 拔 + 爹 + 戴 + 码 + 梦 + 芽 + 熔 + 赤 + 渔 + 哭 + 敬 + 颗 + 奔 + 铅 + 仲 + 虎 + 稀 + 妹 + 乏 + 珍 + 申 + 桌 + 遵 + 允 + 隆 + 螺 + 仓 + 魏 + 锐 + 晓 + 氮 + 兼 + 隐 + 碍 + 赫 + 拨 + 忠 + 肃 + 缸 + 牵 + 抢 + 博 + 巧 + 壳 + 兄 + 杜 + 讯 + 诚 + 碧 + 祥 + 柯 + 页 + 巡 + 矩 + 悲 + 灌 + 龄 + 伦 + 票 + 寻 + 桂 + 铺 + 圣 + 恐 + 恰 + 郑 + 趣 + 抬 + 荒 + 腾 + 贴 + 柔 + 滴 + 猛 + 阔 + 辆 + 妻 + 填 + 撤 + 储 + 签 + 闹 + 扰 + 紫 + 砂 + 递 + 戏 + 吊 + 陶 + 伐 + 喂 + 疗 + 瓶 + 婆 + 抚 + 臂 + 摸 + 忍 + 虾 + 蜡 + 邻 + 胸 + 巩 + 挤 + 偶 + 弃 + 槽 + 劲 + 乳 + 邓 + 吉 + 仁 + 烂 + 砖 + 租 + 乌 + 舰 + 伴 + 瓜 + 浅 + 丙 + 暂 + 燥 + 橡 + 柳 + 迷 + 暖 + 牌 + 秧 + 胆 + 详 + 簧 + 踏 + 瓷 + 谱 + 呆 + 宾 + 糊 + 洛 + 辉 + 愤 + 竞 + 隙 + 怒 + 粘 + 乃 + 绪 + 肩 + 籍 + 敏 + 涂 + 熙 + 皆 + 侦 + 悬 + 掘 + 享 + 纠 + 醒 + 狂 + 锁 + 淀 + 恨 + 牲 + 霸 + 爬 + 赏 + 逆 + 玩 + 陵 + 祝 + 秒 + 浙 + 貌 + 役 + 彼 + 悉 + 鸭 + 趋 + 凤 + 晨 + 畜 + 辈 + 秩 + 卵 + 署 + 梯 + 炎 + 滩 + 棋 + 驱 + 筛 + 峡 + 冒 + 啥 + 寿 + 译 + 浸 + 泉 + 帽 + 迟 + 硅 + 疆 + 贷 + 漏 + 稿 + 冠 + 嫩 + 胁 + 芯 + 牢 + 叛 + 蚀 + 奥 + 鸣 + 岭 + 羊 + 凭 + 串 + 塘 + 绘 + 酵 + 融 + 盆 + 锡 + 庙 + 筹 + 冻 + 辅 + 摄 + 袭 + 筋 + 拒 + 僚 + 旱 + 钾 + 鸟 + 漆 + 沈 + 眉 + 疏 + 添 + 棒 + 穗 + 硝 + 韩 + 逼 + 扭 + 侨 + 凉 + 挺 + 碗 + 栽 + 炒 + 杯 + 患 + 馏 + 劝 + 豪 + 辽 + 勃 + 鸿 + 旦 + 吏 + 拜 + 狗 + 埋 + 辊 + 掩 + 饮 + 搬 + 骂 + 辞 + 勾 + 扣 + 估 + 蒋 + 绒 + 雾 + 丈 + 朵 + 姆 + 拟 + 宇 + 辑 + 陕 + 雕 + 偿 + 蓄 + 崇 + 剪 + 倡 + 厅 + 咬 + 驶 + 薯 + 刷 + 斥 + 番 + 赋 + 奉 + 佛 + 浇 + 漫 + 曼 + 扇 + 钙 + 桃 + 扶 + 仔 + 返 + 俗 + 亏 + 腔 + 鞋 + 棱 + 覆 + 框 + 悄 + 叔 + 撞 + 骗 + 勘 + 旺 + 沸 + 孤 + 吐 + 孟 + 渠 + 屈 + 疾 + 妙 + 惜 + 仰 + 狠 + 胀 + 谐 + 抛 + 霉 + 桑 + 岗 + 嘛 + 衰 + 盗 + 渗 + 脏 + 赖 + 涌 + 甜 + 曹 + 阅 + 肌 + 哩 + 厉 + 烃 + 纬 + 毅 + 昨 + 伪 + 症 + 煮 + 叹 + 钉 + 搭 + 茎 + 笼 + 酷 + 偷 + 弓 + 锥 + 恒 + 杰 + 坑 + 鼻 + 翼 + 纶 + 叙 + 狱 + 逮 + 罐 + 络 + 棚 + 抑 + 膨 + 蔬 + 寺 + 骤 + 穆 + 冶 + 枯 + 册 + 尸 + 凸 + 绅 + 坯 + 牺 + 焰 + 轰 + 欣 + 晋 + 瘦 + 御 + 锭 + 锦 + 丧 + 旬 + 锻 + 垄 + 搜 + 扑 + 邀 + 亭 + 酯 + 迈 + 舒 + 脆 + 酶 + 闲 + 忧 + 酚 + 顽 + 羽 + 涨 + 卸 + 仗 + 陪 + 辟 + 惩 + 杭 + 姚 + 肚 + 捉 + 飘 + 漂 + 昆 + 欺 + 吾 + 郎 + 烷 + 汁 + 呵 + 饰 + 萧 + 雅 + 邮 + 迁 + 燕 + 撒 + 姻 + 赴 + 宴 + 烦 + 债 + 帐 + 斑 + 铃 + 旨 + 醇 + 董 + 饼 + 雏 + 姿 + 拌 + 傅 + 腹 + 妥 + 揉 + 贤 + 拆 + 歪 + 葡 + 胺 + 丢 + 浩 + 徽 + 昂 + 垫 + 挡 + 览 + 贪 + 慰 + 缴 + 汪 + 慌 + 冯 + 诺 + 姜 + 谊 + 凶 + 劣 + 诬 + 耀 + 昏 + 躺 + 盈 + 骑 + 乔 + 溪 + 丛 + 卢 + 抹 + 闷 + 咨 + 刮 + 驾 + 缆 + 悟 + 摘 + 铒 + 掷 + 颇 + 幻 + 柄 + 惠 + 惨 + 佳 + 仇 + 腊 + 窝 + 涤 + 剑 + 瞧 + 堡 + 泼 + 葱 + 罩 + 霍 + 捞 + 胎 + 苍 + 滨 + 俩 + 捅 + 湘 + 砍 + 霞 + 邵 + 萄 + 疯 + 淮 + 遂 + 熊 + 粪 + 烘 + 宿 + 档 + 戈 + 驳 + 嫂 + 裕 + 徙 + 箭 + 捐 + 肠 + 撑 + 晒 + 辨 + 殿 + 莲 + 摊 + 搅 + 酱 + 屏 + 疫 + 哀 + 蔡 + 堵 + 沫 + 皱 + 畅 + 叠 + 阁 + 莱 + 敲 + 辖 + 钩 + 痕 + 坝 + 巷 + 饿 + 祸 + 丘 + 玄 + 溜 + 曰 + 逻 + 彭 + 尝 + 卿 + 妨 + 艇 + 吞 + 韦 + 怨 + 矮 + 歇 + """ + return words.split(separator: "\n").map { String($0) } + }() + +} diff --git a/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/WordList/WordList+Spanish.swift b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/WordList/WordList+Spanish.swift new file mode 100644 index 00000000..0708c9a1 --- /dev/null +++ b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/WordList/WordList+Spanish.swift @@ -0,0 +1,2085 @@ +// +// WordList.swift +// +// Copyright © 2018 Kishikawa Katsumi +// Copyright © 2018 BitcoinKit developers +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// + +import Foundation + +// swiftlint:disable file_length +extension Mnemonic.WordList { + static var spanish: [String] = { + let words = + """ + ábaco + abdomen + abeja + abierto + abogado + abono + aborto + abrazo + abrir + abuelo + abuso + acabar + academia + acceso + acción + aceite + acelga + acento + aceptar + ácido + aclarar + acné + acoger + acoso + activo + acto + actriz + actuar + acudir + acuerdo + acusar + adicto + admitir + adoptar + adorno + aduana + adulto + aéreo + afectar + afición + afinar + afirmar + ágil + agitar + agonía + agosto + agotar + agregar + agrio + agua + agudo + águila + aguja + ahogo + ahorro + aire + aislar + ajedrez + ajeno + ajuste + alacrán + alambre + alarma + alba + álbum + alcalde + aldea + alegre + alejar + alerta + aleta + alfiler + alga + algodón + aliado + aliento + alivio + alma + almeja + almíbar + altar + alteza + altivo + alto + altura + alumno + alzar + amable + amante + amapola + amargo + amasar + ámbar + ámbito + ameno + amigo + amistad + amor + amparo + amplio + ancho + anciano + ancla + andar + andén + anemia + ángulo + anillo + ánimo + anís + anotar + antena + antiguo + antojo + anual + anular + anuncio + añadir + añejo + año + apagar + aparato + apetito + apio + aplicar + apodo + aporte + apoyo + aprender + aprobar + apuesta + apuro + arado + araña + arar + árbitro + árbol + arbusto + archivo + arco + arder + ardilla + arduo + área + árido + aries + armonía + arnés + aroma + arpa + arpón + arreglo + arroz + arruga + arte + artista + asa + asado + asalto + ascenso + asegurar + aseo + asesor + asiento + asilo + asistir + asno + asombro + áspero + astilla + astro + astuto + asumir + asunto + atajo + ataque + atar + atento + ateo + ático + atleta + átomo + atraer + atroz + atún + audaz + audio + auge + aula + aumento + ausente + autor + aval + avance + avaro + ave + avellana + avena + avestruz + avión + aviso + ayer + ayuda + ayuno + azafrán + azar + azote + azúcar + azufre + azul + baba + babor + bache + bahía + baile + bajar + balanza + balcón + balde + bambú + banco + banda + baño + barba + barco + barniz + barro + báscula + bastón + basura + batalla + batería + batir + batuta + baúl + bazar + bebé + bebida + bello + besar + beso + bestia + bicho + bien + bingo + blanco + bloque + blusa + boa + bobina + bobo + boca + bocina + boda + bodega + boina + bola + bolero + bolsa + bomba + bondad + bonito + bono + bonsái + borde + borrar + bosque + bote + botín + bóveda + bozal + bravo + brazo + brecha + breve + brillo + brinco + brisa + broca + broma + bronce + brote + bruja + brusco + bruto + buceo + bucle + bueno + buey + bufanda + bufón + búho + buitre + bulto + burbuja + burla + burro + buscar + butaca + buzón + caballo + cabeza + cabina + cabra + cacao + cadáver + cadena + caer + café + caída + caimán + caja + cajón + cal + calamar + calcio + caldo + calidad + calle + calma + calor + calvo + cama + cambio + camello + camino + campo + cáncer + candil + canela + canguro + canica + canto + caña + cañón + caoba + caos + capaz + capitán + capote + captar + capucha + cara + carbón + cárcel + careta + carga + cariño + carne + carpeta + carro + carta + casa + casco + casero + caspa + castor + catorce + catre + caudal + causa + cazo + cebolla + ceder + cedro + celda + célebre + celoso + célula + cemento + ceniza + centro + cerca + cerdo + cereza + cero + cerrar + certeza + césped + cetro + chacal + chaleco + champú + chancla + chapa + charla + chico + chiste + chivo + choque + choza + chuleta + chupar + ciclón + ciego + cielo + cien + cierto + cifra + cigarro + cima + cinco + cine + cinta + ciprés + circo + ciruela + cisne + cita + ciudad + clamor + clan + claro + clase + clave + cliente + clima + clínica + cobre + cocción + cochino + cocina + coco + código + codo + cofre + coger + cohete + cojín + cojo + cola + colcha + colegio + colgar + colina + collar + colmo + columna + combate + comer + comida + cómodo + compra + conde + conejo + conga + conocer + consejo + contar + copa + copia + corazón + corbata + corcho + cordón + corona + correr + coser + cosmos + costa + cráneo + cráter + crear + crecer + creído + crema + cría + crimen + cripta + crisis + cromo + crónica + croqueta + crudo + cruz + cuadro + cuarto + cuatro + cubo + cubrir + cuchara + cuello + cuento + cuerda + cuesta + cueva + cuidar + culebra + culpa + culto + cumbre + cumplir + cuna + cuneta + cuota + cupón + cúpula + curar + curioso + curso + curva + cutis + dama + danza + dar + dardo + dátil + deber + débil + década + decir + dedo + defensa + definir + dejar + delfín + delgado + delito + demora + denso + dental + deporte + derecho + derrota + desayuno + deseo + desfile + desnudo + destino + desvío + detalle + detener + deuda + día + diablo + diadema + diamante + diana + diario + dibujo + dictar + diente + dieta + diez + difícil + digno + dilema + diluir + dinero + directo + dirigir + disco + diseño + disfraz + diva + divino + doble + doce + dolor + domingo + don + donar + dorado + dormir + dorso + dos + dosis + dragón + droga + ducha + duda + duelo + dueño + dulce + dúo + duque + durar + dureza + duro + ébano + ebrio + echar + eco + ecuador + edad + edición + edificio + editor + educar + efecto + eficaz + eje + ejemplo + elefante + elegir + elemento + elevar + elipse + élite + elixir + elogio + eludir + embudo + emitir + emoción + empate + empeño + empleo + empresa + enano + encargo + enchufe + encía + enemigo + enero + enfado + enfermo + engaño + enigma + enlace + enorme + enredo + ensayo + enseñar + entero + entrar + envase + envío + época + equipo + erizo + escala + escena + escolar + escribir + escudo + esencia + esfera + esfuerzo + espada + espejo + espía + esposa + espuma + esquí + estar + este + estilo + estufa + etapa + eterno + ética + etnia + evadir + evaluar + evento + evitar + exacto + examen + exceso + excusa + exento + exigir + exilio + existir + éxito + experto + explicar + exponer + extremo + fábrica + fábula + fachada + fácil + factor + faena + faja + falda + fallo + falso + faltar + fama + familia + famoso + faraón + farmacia + farol + farsa + fase + fatiga + fauna + favor + fax + febrero + fecha + feliz + feo + feria + feroz + fértil + fervor + festín + fiable + fianza + fiar + fibra + ficción + ficha + fideo + fiebre + fiel + fiera + fiesta + figura + fijar + fijo + fila + filete + filial + filtro + fin + finca + fingir + finito + firma + flaco + flauta + flecha + flor + flota + fluir + flujo + flúor + fobia + foca + fogata + fogón + folio + folleto + fondo + forma + forro + fortuna + forzar + fosa + foto + fracaso + frágil + franja + frase + fraude + freír + freno + fresa + frío + frito + fruta + fuego + fuente + fuerza + fuga + fumar + función + funda + furgón + furia + fusil + fútbol + futuro + gacela + gafas + gaita + gajo + gala + galería + gallo + gamba + ganar + gancho + ganga + ganso + garaje + garza + gasolina + gastar + gato + gavilán + gemelo + gemir + gen + género + genio + gente + geranio + gerente + germen + gesto + gigante + gimnasio + girar + giro + glaciar + globo + gloria + gol + golfo + goloso + golpe + goma + gordo + gorila + gorra + gota + goteo + gozar + grada + gráfico + grano + grasa + gratis + grave + grieta + grillo + gripe + gris + grito + grosor + grúa + grueso + grumo + grupo + guante + guapo + guardia + guerra + guía + guiño + guion + guiso + guitarra + gusano + gustar + haber + hábil + hablar + hacer + hacha + hada + hallar + hamaca + harina + haz + hazaña + hebilla + hebra + hecho + helado + helio + hembra + herir + hermano + héroe + hervir + hielo + hierro + hígado + higiene + hijo + himno + historia + hocico + hogar + hoguera + hoja + hombre + hongo + honor + honra + hora + hormiga + horno + hostil + hoyo + hueco + huelga + huerta + hueso + huevo + huida + huir + humano + húmedo + humilde + humo + hundir + huracán + hurto + icono + ideal + idioma + ídolo + iglesia + iglú + igual + ilegal + ilusión + imagen + imán + imitar + impar + imperio + imponer + impulso + incapaz + índice + inerte + infiel + informe + ingenio + inicio + inmenso + inmune + innato + insecto + instante + interés + íntimo + intuir + inútil + invierno + ira + iris + ironía + isla + islote + jabalí + jabón + jamón + jarabe + jardín + jarra + jaula + jazmín + jefe + jeringa + jinete + jornada + joroba + joven + joya + juerga + jueves + juez + jugador + jugo + juguete + juicio + junco + jungla + junio + juntar + júpiter + jurar + justo + juvenil + juzgar + kilo + koala + labio + lacio + lacra + lado + ladrón + lagarto + lágrima + laguna + laico + lamer + lámina + lámpara + lana + lancha + langosta + lanza + lápiz + largo + larva + lástima + lata + látex + latir + laurel + lavar + lazo + leal + lección + leche + lector + leer + legión + legumbre + lejano + lengua + lento + leña + león + leopardo + lesión + letal + letra + leve + leyenda + libertad + libro + licor + líder + lidiar + lienzo + liga + ligero + lima + límite + limón + limpio + lince + lindo + línea + lingote + lino + linterna + líquido + liso + lista + litera + litio + litro + llaga + llama + llanto + llave + llegar + llenar + llevar + llorar + llover + lluvia + lobo + loción + loco + locura + lógica + logro + lombriz + lomo + lonja + lote + lucha + lucir + lugar + lujo + luna + lunes + lupa + lustro + luto + luz + maceta + macho + madera + madre + maduro + maestro + mafia + magia + mago + maíz + maldad + maleta + malla + malo + mamá + mambo + mamut + manco + mando + manejar + manga + maniquí + manjar + mano + manso + manta + mañana + mapa + máquina + mar + marco + marea + marfil + margen + marido + mármol + marrón + martes + marzo + masa + máscara + masivo + matar + materia + matiz + matriz + máximo + mayor + mazorca + mecha + medalla + medio + médula + mejilla + mejor + melena + melón + memoria + menor + mensaje + mente + menú + mercado + merengue + mérito + mes + mesón + meta + meter + método + metro + mezcla + miedo + miel + miembro + miga + mil + milagro + militar + millón + mimo + mina + minero + mínimo + minuto + miope + mirar + misa + miseria + misil + mismo + mitad + mito + mochila + moción + moda + modelo + moho + mojar + molde + moler + molino + momento + momia + monarca + moneda + monja + monto + moño + morada + morder + moreno + morir + morro + morsa + mortal + mosca + mostrar + motivo + mover + móvil + mozo + mucho + mudar + mueble + muela + muerte + muestra + mugre + mujer + mula + muleta + multa + mundo + muñeca + mural + muro + músculo + museo + musgo + música + muslo + nácar + nación + nadar + naipe + naranja + nariz + narrar + nasal + natal + nativo + natural + náusea + naval + nave + navidad + necio + néctar + negar + negocio + negro + neón + nervio + neto + neutro + nevar + nevera + nicho + nido + niebla + nieto + niñez + niño + nítido + nivel + nobleza + noche + nómina + noria + norma + norte + nota + noticia + novato + novela + novio + nube + nuca + núcleo + nudillo + nudo + nuera + nueve + nuez + nulo + número + nutria + oasis + obeso + obispo + objeto + obra + obrero + observar + obtener + obvio + oca + ocaso + océano + ochenta + ocho + ocio + ocre + octavo + octubre + oculto + ocupar + ocurrir + odiar + odio + odisea + oeste + ofensa + oferta + oficio + ofrecer + ogro + oído + oír + ojo + ola + oleada + olfato + olivo + olla + olmo + olor + olvido + ombligo + onda + onza + opaco + opción + ópera + opinar + oponer + optar + óptica + opuesto + oración + orador + oral + órbita + orca + orden + oreja + órgano + orgía + orgullo + oriente + origen + orilla + oro + orquesta + oruga + osadía + oscuro + osezno + oso + ostra + otoño + otro + oveja + óvulo + óxido + oxígeno + oyente + ozono + pacto + padre + paella + página + pago + país + pájaro + palabra + palco + paleta + pálido + palma + paloma + palpar + pan + panal + pánico + pantera + pañuelo + papá + papel + papilla + paquete + parar + parcela + pared + parir + paro + párpado + parque + párrafo + parte + pasar + paseo + pasión + paso + pasta + pata + patio + patria + pausa + pauta + pavo + payaso + peatón + pecado + pecera + pecho + pedal + pedir + pegar + peine + pelar + peldaño + pelea + peligro + pellejo + pelo + peluca + pena + pensar + peñón + peón + peor + pepino + pequeño + pera + percha + perder + pereza + perfil + perico + perla + permiso + perro + persona + pesa + pesca + pésimo + pestaña + pétalo + petróleo + pez + pezuña + picar + pichón + pie + piedra + pierna + pieza + pijama + pilar + piloto + pimienta + pino + pintor + pinza + piña + piojo + pipa + pirata + pisar + piscina + piso + pista + pitón + pizca + placa + plan + plata + playa + plaza + pleito + pleno + plomo + pluma + plural + pobre + poco + poder + podio + poema + poesía + poeta + polen + policía + pollo + polvo + pomada + pomelo + pomo + pompa + poner + porción + portal + posada + poseer + posible + poste + potencia + potro + pozo + prado + precoz + pregunta + premio + prensa + preso + previo + primo + príncipe + prisión + privar + proa + probar + proceso + producto + proeza + profesor + programa + prole + promesa + pronto + propio + próximo + prueba + público + puchero + pudor + pueblo + puerta + puesto + pulga + pulir + pulmón + pulpo + pulso + puma + punto + puñal + puño + pupa + pupila + puré + quedar + queja + quemar + querer + queso + quieto + química + quince + quitar + rábano + rabia + rabo + ración + radical + raíz + rama + rampa + rancho + rango + rapaz + rápido + rapto + rasgo + raspa + rato + rayo + raza + razón + reacción + realidad + rebaño + rebote + recaer + receta + rechazo + recoger + recreo + recto + recurso + red + redondo + reducir + reflejo + reforma + refrán + refugio + regalo + regir + regla + regreso + rehén + reino + reír + reja + relato + relevo + relieve + relleno + reloj + remar + remedio + remo + rencor + rendir + renta + reparto + repetir + reposo + reptil + res + rescate + resina + respeto + resto + resumen + retiro + retorno + retrato + reunir + revés + revista + rey + rezar + rico + riego + rienda + riesgo + rifa + rígido + rigor + rincón + riñón + río + riqueza + risa + ritmo + rito + rizo + roble + roce + rociar + rodar + rodeo + rodilla + roer + rojizo + rojo + romero + romper + ron + ronco + ronda + ropa + ropero + rosa + rosca + rostro + rotar + rubí + rubor + rudo + rueda + rugir + ruido + ruina + ruleta + rulo + rumbo + rumor + ruptura + ruta + rutina + sábado + saber + sabio + sable + sacar + sagaz + sagrado + sala + saldo + salero + salir + salmón + salón + salsa + salto + salud + salvar + samba + sanción + sandía + sanear + sangre + sanidad + sano + santo + sapo + saque + sardina + sartén + sastre + satán + sauna + saxofón + sección + seco + secreto + secta + sed + seguir + seis + sello + selva + semana + semilla + senda + sensor + señal + señor + separar + sepia + sequía + ser + serie + sermón + servir + sesenta + sesión + seta + setenta + severo + sexo + sexto + sidra + siesta + siete + siglo + signo + sílaba + silbar + silencio + silla + símbolo + simio + sirena + sistema + sitio + situar + sobre + socio + sodio + sol + solapa + soldado + soledad + sólido + soltar + solución + sombra + sondeo + sonido + sonoro + sonrisa + sopa + soplar + soporte + sordo + sorpresa + sorteo + sostén + sótano + suave + subir + suceso + sudor + suegra + suelo + sueño + suerte + sufrir + sujeto + sultán + sumar + superar + suplir + suponer + supremo + sur + surco + sureño + surgir + susto + sutil + tabaco + tabique + tabla + tabú + taco + tacto + tajo + talar + talco + talento + talla + talón + tamaño + tambor + tango + tanque + tapa + tapete + tapia + tapón + taquilla + tarde + tarea + tarifa + tarjeta + tarot + tarro + tarta + tatuaje + tauro + taza + tazón + teatro + techo + tecla + técnica + tejado + tejer + tejido + tela + teléfono + tema + temor + templo + tenaz + tender + tener + tenis + tenso + teoría + terapia + terco + término + ternura + terror + tesis + tesoro + testigo + tetera + texto + tez + tibio + tiburón + tiempo + tienda + tierra + tieso + tigre + tijera + tilde + timbre + tímido + timo + tinta + tío + típico + tipo + tira + tirón + titán + títere + título + tiza + toalla + tobillo + tocar + tocino + todo + toga + toldo + tomar + tono + tonto + topar + tope + toque + tórax + torero + tormenta + torneo + toro + torpedo + torre + torso + tortuga + tos + tosco + toser + tóxico + trabajo + tractor + traer + tráfico + trago + traje + tramo + trance + trato + trauma + trazar + trébol + tregua + treinta + tren + trepar + tres + tribu + trigo + tripa + triste + triunfo + trofeo + trompa + tronco + tropa + trote + trozo + truco + trueno + trufa + tubería + tubo + tuerto + tumba + tumor + túnel + túnica + turbina + turismo + turno + tutor + ubicar + úlcera + umbral + unidad + unir + universo + uno + untar + uña + urbano + urbe + urgente + urna + usar + usuario + útil + utopía + uva + vaca + vacío + vacuna + vagar + vago + vaina + vajilla + vale + válido + valle + valor + válvula + vampiro + vara + variar + varón + vaso + vecino + vector + vehículo + veinte + vejez + vela + velero + veloz + vena + vencer + venda + veneno + vengar + venir + venta + venus + ver + verano + verbo + verde + vereda + verja + verso + verter + vía + viaje + vibrar + vicio + víctima + vida + vídeo + vidrio + viejo + viernes + vigor + vil + villa + vinagre + vino + viñedo + violín + viral + virgo + virtud + visor + víspera + vista + vitamina + viudo + vivaz + vivero + vivir + vivo + volcán + volumen + volver + voraz + votar + voto + voz + vuelo + vulgar + yacer + yate + yegua + yema + yerno + yeso + yodo + yoga + yogur + zafiro + zanja + zapato + zarza + zona + zorro + zumo + zurdo + """ + return words.split(separator: "\n").map { String($0) } + }() + +} diff --git a/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/WordList/WordList+TraditionalChinese.swift b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/WordList/WordList+TraditionalChinese.swift new file mode 100644 index 00000000..0e569479 --- /dev/null +++ b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/WordList/WordList+TraditionalChinese.swift @@ -0,0 +1,2085 @@ +// +// WordList.swift +// +// Copyright © 2018 Kishikawa Katsumi +// Copyright © 2018 BitcoinKit developers +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// + +import Foundation + +// swiftlint:disable file_length +extension Mnemonic.WordList { + static var traditionalChinese: [String] = { + let words = + """ + 的 + 一 + 是 + 在 + 不 + 了 + 有 + 和 + 人 + 這 + 中 + 大 + 為 + 上 + 個 + 國 + 我 + 以 + 要 + 他 + 時 + 來 + 用 + 們 + 生 + 到 + 作 + 地 + 於 + 出 + 就 + 分 + 對 + 成 + 會 + 可 + 主 + 發 + 年 + 動 + 同 + 工 + 也 + 能 + 下 + 過 + 子 + 說 + 產 + 種 + 面 + 而 + 方 + 後 + 多 + 定 + 行 + 學 + 法 + 所 + 民 + 得 + 經 + 十 + 三 + 之 + 進 + 著 + 等 + 部 + 度 + 家 + 電 + 力 + 裡 + 如 + 水 + 化 + 高 + 自 + 二 + 理 + 起 + 小 + 物 + 現 + 實 + 加 + 量 + 都 + 兩 + 體 + 制 + 機 + 當 + 使 + 點 + 從 + 業 + 本 + 去 + 把 + 性 + 好 + 應 + 開 + 它 + 合 + 還 + 因 + 由 + 其 + 些 + 然 + 前 + 外 + 天 + 政 + 四 + 日 + 那 + 社 + 義 + 事 + 平 + 形 + 相 + 全 + 表 + 間 + 樣 + 與 + 關 + 各 + 重 + 新 + 線 + 內 + 數 + 正 + 心 + 反 + 你 + 明 + 看 + 原 + 又 + 麼 + 利 + 比 + 或 + 但 + 質 + 氣 + 第 + 向 + 道 + 命 + 此 + 變 + 條 + 只 + 沒 + 結 + 解 + 問 + 意 + 建 + 月 + 公 + 無 + 系 + 軍 + 很 + 情 + 者 + 最 + 立 + 代 + 想 + 已 + 通 + 並 + 提 + 直 + 題 + 黨 + 程 + 展 + 五 + 果 + 料 + 象 + 員 + 革 + 位 + 入 + 常 + 文 + 總 + 次 + 品 + 式 + 活 + 設 + 及 + 管 + 特 + 件 + 長 + 求 + 老 + 頭 + 基 + 資 + 邊 + 流 + 路 + 級 + 少 + 圖 + 山 + 統 + 接 + 知 + 較 + 將 + 組 + 見 + 計 + 別 + 她 + 手 + 角 + 期 + 根 + 論 + 運 + 農 + 指 + 幾 + 九 + 區 + 強 + 放 + 決 + 西 + 被 + 幹 + 做 + 必 + 戰 + 先 + 回 + 則 + 任 + 取 + 據 + 處 + 隊 + 南 + 給 + 色 + 光 + 門 + 即 + 保 + 治 + 北 + 造 + 百 + 規 + 熱 + 領 + 七 + 海 + 口 + 東 + 導 + 器 + 壓 + 志 + 世 + 金 + 增 + 爭 + 濟 + 階 + 油 + 思 + 術 + 極 + 交 + 受 + 聯 + 什 + 認 + 六 + 共 + 權 + 收 + 證 + 改 + 清 + 美 + 再 + 採 + 轉 + 更 + 單 + 風 + 切 + 打 + 白 + 教 + 速 + 花 + 帶 + 安 + 場 + 身 + 車 + 例 + 真 + 務 + 具 + 萬 + 每 + 目 + 至 + 達 + 走 + 積 + 示 + 議 + 聲 + 報 + 鬥 + 完 + 類 + 八 + 離 + 華 + 名 + 確 + 才 + 科 + 張 + 信 + 馬 + 節 + 話 + 米 + 整 + 空 + 元 + 況 + 今 + 集 + 溫 + 傳 + 土 + 許 + 步 + 群 + 廣 + 石 + 記 + 需 + 段 + 研 + 界 + 拉 + 林 + 律 + 叫 + 且 + 究 + 觀 + 越 + 織 + 裝 + 影 + 算 + 低 + 持 + 音 + 眾 + 書 + 布 + 复 + 容 + 兒 + 須 + 際 + 商 + 非 + 驗 + 連 + 斷 + 深 + 難 + 近 + 礦 + 千 + 週 + 委 + 素 + 技 + 備 + 半 + 辦 + 青 + 省 + 列 + 習 + 響 + 約 + 支 + 般 + 史 + 感 + 勞 + 便 + 團 + 往 + 酸 + 歷 + 市 + 克 + 何 + 除 + 消 + 構 + 府 + 稱 + 太 + 準 + 精 + 值 + 號 + 率 + 族 + 維 + 劃 + 選 + 標 + 寫 + 存 + 候 + 毛 + 親 + 快 + 效 + 斯 + 院 + 查 + 江 + 型 + 眼 + 王 + 按 + 格 + 養 + 易 + 置 + 派 + 層 + 片 + 始 + 卻 + 專 + 狀 + 育 + 廠 + 京 + 識 + 適 + 屬 + 圓 + 包 + 火 + 住 + 調 + 滿 + 縣 + 局 + 照 + 參 + 紅 + 細 + 引 + 聽 + 該 + 鐵 + 價 + 嚴 + 首 + 底 + 液 + 官 + 德 + 隨 + 病 + 蘇 + 失 + 爾 + 死 + 講 + 配 + 女 + 黃 + 推 + 顯 + 談 + 罪 + 神 + 藝 + 呢 + 席 + 含 + 企 + 望 + 密 + 批 + 營 + 項 + 防 + 舉 + 球 + 英 + 氧 + 勢 + 告 + 李 + 台 + 落 + 木 + 幫 + 輪 + 破 + 亞 + 師 + 圍 + 注 + 遠 + 字 + 材 + 排 + 供 + 河 + 態 + 封 + 另 + 施 + 減 + 樹 + 溶 + 怎 + 止 + 案 + 言 + 士 + 均 + 武 + 固 + 葉 + 魚 + 波 + 視 + 僅 + 費 + 緊 + 愛 + 左 + 章 + 早 + 朝 + 害 + 續 + 輕 + 服 + 試 + 食 + 充 + 兵 + 源 + 判 + 護 + 司 + 足 + 某 + 練 + 差 + 致 + 板 + 田 + 降 + 黑 + 犯 + 負 + 擊 + 范 + 繼 + 興 + 似 + 餘 + 堅 + 曲 + 輸 + 修 + 故 + 城 + 夫 + 夠 + 送 + 筆 + 船 + 佔 + 右 + 財 + 吃 + 富 + 春 + 職 + 覺 + 漢 + 畫 + 功 + 巴 + 跟 + 雖 + 雜 + 飛 + 檢 + 吸 + 助 + 昇 + 陽 + 互 + 初 + 創 + 抗 + 考 + 投 + 壞 + 策 + 古 + 徑 + 換 + 未 + 跑 + 留 + 鋼 + 曾 + 端 + 責 + 站 + 簡 + 述 + 錢 + 副 + 盡 + 帝 + 射 + 草 + 衝 + 承 + 獨 + 令 + 限 + 阿 + 宣 + 環 + 雙 + 請 + 超 + 微 + 讓 + 控 + 州 + 良 + 軸 + 找 + 否 + 紀 + 益 + 依 + 優 + 頂 + 礎 + 載 + 倒 + 房 + 突 + 坐 + 粉 + 敵 + 略 + 客 + 袁 + 冷 + 勝 + 絕 + 析 + 塊 + 劑 + 測 + 絲 + 協 + 訴 + 念 + 陳 + 仍 + 羅 + 鹽 + 友 + 洋 + 錯 + 苦 + 夜 + 刑 + 移 + 頻 + 逐 + 靠 + 混 + 母 + 短 + 皮 + 終 + 聚 + 汽 + 村 + 雲 + 哪 + 既 + 距 + 衛 + 停 + 烈 + 央 + 察 + 燒 + 迅 + 境 + 若 + 印 + 洲 + 刻 + 括 + 激 + 孔 + 搞 + 甚 + 室 + 待 + 核 + 校 + 散 + 侵 + 吧 + 甲 + 遊 + 久 + 菜 + 味 + 舊 + 模 + 湖 + 貨 + 損 + 預 + 阻 + 毫 + 普 + 穩 + 乙 + 媽 + 植 + 息 + 擴 + 銀 + 語 + 揮 + 酒 + 守 + 拿 + 序 + 紙 + 醫 + 缺 + 雨 + 嗎 + 針 + 劉 + 啊 + 急 + 唱 + 誤 + 訓 + 願 + 審 + 附 + 獲 + 茶 + 鮮 + 糧 + 斤 + 孩 + 脫 + 硫 + 肥 + 善 + 龍 + 演 + 父 + 漸 + 血 + 歡 + 械 + 掌 + 歌 + 沙 + 剛 + 攻 + 謂 + 盾 + 討 + 晚 + 粒 + 亂 + 燃 + 矛 + 乎 + 殺 + 藥 + 寧 + 魯 + 貴 + 鐘 + 煤 + 讀 + 班 + 伯 + 香 + 介 + 迫 + 句 + 豐 + 培 + 握 + 蘭 + 擔 + 弦 + 蛋 + 沉 + 假 + 穿 + 執 + 答 + 樂 + 誰 + 順 + 煙 + 縮 + 徵 + 臉 + 喜 + 松 + 腳 + 困 + 異 + 免 + 背 + 星 + 福 + 買 + 染 + 井 + 概 + 慢 + 怕 + 磁 + 倍 + 祖 + 皇 + 促 + 靜 + 補 + 評 + 翻 + 肉 + 踐 + 尼 + 衣 + 寬 + 揚 + 棉 + 希 + 傷 + 操 + 垂 + 秋 + 宜 + 氫 + 套 + 督 + 振 + 架 + 亮 + 末 + 憲 + 慶 + 編 + 牛 + 觸 + 映 + 雷 + 銷 + 詩 + 座 + 居 + 抓 + 裂 + 胞 + 呼 + 娘 + 景 + 威 + 綠 + 晶 + 厚 + 盟 + 衡 + 雞 + 孫 + 延 + 危 + 膠 + 屋 + 鄉 + 臨 + 陸 + 顧 + 掉 + 呀 + 燈 + 歲 + 措 + 束 + 耐 + 劇 + 玉 + 趙 + 跳 + 哥 + 季 + 課 + 凱 + 胡 + 額 + 款 + 紹 + 卷 + 齊 + 偉 + 蒸 + 殖 + 永 + 宗 + 苗 + 川 + 爐 + 岩 + 弱 + 零 + 楊 + 奏 + 沿 + 露 + 桿 + 探 + 滑 + 鎮 + 飯 + 濃 + 航 + 懷 + 趕 + 庫 + 奪 + 伊 + 靈 + 稅 + 途 + 滅 + 賽 + 歸 + 召 + 鼓 + 播 + 盤 + 裁 + 險 + 康 + 唯 + 錄 + 菌 + 純 + 借 + 糖 + 蓋 + 橫 + 符 + 私 + 努 + 堂 + 域 + 槍 + 潤 + 幅 + 哈 + 竟 + 熟 + 蟲 + 澤 + 腦 + 壤 + 碳 + 歐 + 遍 + 側 + 寨 + 敢 + 徹 + 慮 + 斜 + 薄 + 庭 + 納 + 彈 + 飼 + 伸 + 折 + 麥 + 濕 + 暗 + 荷 + 瓦 + 塞 + 床 + 築 + 惡 + 戶 + 訪 + 塔 + 奇 + 透 + 梁 + 刀 + 旋 + 跡 + 卡 + 氯 + 遇 + 份 + 毒 + 泥 + 退 + 洗 + 擺 + 灰 + 彩 + 賣 + 耗 + 夏 + 擇 + 忙 + 銅 + 獻 + 硬 + 予 + 繁 + 圈 + 雪 + 函 + 亦 + 抽 + 篇 + 陣 + 陰 + 丁 + 尺 + 追 + 堆 + 雄 + 迎 + 泛 + 爸 + 樓 + 避 + 謀 + 噸 + 野 + 豬 + 旗 + 累 + 偏 + 典 + 館 + 索 + 秦 + 脂 + 潮 + 爺 + 豆 + 忽 + 托 + 驚 + 塑 + 遺 + 愈 + 朱 + 替 + 纖 + 粗 + 傾 + 尚 + 痛 + 楚 + 謝 + 奮 + 購 + 磨 + 君 + 池 + 旁 + 碎 + 骨 + 監 + 捕 + 弟 + 暴 + 割 + 貫 + 殊 + 釋 + 詞 + 亡 + 壁 + 頓 + 寶 + 午 + 塵 + 聞 + 揭 + 炮 + 殘 + 冬 + 橋 + 婦 + 警 + 綜 + 招 + 吳 + 付 + 浮 + 遭 + 徐 + 您 + 搖 + 谷 + 贊 + 箱 + 隔 + 訂 + 男 + 吹 + 園 + 紛 + 唐 + 敗 + 宋 + 玻 + 巨 + 耕 + 坦 + 榮 + 閉 + 灣 + 鍵 + 凡 + 駐 + 鍋 + 救 + 恩 + 剝 + 凝 + 鹼 + 齒 + 截 + 煉 + 麻 + 紡 + 禁 + 廢 + 盛 + 版 + 緩 + 淨 + 睛 + 昌 + 婚 + 涉 + 筒 + 嘴 + 插 + 岸 + 朗 + 莊 + 街 + 藏 + 姑 + 貿 + 腐 + 奴 + 啦 + 慣 + 乘 + 夥 + 恢 + 勻 + 紗 + 扎 + 辯 + 耳 + 彪 + 臣 + 億 + 璃 + 抵 + 脈 + 秀 + 薩 + 俄 + 網 + 舞 + 店 + 噴 + 縱 + 寸 + 汗 + 掛 + 洪 + 賀 + 閃 + 柬 + 爆 + 烯 + 津 + 稻 + 牆 + 軟 + 勇 + 像 + 滾 + 厘 + 蒙 + 芳 + 肯 + 坡 + 柱 + 盪 + 腿 + 儀 + 旅 + 尾 + 軋 + 冰 + 貢 + 登 + 黎 + 削 + 鑽 + 勒 + 逃 + 障 + 氨 + 郭 + 峰 + 幣 + 港 + 伏 + 軌 + 畝 + 畢 + 擦 + 莫 + 刺 + 浪 + 秘 + 援 + 株 + 健 + 售 + 股 + 島 + 甘 + 泡 + 睡 + 童 + 鑄 + 湯 + 閥 + 休 + 匯 + 舍 + 牧 + 繞 + 炸 + 哲 + 磷 + 績 + 朋 + 淡 + 尖 + 啟 + 陷 + 柴 + 呈 + 徒 + 顏 + 淚 + 稍 + 忘 + 泵 + 藍 + 拖 + 洞 + 授 + 鏡 + 辛 + 壯 + 鋒 + 貧 + 虛 + 彎 + 摩 + 泰 + 幼 + 廷 + 尊 + 窗 + 綱 + 弄 + 隸 + 疑 + 氏 + 宮 + 姐 + 震 + 瑞 + 怪 + 尤 + 琴 + 循 + 描 + 膜 + 違 + 夾 + 腰 + 緣 + 珠 + 窮 + 森 + 枝 + 竹 + 溝 + 催 + 繩 + 憶 + 邦 + 剩 + 幸 + 漿 + 欄 + 擁 + 牙 + 貯 + 禮 + 濾 + 鈉 + 紋 + 罷 + 拍 + 咱 + 喊 + 袖 + 埃 + 勤 + 罰 + 焦 + 潛 + 伍 + 墨 + 欲 + 縫 + 姓 + 刊 + 飽 + 仿 + 獎 + 鋁 + 鬼 + 麗 + 跨 + 默 + 挖 + 鏈 + 掃 + 喝 + 袋 + 炭 + 污 + 幕 + 諸 + 弧 + 勵 + 梅 + 奶 + 潔 + 災 + 舟 + 鑑 + 苯 + 訟 + 抱 + 毀 + 懂 + 寒 + 智 + 埔 + 寄 + 屆 + 躍 + 渡 + 挑 + 丹 + 艱 + 貝 + 碰 + 拔 + 爹 + 戴 + 碼 + 夢 + 芽 + 熔 + 赤 + 漁 + 哭 + 敬 + 顆 + 奔 + 鉛 + 仲 + 虎 + 稀 + 妹 + 乏 + 珍 + 申 + 桌 + 遵 + 允 + 隆 + 螺 + 倉 + 魏 + 銳 + 曉 + 氮 + 兼 + 隱 + 礙 + 赫 + 撥 + 忠 + 肅 + 缸 + 牽 + 搶 + 博 + 巧 + 殼 + 兄 + 杜 + 訊 + 誠 + 碧 + 祥 + 柯 + 頁 + 巡 + 矩 + 悲 + 灌 + 齡 + 倫 + 票 + 尋 + 桂 + 鋪 + 聖 + 恐 + 恰 + 鄭 + 趣 + 抬 + 荒 + 騰 + 貼 + 柔 + 滴 + 猛 + 闊 + 輛 + 妻 + 填 + 撤 + 儲 + 簽 + 鬧 + 擾 + 紫 + 砂 + 遞 + 戲 + 吊 + 陶 + 伐 + 餵 + 療 + 瓶 + 婆 + 撫 + 臂 + 摸 + 忍 + 蝦 + 蠟 + 鄰 + 胸 + 鞏 + 擠 + 偶 + 棄 + 槽 + 勁 + 乳 + 鄧 + 吉 + 仁 + 爛 + 磚 + 租 + 烏 + 艦 + 伴 + 瓜 + 淺 + 丙 + 暫 + 燥 + 橡 + 柳 + 迷 + 暖 + 牌 + 秧 + 膽 + 詳 + 簧 + 踏 + 瓷 + 譜 + 呆 + 賓 + 糊 + 洛 + 輝 + 憤 + 競 + 隙 + 怒 + 粘 + 乃 + 緒 + 肩 + 籍 + 敏 + 塗 + 熙 + 皆 + 偵 + 懸 + 掘 + 享 + 糾 + 醒 + 狂 + 鎖 + 淀 + 恨 + 牲 + 霸 + 爬 + 賞 + 逆 + 玩 + 陵 + 祝 + 秒 + 浙 + 貌 + 役 + 彼 + 悉 + 鴨 + 趨 + 鳳 + 晨 + 畜 + 輩 + 秩 + 卵 + 署 + 梯 + 炎 + 灘 + 棋 + 驅 + 篩 + 峽 + 冒 + 啥 + 壽 + 譯 + 浸 + 泉 + 帽 + 遲 + 矽 + 疆 + 貸 + 漏 + 稿 + 冠 + 嫩 + 脅 + 芯 + 牢 + 叛 + 蝕 + 奧 + 鳴 + 嶺 + 羊 + 憑 + 串 + 塘 + 繪 + 酵 + 融 + 盆 + 錫 + 廟 + 籌 + 凍 + 輔 + 攝 + 襲 + 筋 + 拒 + 僚 + 旱 + 鉀 + 鳥 + 漆 + 沈 + 眉 + 疏 + 添 + 棒 + 穗 + 硝 + 韓 + 逼 + 扭 + 僑 + 涼 + 挺 + 碗 + 栽 + 炒 + 杯 + 患 + 餾 + 勸 + 豪 + 遼 + 勃 + 鴻 + 旦 + 吏 + 拜 + 狗 + 埋 + 輥 + 掩 + 飲 + 搬 + 罵 + 辭 + 勾 + 扣 + 估 + 蔣 + 絨 + 霧 + 丈 + 朵 + 姆 + 擬 + 宇 + 輯 + 陝 + 雕 + 償 + 蓄 + 崇 + 剪 + 倡 + 廳 + 咬 + 駛 + 薯 + 刷 + 斥 + 番 + 賦 + 奉 + 佛 + 澆 + 漫 + 曼 + 扇 + 鈣 + 桃 + 扶 + 仔 + 返 + 俗 + 虧 + 腔 + 鞋 + 棱 + 覆 + 框 + 悄 + 叔 + 撞 + 騙 + 勘 + 旺 + 沸 + 孤 + 吐 + 孟 + 渠 + 屈 + 疾 + 妙 + 惜 + 仰 + 狠 + 脹 + 諧 + 拋 + 黴 + 桑 + 崗 + 嘛 + 衰 + 盜 + 滲 + 臟 + 賴 + 湧 + 甜 + 曹 + 閱 + 肌 + 哩 + 厲 + 烴 + 緯 + 毅 + 昨 + 偽 + 症 + 煮 + 嘆 + 釘 + 搭 + 莖 + 籠 + 酷 + 偷 + 弓 + 錐 + 恆 + 傑 + 坑 + 鼻 + 翼 + 綸 + 敘 + 獄 + 逮 + 罐 + 絡 + 棚 + 抑 + 膨 + 蔬 + 寺 + 驟 + 穆 + 冶 + 枯 + 冊 + 屍 + 凸 + 紳 + 坯 + 犧 + 焰 + 轟 + 欣 + 晉 + 瘦 + 禦 + 錠 + 錦 + 喪 + 旬 + 鍛 + 壟 + 搜 + 撲 + 邀 + 亭 + 酯 + 邁 + 舒 + 脆 + 酶 + 閒 + 憂 + 酚 + 頑 + 羽 + 漲 + 卸 + 仗 + 陪 + 闢 + 懲 + 杭 + 姚 + 肚 + 捉 + 飄 + 漂 + 昆 + 欺 + 吾 + 郎 + 烷 + 汁 + 呵 + 飾 + 蕭 + 雅 + 郵 + 遷 + 燕 + 撒 + 姻 + 赴 + 宴 + 煩 + 債 + 帳 + 斑 + 鈴 + 旨 + 醇 + 董 + 餅 + 雛 + 姿 + 拌 + 傅 + 腹 + 妥 + 揉 + 賢 + 拆 + 歪 + 葡 + 胺 + 丟 + 浩 + 徽 + 昂 + 墊 + 擋 + 覽 + 貪 + 慰 + 繳 + 汪 + 慌 + 馮 + 諾 + 姜 + 誼 + 兇 + 劣 + 誣 + 耀 + 昏 + 躺 + 盈 + 騎 + 喬 + 溪 + 叢 + 盧 + 抹 + 悶 + 諮 + 刮 + 駕 + 纜 + 悟 + 摘 + 鉺 + 擲 + 頗 + 幻 + 柄 + 惠 + 慘 + 佳 + 仇 + 臘 + 窩 + 滌 + 劍 + 瞧 + 堡 + 潑 + 蔥 + 罩 + 霍 + 撈 + 胎 + 蒼 + 濱 + 倆 + 捅 + 湘 + 砍 + 霞 + 邵 + 萄 + 瘋 + 淮 + 遂 + 熊 + 糞 + 烘 + 宿 + 檔 + 戈 + 駁 + 嫂 + 裕 + 徙 + 箭 + 捐 + 腸 + 撐 + 曬 + 辨 + 殿 + 蓮 + 攤 + 攪 + 醬 + 屏 + 疫 + 哀 + 蔡 + 堵 + 沫 + 皺 + 暢 + 疊 + 閣 + 萊 + 敲 + 轄 + 鉤 + 痕 + 壩 + 巷 + 餓 + 禍 + 丘 + 玄 + 溜 + 曰 + 邏 + 彭 + 嘗 + 卿 + 妨 + 艇 + 吞 + 韋 + 怨 + 矮 + 歇 + """ + return words.split(separator: "\n").map { String($0) } + }() + +} diff --git a/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/WordList/WordList.swift b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/WordList/WordList.swift new file mode 100644 index 00000000..08b26f3e --- /dev/null +++ b/AtalaPrismSDK/Apollo/Sources/BIPs/BIP39/WordList/WordList.swift @@ -0,0 +1,35 @@ +// +// WordList.swift +// +// Copyright © 2018 Kishikawa Katsumi +// Copyright © 2018 BitcoinKit developers +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// + +import Foundation + +extension Mnemonic { + enum WordList {} +} + +extension Mnemonic.WordList { + /// `2^11 => 2048` + static let sizeLog2 = 11 +} diff --git a/AtalaPrismSDK/Apollo/Sources/Crypto/ECSigning.swift b/AtalaPrismSDK/Apollo/Sources/Crypto/ECSigning.swift new file mode 100644 index 00000000..4af66598 --- /dev/null +++ b/AtalaPrismSDK/Apollo/Sources/Crypto/ECSigning.swift @@ -0,0 +1,51 @@ +import CryptoKit +import Foundation +import secp256k1 + +struct ECSigning { + let data: Data + let privateKey: Data + + func signMessage() throws -> Data { + let ctx = secp256k1_context_create(UInt32(SECP256K1_CONTEXT_SIGN))! + defer { secp256k1_context_destroy(ctx) } + + let signature = UnsafeMutablePointer.allocate(capacity: 1) + defer { signature.deallocate() } + let status = data.withUnsafeBytes { (ptr: UnsafeRawBufferPointer) in + privateKey.withUnsafeBytes { + secp256k1_ecdsa_sign( + ctx, + signature, + ptr.bindMemory(to: UInt8.self).baseAddress.unsafelyUnwrapped, + $0.bindMemory(to: UInt8.self).baseAddress.unsafelyUnwrapped, + nil, + nil + ) + } + } + guard status == 1 else { throw CryptoError.signFailed } + + let normalizedsig = UnsafeMutablePointer.allocate(capacity: 1) + defer { normalizedsig.deallocate() } + secp256k1_ecdsa_signature_normalize(ctx, normalizedsig, signature) + + var length: size_t = 128 + var der = Data(count: length) + guard der.withUnsafeMutableBytes({ + return secp256k1_ecdsa_signature_serialize_der( + ctx, + $0.bindMemory(to: UInt8.self).baseAddress.unsafelyUnwrapped, + &length, + normalizedsig + ) }) == 1 else { throw CryptoError.noEnoughSpace } + der.count = length + + return der + } + + public enum CryptoError: Error { + case signFailed + case noEnoughSpace + } +} diff --git a/AtalaPrismSDK/Apollo/Sources/Crypto/ECVerify.swift b/AtalaPrismSDK/Apollo/Sources/Crypto/ECVerify.swift new file mode 100644 index 00000000..9d386115 --- /dev/null +++ b/AtalaPrismSDK/Apollo/Sources/Crypto/ECVerify.swift @@ -0,0 +1,62 @@ +// +// File.swift +// +// +// Created by Goncalo Frade IOHK on 07/03/2023. +// + +import Foundation +import secp256k1 + +struct ECVerify { + let signature: Data + let message: Data + let publicKey: Data + + + func verifySignature() throws -> Bool { + let ctx = secp256k1_context_create(UInt32(SECP256K1_CONTEXT_VERIFY))! + defer { secp256k1_context_destroy(ctx) } + + let signaturePointer = UnsafeMutablePointer.allocate(capacity: 1) + defer { signaturePointer.deallocate() } + guard signature.withUnsafeBytes({ + secp256k1_ecdsa_signature_parse_der( + ctx, + signaturePointer, + $0.bindMemory(to: UInt8.self).baseAddress.unsafelyUnwrapped, + signature.count + ) + }) == 1 else { + throw CryptoError.signatureParseFailed + } + + let pubkeyPointer = UnsafeMutablePointer.allocate(capacity: 1) + defer { pubkeyPointer.deallocate() } + guard publicKey.withUnsafeBytes({ + secp256k1_ec_pubkey_parse( + ctx, + pubkeyPointer, + $0.bindMemory(to: UInt8.self).baseAddress.unsafelyUnwrapped, + publicKey.count + ) }) == 1 else { + throw CryptoError.publicKeyParseFailed + } + + guard message.withUnsafeBytes ({ + secp256k1_ecdsa_verify( + ctx, + signaturePointer, + $0.bindMemory(to: UInt8.self).baseAddress.unsafelyUnwrapped, + pubkeyPointer) }) == 1 else { + return false + } + + return true + } + + public enum CryptoError: Error { + case signatureParseFailed + case publicKeyParseFailed + } +} diff --git a/AtalaPrismSDK/Apollo/Sources/Extensions/CompressedPublicKey+Helpers.swift b/AtalaPrismSDK/Apollo/Sources/Extensions/CompressedPublicKey+Helpers.swift deleted file mode 100644 index c13597d6..00000000 --- a/AtalaPrismSDK/Apollo/Sources/Extensions/CompressedPublicKey+Helpers.swift +++ /dev/null @@ -1,11 +0,0 @@ -import Domain -import Foundation -import PrismAPI - -public extension CompressedPublicKey { - init(compressedData: Data) { - let ec = EC() - let publicKey = ec.toPublicKeyFromCompressed(compressed: compressedData.toKotlinByteArray()) - self.init(uncompressed: Domain.PublicKey(fromEC: publicKey), value: compressedData) - } -} diff --git a/AtalaPrismSDK/Apollo/Sources/Extensions/Data+Extensions.swift b/AtalaPrismSDK/Apollo/Sources/Extensions/Data+Extensions.swift new file mode 100644 index 00000000..8246214f --- /dev/null +++ b/AtalaPrismSDK/Apollo/Sources/Extensions/Data+Extensions.swift @@ -0,0 +1,39 @@ +// +// Data_Extensions.swift +// +// Copyright © 2018 BitcoinKit developers +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// + +import Foundation + +extension Data { + + var binaryString: String { + var result: [String] = [] + for byte in self { + let byteString = String(byte, radix: 2) + let padding = String(repeating: "0", + count: 8 - byteString.count) + result.append(padding + byteString) + } + return result.joined() + } +} diff --git a/AtalaPrismSDK/Apollo/Sources/Extensions/FixedWidthInteger+Extensions.swift b/AtalaPrismSDK/Apollo/Sources/Extensions/FixedWidthInteger+Extensions.swift new file mode 100644 index 00000000..5a8ad613 --- /dev/null +++ b/AtalaPrismSDK/Apollo/Sources/Extensions/FixedWidthInteger+Extensions.swift @@ -0,0 +1,39 @@ +// +// FixedWidthInteger_Extensions.swift +// +// Copyright © 2018 BitcoinKit developers +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// + +import Foundation + +extension FixedWidthInteger { + var binaryString: String { + var result: [String] = [] + for i in 0..<(Self.bitWidth / 8) { + let byte = UInt8(truncatingIfNeeded: self >> (i * 8)) + let byteString = String(byte, radix: 2) + let padding = String(repeating: "0", + count: 8 - byteString.count) + result.append(padding + byteString) + } + return result.reversed().joined() + } +} diff --git a/AtalaPrismSDK/Apollo/Sources/Extensions/PrivateKey+Helpers.swift b/AtalaPrismSDK/Apollo/Sources/Extensions/PrivateKey+Helpers.swift deleted file mode 100644 index 631db74b..00000000 --- a/AtalaPrismSDK/Apollo/Sources/Extensions/PrivateKey+Helpers.swift +++ /dev/null @@ -1,9 +0,0 @@ -import Domain -import Foundation -import PrismAPI - -extension Domain.PrivateKey { - init(curve: KeyCurve, fromEC: ECPrivateKey) { - self.init(curve: curve, value: fromEC.getEncoded().toData()) - } -} diff --git a/AtalaPrismSDK/Apollo/Sources/Extensions/PublicKey+Compressed.swift b/AtalaPrismSDK/Apollo/Sources/Extensions/PublicKey+Compressed.swift deleted file mode 100644 index cbf251b0..00000000 --- a/AtalaPrismSDK/Apollo/Sources/Extensions/PublicKey+Compressed.swift +++ /dev/null @@ -1,18 +0,0 @@ -import Domain -import Foundation -import PrismAPI - -extension Domain.PublicKey { - init(fromEC: ECPublicKey) { - self.init(curve: ECConfig().CURVE_NAME, value: fromEC.getEncoded().toData()) - } - - public func compressed() -> CompressedPublicKey { - let ec = EC() - let publicKey = ec.toPublicKeyFromBytes(encoded: value.toKotlinByteArray()) - return CompressedPublicKey( - uncompressed: self, - value: publicKey.getEncodedCompressed().toData() - ) - } -} diff --git a/AtalaPrismSDK/Apollo/Sources/Extensions/RangeReplaceableCollection+Extensions.swift b/AtalaPrismSDK/Apollo/Sources/Extensions/RangeReplaceableCollection+Extensions.swift new file mode 100644 index 00000000..203935bc --- /dev/null +++ b/AtalaPrismSDK/Apollo/Sources/Extensions/RangeReplaceableCollection+Extensions.swift @@ -0,0 +1,54 @@ +// +// RangeReplaceableCollection_Extensions.swift +// +// Copyright © 2018 BitcoinKit developers +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// +import Foundation + +extension RangeReplaceableCollection where Self: MutableCollection { + + /// Equivalence to Python's operator on lists: `[:n]`, e.g. `x = [1, 2, 3, 4, 5]; x[:3] // equals: [1, 2, 3]` + func prefix(maxCount: Int) -> Self { + return Self(self.prefix(maxCount)) + } + + /// Equivalent to Python's `[-n]`, e.g.`"Hello"[-3] // equals: "llo"` + func suffix(maxCount: Int) -> Self { + return Self(self.suffix(maxCount)) + } + + /// Equivalence to Python's operator on string: `[:-n]`, e.g.`"Hello"[:-3] // equals: "He"` + func prefix(subtractFromCount n: Int) -> Self { + let specifiedCount = count - n + guard specifiedCount > 0 else { return Self() } + return prefix(maxCount: specifiedCount) + } + + func splitIntoChunks(ofSize maxLength: Int) -> [Self] { + precondition(maxLength > 0, "groups must be greater than zero") + var start = startIndex + return stride(from: 0, to: count, by: maxLength).map { _ in + let end = index(start, offsetBy: maxLength, limitedBy: endIndex) ?? endIndex + defer { start = end } + return Self(self[start.. KotlinByteArray { - let result = KotlinByteArray(size: Int32(count)) - for index in indices { - result.set(index: Int32(index), value: Int8(bitPattern: self[index])) - } - return result - } -} - -extension Array where Element == Int8 { - func toKotlinByteArray() -> KotlinByteArray { - let result = KotlinByteArray(size: Int32(count)) - for index in indices { - result.set(index: Int32(index), value: self[index]) - } - return result - } -} - -extension KotlinByteArray { - func toData() -> Data { - let kotlinByteArray = self - var data = Data(count: Int(kotlinByteArray.size)) - for index in data.indices { - data[index] = UInt8(bitPattern: kotlinByteArray.get(index: Int32(index))) - } - return data - } -} diff --git a/AtalaPrismSDK/Apollo/Sources/Helper/PointOnCurve.swift b/AtalaPrismSDK/Apollo/Sources/Helper/PointOnCurve.swift new file mode 100644 index 00000000..2325f9f3 --- /dev/null +++ b/AtalaPrismSDK/Apollo/Sources/Helper/PointOnCurve.swift @@ -0,0 +1,91 @@ +// +// PointOnCurve.swift +// +// Copyright © 2018 BitcoinKit developers +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// + +import Foundation +import secp256k1 + +struct PointOnCurve { + + private static let byteForUncompressed: UInt8 = 0x04 + let x: Scalar32Bytes + let y: Scalar32Bytes + + init(x: Scalar32Bytes, y: Scalar32Bytes) { + self.x = x + self.y = y + } + + init(x xData: Data, y yData: Data) throws { + let x = try Scalar32Bytes(data: xData) + let y = try Scalar32Bytes(data: yData) + self.init(x: x, y: y) + } +} + +extension PointOnCurve { + enum Error: Swift.Error { + case multiplicationResultedInTooFewBytes(expected: Int, butGot: Int) + case expectedUncompressedPoint + case publicKeyContainsTooFewBytes(expected: Int, butGot: Int) + } + +// static func decodePointFromPublicKey(_ publicKey: LockPublicKey) throws -> PointOnCurve { +// let data: Data +// if publicKey.isCompressed { +// data = _EllipticCurve.decodePointOnCurve(forCompressedPublicKey: publicKey.data) +// } else { +// data = publicKey.data +// } +// return try PointOnCurve.decodePointFrom(xAndYPrefixedWithCompressionType: data) +// } +// +// private static func decodePointFrom(xAndYPrefixedWithCompressionType data: Data) throws -> PointOnCurve { +// var xAndY = data +// guard xAndY[0] == PointOnCurve.byteForUncompressed else { +// throw Error.expectedUncompressedPoint +// } +// xAndY = Data(xAndY.dropFirst()) +// let expectedByteCount = Scalar32Bytes.expectedByteCount * 2 +// guard xAndY.count == expectedByteCount else { +// throw Error.multiplicationResultedInTooFewBytes(expected: expectedByteCount, butGot: xAndY.count) +// } +// let resultX = xAndY.prefix(Scalar32Bytes.expectedByteCount) +// let resultY = xAndY.suffix(Scalar32Bytes.expectedByteCount) +// return try PointOnCurve(x: resultX, y: resultY) +// } +// +// func multiplyBy(scalar: Scalar32Bytes) throws -> PointOnCurve { +// let xAndY = _EllipticCurve.multiplyECPointX(x.data, andECPointY: y.data, withScalar: scalar.data) +// return try PointOnCurve.decodePointFrom(xAndYPrefixedWithCompressionType: xAndY) +// } +// +// func multiplyBy(privateKey: LockPrivateKey) throws -> PointOnCurve { +// return try multiplyBy(scalar: privateKey.data) +// } +// +// func multiplyBy(scalar scalarData: Data) throws -> PointOnCurve { +// let scalar = try Scalar32Bytes(data: scalarData) +// return try multiplyBy(scalar: scalar) +// } +} diff --git a/AtalaPrismSDK/Apollo/Sources/Helper/Scalar32Bytes.swift b/AtalaPrismSDK/Apollo/Sources/Helper/Scalar32Bytes.swift new file mode 100644 index 00000000..84a49d52 --- /dev/null +++ b/AtalaPrismSDK/Apollo/Sources/Helper/Scalar32Bytes.swift @@ -0,0 +1,40 @@ +// +// Scalar32Bytes.swift +// +// Copyright © 2018 BitcoinKit developers +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// + +import Foundation + +public struct Scalar32Bytes { + public enum Error: Swift.Error { + case tooManyBytes(expectedCount: Int, butGot: Int) + } + public static let expectedByteCount = 32 + public let data: Data + public init(data: Data) throws { + let byteCount = data.count + if byteCount > Scalar32Bytes.expectedByteCount { + throw Error.tooManyBytes(expectedCount: Scalar32Bytes.expectedByteCount, butGot: byteCount) + } + self.data = data + } +} diff --git a/AtalaPrismSDK/Apollo/Sources/Helper/SecureGenerateBytes.swift b/AtalaPrismSDK/Apollo/Sources/Helper/SecureGenerateBytes.swift new file mode 100644 index 00000000..9c7a422a --- /dev/null +++ b/AtalaPrismSDK/Apollo/Sources/Helper/SecureGenerateBytes.swift @@ -0,0 +1,33 @@ +// +// Copyright © 2018 BitcoinKit developers +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// + +import Core +import Foundation +import Security + +func securelyGenerateBytes(count: Int) throws -> Data { + var randomBytes = [UInt8](repeating: 0, count: count) + let statusRaw = SecRandomCopyBytes(kSecRandomDefault, count, &randomBytes) as OSStatus + let status = Status(status: statusRaw) + guard status == .success else { throw status } + return Data(randomBytes) +} diff --git a/AtalaPrismSDK/Apollo/Sources/Operations/CreateSec256k1KeyPairOperation.swift b/AtalaPrismSDK/Apollo/Sources/Operations/CreateSec256k1KeyPairOperation.swift index 11d7ac08..79f0d860 100644 --- a/AtalaPrismSDK/Apollo/Sources/Operations/CreateSec256k1KeyPairOperation.swift +++ b/AtalaPrismSDK/Apollo/Sources/Operations/CreateSec256k1KeyPairOperation.swift @@ -1,7 +1,6 @@ import Core import Domain import Foundation -import PrismAPI struct CreateSec256k1KeyPairOperation { struct KeyPath { @@ -18,37 +17,27 @@ struct CreateSec256k1KeyPairOperation { } let logger: PrismLogger - let keyDerivation = KeyDerivation() let seed: Seed let keyPath: KeyPath - init(logger: PrismLogger, seed: Seed, keyPath: KeyPath) { + init(logger: PrismLogger = PrismLogger(category: .apollo), seed: Seed, keyPath: KeyPath) { self.logger = logger self.seed = seed self.keyPath = keyPath } - func compute() -> KeyPair { - let newDerivationPath = DerivationPath.Companion().fromPath(path: keyPath.keyPathString()) - logger.debug(message: "New Derivation path from \(keyPath.keyPathString())") - let newKey = keyDerivation.deriveKey(seed: seed.value.toKotlinByteArray(), path: newDerivationPath) - logger.debug(message: "KeyPair created", metadata: [ - .privateMetadataByLevel( - key: "privateKey", - value: newKey.privateKey().getEncoded().toData().description, - level: .debug + func compute() throws -> KeyPair { + let derivedKey = try HDKeychain(seed: seed.value).derivedKey(path: keyPath.keyPathString()) + + return .init( + privateKey: .init( + curve: .secp256k1(index: keyPath.index), + value: derivedKey.privateKey().data ), - .privateMetadataByLevel( - key: "publicKey", - value: newKey.privateKey().getEncoded().toData().description, - level: .debug + publicKey: .init( + curve: KeyCurve.secp256k1(index: keyPath.index).name, + value: derivedKey.extendedPublicKey().publicKey().data ) - ]) - - return KeyPair( - curve: .secp256k1(index: keyPath.index), - privateKey: PrivateKey(curve: .secp256k1(index: keyPath.index), fromEC: newKey.keyPair().privateKey), - publicKey: PublicKey(fromEC: newKey.keyPair().publicKey) ) } } diff --git a/AtalaPrismSDK/Apollo/Sources/Operations/CreateSeedOperation.swift b/AtalaPrismSDK/Apollo/Sources/Operations/CreateSeedOperation.swift index fb4515d0..277f91f3 100644 --- a/AtalaPrismSDK/Apollo/Sources/Operations/CreateSeedOperation.swift +++ b/AtalaPrismSDK/Apollo/Sources/Operations/CreateSeedOperation.swift @@ -1,19 +1,22 @@ import Core import Domain import Foundation -import PrismAPI struct CreateSeedOperation { - let keyDerivation = KeyDerivation() let logger: PrismLogger let words: [String] let passphrase: String - init(logger: PrismLogger, words: [String], passphrase: String = "") throws { + init( + logger: PrismLogger = .init(category: .apollo), + words: [String], + passphrase: String = "" + ) throws { self.logger = logger self.words = words self.passphrase = passphrase - let invalidWords = words.filter { !keyDerivation.isValidMnemonicWord(word: $0) } + let validWords = Mnemonic.wordList(for: .english) + let invalidWords = Set(words).subtracting(Set(validWords)) guard invalidWords.isEmpty else { logger.error( message: "Invalid mnemonic word", @@ -23,16 +26,14 @@ struct CreateSeedOperation { .publicMetadata(key: "word\($0)", value: $1) } ) - throw ApolloError.invalidMnemonicWord(invalidWords: invalidWords) + throw ApolloError.invalidMnemonicWord(invalidWords: Array(invalidWords)) } } - func compute() -> Seed { - Seed(value: keyDerivation - .binarySeed( - seed: MnemonicCode(words: words), - passphrase: passphrase - ).toData() - ) + func compute() throws -> Seed { + Seed(value: try Mnemonic.seed( + mnemonic: words, + passphrase: passphrase + )) } } diff --git a/AtalaPrismSDK/Apollo/Sources/Operations/RandomMnemonicsOperation.swift b/AtalaPrismSDK/Apollo/Sources/Operations/RandomMnemonicsOperation.swift index 160b84a4..4a71fc3a 100644 --- a/AtalaPrismSDK/Apollo/Sources/Operations/RandomMnemonicsOperation.swift +++ b/AtalaPrismSDK/Apollo/Sources/Operations/RandomMnemonicsOperation.swift @@ -1,12 +1,10 @@ import Core import Foundation -import PrismAPI struct RandomMnemonicsOperation { - let keyDerivation = KeyDerivation() let logger: PrismLogger func compute() -> [String] { - keyDerivation.randomMnemonicCode().words + (try? Mnemonic.generate(strength: .veryHigh)) ?? [] } } diff --git a/AtalaPrismSDK/Apollo/Sources/Operations/SignMessageOperation.swift b/AtalaPrismSDK/Apollo/Sources/Operations/SignMessageOperation.swift index 4cf7755e..3539e63d 100644 --- a/AtalaPrismSDK/Apollo/Sources/Operations/SignMessageOperation.swift +++ b/AtalaPrismSDK/Apollo/Sources/Operations/SignMessageOperation.swift @@ -1,27 +1,29 @@ import Core +import CryptoKit import Domain import Foundation -import PrismAPI struct SignMessageOperation { let logger: PrismLogger let privateKey: Domain.PrivateKey let message: Data - func compute() -> Signature { - logger.debug( - message: "Signing message", - metadata: [ - .maskedMetadata(key: "message", value: message.description) - ] - ) + init( + logger: PrismLogger = PrismLogger(category: .apollo), + privateKey: Domain.PrivateKey, + message: Data + ) { + self.logger = logger + self.privateKey = privateKey + self.message = message + } - let ec = EC() - let ecPrivateKey = ec.toPrivateKeyFromBytes(encoded: privateKey.value.toKotlinByteArray()) - logger.debug(message: "Decoded internaly the private key") - return Signature(value: ec.signBytes( - data: message.toKotlinByteArray(), - privateKey: ecPrivateKey - ).getEncoded().toData()) + func compute() throws -> Signature { + return Signature( + value: try ECSigning( + data: Data(SHA256.hash(data: message)), + privateKey: privateKey.value + ).signMessage() + ) } } diff --git a/AtalaPrismSDK/Apollo/Sources/Operations/VerifySignatureOperation.swift b/AtalaPrismSDK/Apollo/Sources/Operations/VerifySignatureOperation.swift index 9b2d9573..a5803c6a 100644 --- a/AtalaPrismSDK/Apollo/Sources/Operations/VerifySignatureOperation.swift +++ b/AtalaPrismSDK/Apollo/Sources/Operations/VerifySignatureOperation.swift @@ -1,7 +1,7 @@ import Core +import CryptoKit import Domain import Foundation -import PrismAPI struct VerifySignatureOperation { let logger: PrismLogger @@ -9,29 +9,23 @@ struct VerifySignatureOperation { let challenge: Data let signature: Signature - func compute() -> Bool { - logger.debug( - message: "Verifying signature", - metadata: [ - .maskedMetadata(key: "challenge", value: challenge.description), - .publicMetadata(key: "signature", value: signature.value.description) - ] - ) - let ec = EC() - let publicKey = ec.toPublicKeyFromBytes(encoded: publicKey.value.toKotlinByteArray()) - logger.debug(message: "Decoded internaly the public key") - let verification = ec.verifyBytes( - data: challenge.toKotlinByteArray(), - publicKey: publicKey, - signature: ec.toSignatureFromBytes(encoded: signature.value.toKotlinByteArray()) - ) - logger.debug( - message: "Signature verification \(verification ? "succeded" : "failed")", - metadata: [ - .maskedMetadata(key: "challenge", value: challenge.description), - .publicMetadata(key: "signature", value: signature.value.description) - ] - ) - return verification + init( + logger: PrismLogger = PrismLogger(category: .apollo), + publicKey: Domain.PublicKey, + challenge: Data, + signature: Signature + ) { + self.logger = logger + self.publicKey = publicKey + self.challenge = challenge + self.signature = signature + } + + func compute() throws -> Bool { + try ECVerify( + signature: signature.value, + message: Data(SHA256.hash(data: challenge)), + publicKey: publicKey.value + ).verifySignature() } } diff --git a/AtalaPrismSDK/Apollo/Tests/ApolloTest.swift b/AtalaPrismSDK/Apollo/Tests/ApolloTest.swift deleted file mode 100644 index 1a0a45df..00000000 --- a/AtalaPrismSDK/Apollo/Tests/ApolloTest.swift +++ /dev/null @@ -1 +0,0 @@ -// This file is just here as a foolproof/template since for Swift Packages a module source always have to have at least one Swift file diff --git a/AtalaPrismSDK/Apollo/Tests/BIP32Tests.swift b/AtalaPrismSDK/Apollo/Tests/BIP32Tests.swift new file mode 100644 index 00000000..72be2901 --- /dev/null +++ b/AtalaPrismSDK/Apollo/Tests/BIP32Tests.swift @@ -0,0 +1,29 @@ +@testable import Apollo +import Core +import Domain +import XCTest + +final class BIP32Tests: XCTestCase { + + let mnemonics = ["blade", "multiply", "coil", "rare", "fox", "doll", "tongue", "please", "icon", "mind", "gesture", "moral", "old", "laugh", "symptom", "assume", "burden", "appear", "always", "oil", "ticket", "vault", "return", "height"] + + func testBip32RootKeyGeneration() throws { + let seed = try CreateSeedOperation(words: mnemonics).compute() + let operation = CreateSec256k1KeyPairOperation(seed: seed, keyPath: .init(index: 0)) + let privateKey = try operation.compute() + XCTAssertEqual( + privateKey.privateKey.value.base64UrlEncodedString(), + "xURclKhT6as1Tb9vg4AJRRLPAMWb9dYTTthDvXEKjMc" + ) + } + + func testBip32KeyPathGeneration() throws { + let seed = try CreateSeedOperation(words: mnemonics).compute() + let operation = CreateSec256k1KeyPairOperation(seed: seed, keyPath: .init(index: 3)) + let privateKey = try operation.compute() + XCTAssertEqual( + privateKey.privateKey.value.base64UrlEncodedString(), + "N_JFgvYaReyRXwassz5FHg33A4I6dczzdXrjdHGksmg" + ) + } +} diff --git a/AtalaPrismSDK/Apollo/Tests/BIP39Tests.swift b/AtalaPrismSDK/Apollo/Tests/BIP39Tests.swift new file mode 100644 index 00000000..0dafaf0a --- /dev/null +++ b/AtalaPrismSDK/Apollo/Tests/BIP39Tests.swift @@ -0,0 +1,24 @@ +@testable import Apollo +import XCTest + +final class BIP39Tests: XCTestCase { + + let mnemonics = ["blade", "multiply", "coil", "rare", "fox", "doll", "tongue", "please", "icon", "mind", "gesture", "moral", "old", "laugh", "symptom", "assume", "burden", "appear", "always", "oil", "ticket", "vault", "return", "height"] + + func testBip39SeedGeneration_WithoutPassword() throws { + let seed = try CreateSeedOperation(words: mnemonics).compute() + XCTAssertEqual( + seed.value.base64UrlEncodedString(), + "e8uNN7LRH5mEUcxa7FhxDAgWGLh8P94WEOD0jUdaJ2mSU1o02u-Lzao50elV32XvYT0ux9jWuBVECpFAz2ckKw" + ) + } + + func testBip39SeedGeneration_WithPassword() throws { + let seed = try CreateSeedOperation(words: mnemonics, passphrase: "test").compute() + XCTAssertEqual( + seed.value.base64UrlEncodedString(), + "g-p5YM9M38keYsz760BqRQrEU-bhvU4Lc9ml0_IUowtaHH60XkkZKERjOiS_HugFSzGuU0cmCdziWEikGpiCDA" + ) + } + +} diff --git a/AtalaPrismSDK/Apollo/Tests/ECSigningTests.swift b/AtalaPrismSDK/Apollo/Tests/ECSigningTests.swift new file mode 100644 index 00000000..ddfc32b9 --- /dev/null +++ b/AtalaPrismSDK/Apollo/Tests/ECSigningTests.swift @@ -0,0 +1,24 @@ +@testable import Apollo +import Core +import Domain +import XCTest + +final class ECSigningTests: XCTestCase { + func testSigning() throws { + let privKey = PrivateKey( + curve: .secp256k1(index: 0), + value: Data(fromBase64URL: "xURclKhT6as1Tb9vg4AJRRLPAMWb9dYTTthDvXEKjMc")! + ) + let testMessage = "test".data(using: .utf8)! + + let signing = try SignMessageOperation( + privateKey: privKey, + message: testMessage + ).compute() + + XCTAssertEqual( + signing.value.base64UrlEncodedString(), + "MEUCIQDJroM8wtcJovEyZjl2unJpKZ_kbicRjPCJ2krzQzK31QIgcpe5CwIIXUrP63qOT-WzzmxVplHGhSO8R8h5-1ECKt4" + ) + } +} diff --git a/AtalaPrismSDK/Apollo/Tests/ECVerifyTests.swift b/AtalaPrismSDK/Apollo/Tests/ECVerifyTests.swift new file mode 100644 index 00000000..4d97e2eb --- /dev/null +++ b/AtalaPrismSDK/Apollo/Tests/ECVerifyTests.swift @@ -0,0 +1,25 @@ +@testable import Apollo +import Core +import Domain +import XCTest + +final class ECVerification: XCTestCase { + + func testVerify() throws { + let pubKey = PublicKey( + curve: KeyCurve.secp256k1().name, + value: Data(fromBase64URL: "BHza5mV6_Iz6XdyMpxpjUMprZUCN_MpMuQCTFYpxSf8rW7N7DD04troywCgLkg0_ABP-IcxZcE1-qKjwCWYTVO8")! + ) + let testMessage = "test".data(using: .utf8)! + + XCTAssertTrue(try VerifySignatureOperation( + publicKey: pubKey, + challenge: testMessage, + signature: Signature( + value: Data( + fromBase64URL: "MEUCIQDJroM8wtcJovEyZjl2unJpKZ_kbicRjPCJ2krzQzK31QIgcpe5CwIIXUrP63qOT-WzzmxVplHGhSO8R8h5-1ECKt4")! + ) + ).compute()) + } + +} diff --git a/AtalaPrismSDK/Apollo/Tests/PublicKeyCompressionTests.swift b/AtalaPrismSDK/Apollo/Tests/PublicKeyCompressionTests.swift new file mode 100644 index 00000000..4e348d73 --- /dev/null +++ b/AtalaPrismSDK/Apollo/Tests/PublicKeyCompressionTests.swift @@ -0,0 +1,18 @@ +@testable import Apollo +import XCTest + +final class PublicKeyCompressionTests: XCTestCase { + + func testCompressPublicKey() throws { + let privateKey = LockPrivateKey(data: Data(fromBase64URL: "xURclKhT6as1Tb9vg4AJRRLPAMWb9dYTTthDvXEKjMc")!) + + let pubKey = privateKey.publicKey() + print("Is key compressed: \(pubKey.isCompressed)") + + let compressedPubKey = pubKey.compressedPublicKey() + print("Is key compressed: \(compressedPubKey.isCompressed)") + + let uncompressedPubKey = pubKey.uncompressedPublicKey() + print("Is key compressed: \(uncompressedPubKey.isCompressed)") + } +} diff --git a/AtalaPrismSDK/Castor/Sources/CastorImpl+Public.swift b/AtalaPrismSDK/Castor/Sources/CastorImpl+Public.swift index 0b419c7c..c7c8622a 100644 --- a/AtalaPrismSDK/Castor/Sources/CastorImpl+Public.swift +++ b/AtalaPrismSDK/Castor/Sources/CastorImpl+Public.swift @@ -57,9 +57,17 @@ extension CastorImpl: Castor { /// - signature: The signature data to verify /// - Returns: A boolean value indicating whether the signature is valid or not /// - Throws: An error if the DID or signature data are invalid - public func verifySignature(did: DID, challenge: Data, signature: Data) async throws -> Bool { + public func verifySignature( + did: DID, + challenge: Data, + signature: Data + ) async throws -> Bool { let document = try await resolveDID(did: did) - return verifySignature(document: document, challenge: challenge, signature: signature) + return try verifySignature( + document: document, + challenge: challenge, + signature: signature + ) } /// verifySignature verifies the authenticity of a signature using the corresponding DID Document, challenge, and signature data. This function returns a boolean value indicating whether the signature is valid or not. This function may throw an error if the DID Document or signature data are invalid. @@ -74,8 +82,8 @@ extension CastorImpl: Castor { document: DIDDocument, challenge: Data, signature: Data - ) -> Bool { - return VerifyDIDSignatureOperation( + ) throws -> Bool { + return try VerifyDIDSignatureOperation( apollo: apollo, document: document, challenge: challenge, diff --git a/AtalaPrismSDK/Castor/Sources/DID/PrismDID/PrismDIDPublicKey.swift b/AtalaPrismSDK/Castor/Sources/DID/PrismDID/PrismDIDPublicKey.swift index f0537d82..e6b3f175 100644 --- a/AtalaPrismSDK/Castor/Sources/DID/PrismDID/PrismDIDPublicKey.swift +++ b/AtalaPrismSDK/Castor/Sources/DID/PrismDID/PrismDIDPublicKey.swift @@ -77,7 +77,7 @@ struct PrismDIDPublicKey { usage = proto.usage.fromProto() switch proto.keyData { case let .compressedEcKeyData(value): - keyData = apollo.compressedPublicKey(compressedData: value.data).uncompressed + keyData = apollo.uncompressedPublicKey(compressedData: value.data) default: throw CastorError.invalidPublicKeyCoding(didMethod: "prism", curve: "secp256k1") } diff --git a/AtalaPrismSDK/Castor/Sources/Operations/VerifyDIDSignatureOperation.swift b/AtalaPrismSDK/Castor/Sources/Operations/VerifyDIDSignatureOperation.swift index aa35a8e8..e0cda8fb 100644 --- a/AtalaPrismSDK/Castor/Sources/Operations/VerifyDIDSignatureOperation.swift +++ b/AtalaPrismSDK/Castor/Sources/Operations/VerifyDIDSignatureOperation.swift @@ -8,11 +8,11 @@ struct VerifyDIDSignatureOperation { let challenge: Data let signature: Data - func compute() -> Bool { - return document.authenticate + func compute() throws -> Bool { + return try document.authenticate .compactMap { $0.publicKey } .contains { - apollo.verifySignature( + try apollo.verifySignature( publicKey: $0, challenge: challenge, signature: Signature(value: signature) diff --git a/AtalaPrismSDK/Castor/Tests/PrismDIDPublicKeyTests.swift b/AtalaPrismSDK/Castor/Tests/PrismDIDPublicKeyTests.swift index 663f2e66..8a2953b7 100644 --- a/AtalaPrismSDK/Castor/Tests/PrismDIDPublicKeyTests.swift +++ b/AtalaPrismSDK/Castor/Tests/PrismDIDPublicKeyTests.swift @@ -12,7 +12,7 @@ final class PrismDIDPublicKeyTests: XCTestCase { override func setUp() async throws { apollo = ApolloImpl() seed = apollo.createRandomSeed().seed - keyPair = apollo.createKeyPair(seed: seed, curve: .secp256k1()) + keyPair = try apollo.createKeyPair(seed: seed, curve: .secp256k1()) } func testFromProto() throws { diff --git a/AtalaPrismSDK/Domain/Sources/BBs/Apollo.swift b/AtalaPrismSDK/Domain/Sources/BBs/Apollo.swift index d0423a74..13497bfd 100644 --- a/AtalaPrismSDK/Domain/Sources/BBs/Apollo.swift +++ b/AtalaPrismSDK/Domain/Sources/BBs/Apollo.swift @@ -28,7 +28,7 @@ public protocol Apollo { /// - seed: A seed object used to generate the key pair /// - curve: The key curve to use for generating the key pair /// - Returns: A key pair object containing a private and public key - func createKeyPair(seed: Seed, curve: KeyCurve) -> KeyPair + func createKeyPair(seed: Seed, curve: KeyCurve) throws -> KeyPair /// createKeyPair creates a key pair using a given seed and a specified private key. This function may throw an error if the private key is invalid. /// @@ -49,7 +49,7 @@ public protocol Apollo { /// /// - Parameter compressedData: The compressed public key data /// - Returns: The decompressed public key - func compressedPublicKey(compressedData: Data) -> CompressedPublicKey + func uncompressedPublicKey(compressedData: Data) -> PublicKey /// signMessage signs a message using a given private key, returning the signature. /// @@ -57,7 +57,7 @@ public protocol Apollo { /// - privateKey: The private key to use for signing the message /// - message: The message to sign, in binary data form /// - Returns: The signature of the message - func signMessage(privateKey: PrivateKey, message: Data) -> Signature + func signMessage(privateKey: PrivateKey, message: Data) throws -> Signature /// signMessage signs a message using a given private key, returning the signature. This function may throw an error if the message is invalid. /// @@ -79,7 +79,7 @@ public protocol Apollo { publicKey: PublicKey, challenge: Data, signature: Signature - ) -> Bool + ) throws -> Bool /// getPrivateJWKJson converts a private key pair into a JSON Web Key (JWK) format with a given ID. This function may throw an error if the key pair is invalid. /// diff --git a/AtalaPrismSDK/PrismAgent/Sources/Helpers/AttachmentDescriptor+Builder.swift b/AtalaPrismSDK/PrismAgent/Sources/Helpers/AttachmentDescriptor+Builder.swift index a66bceed..d16005c3 100644 --- a/AtalaPrismSDK/PrismAgent/Sources/Helpers/AttachmentDescriptor+Builder.swift +++ b/AtalaPrismSDK/PrismAgent/Sources/Helpers/AttachmentDescriptor+Builder.swift @@ -3,7 +3,7 @@ import Domain import Foundation extension AttachmentDescriptor { - static func build( + public static func build( id: String = UUID().uuidString, payload: T, mediaType: String? = "application/json" diff --git a/AtalaPrismSDK/PrismAgent/Sources/PrismAgent+DIDHigherFucntions.swift b/AtalaPrismSDK/PrismAgent/Sources/PrismAgent+DIDHigherFucntions.swift index f86a93c1..24304483 100644 --- a/AtalaPrismSDK/PrismAgent/Sources/PrismAgent+DIDHigherFucntions.swift +++ b/AtalaPrismSDK/PrismAgent/Sources/PrismAgent+DIDHigherFucntions.swift @@ -39,12 +39,12 @@ Could not find key in storage please use Castor instead and provide the private throw PrismAgentError.cannotFindDIDKeyPairIndex } // Re-Create the key pair to sign the message - let keyPair = apollo.createKeyPair(seed: seed, curve: .secp256k1(index: index)) + let keyPair = try apollo.createKeyPair(seed: seed, curve: .secp256k1(index: index)) self?.logger.debug(message: "Signing message", metadata: [ .maskedMetadataByLevel(key: "messageB64", value: message.base64Encoded(), level: .debug) ]) - return apollo.signMessage(privateKey: keyPair.privateKey, message: message) + return try apollo.signMessage(privateKey: keyPair.privateKey, message: message) } .first() .await() @@ -71,7 +71,7 @@ Could not find key in storage please use Castor instead and provide the private // If the user provided a key path index use it, if not use the last + 1 let index = keyPathIndex ?? ($0 + 1) // Create the key pair - let keyPair = apollo.createKeyPair(seed: seed, curve: .secp256k1(index: index)) + let keyPair = try apollo.createKeyPair(seed: seed, curve: .secp256k1(index: index)) let newDID = try castor.createPrismDID(masterPublicKey: keyPair.publicKey, services: services) self?.logger.debug(message: "Created new Prism DID", metadata: [ .maskedMetadataByLevel(key: "DID", value: newDID.string, level: .debug), @@ -119,8 +119,8 @@ Could not find key in storage please use Castor instead and provide the private alias: String? = "", updateMediator: Bool ) async throws -> DID { - let keyAgreementKeyPair = apollo.createKeyPair(seed: seed, curve: .x25519) - let authenticationKeyPair = apollo.createKeyPair(seed: seed, curve: .ed25519) + let keyAgreementKeyPair = try apollo.createKeyPair(seed: seed, curve: .x25519) + let authenticationKeyPair = try apollo.createKeyPair(seed: seed, curve: .ed25519) let withServices: [DIDDocument.Service] if updateMediator, let routingDID = mediatorRoutingDID?.string { diff --git a/AtalaPrismSDK/PrismAgent/Sources/PrismAgent.swift b/AtalaPrismSDK/PrismAgent/Sources/PrismAgent.swift index fb840622..44ba582a 100644 --- a/AtalaPrismSDK/PrismAgent/Sources/PrismAgent.swift +++ b/AtalaPrismSDK/PrismAgent/Sources/PrismAgent.swift @@ -159,30 +159,6 @@ public class PrismAgent { state = .stoped logger.info(message: "Agent not running") } - -// // TODO: This is to be deleted in the future. For now it helps with proof of request logic -// public func presentCredentialProof( -// request: RequestPresentation, -// credential: VerifiableCredential -// ) async throws { -// guard let jwtBase64 = credential.id.data(using: .utf8)?.base64UrlEncodedString() else { -// throw UnknownError.somethingWentWrongError( -// customMessage: "Could not decode JWT Credential", -// underlyingErrors: nil -// ) -// } -// let presentation = Presentation( -// body: .init(goalCode: request.body.goalCode, comment: request.body.comment), -// attachments: [try .build( -// payload: AttachmentBase64(base64: jwtBase64), -// mediaType: "prism/jwt" -// )], -// thid: request.id, -// from: request.to, -// to: request.from -// ) -// _ = try await connectionManager.sendMessage(presentation.makeMessage()) -// } // // // TODO: This is to be deleted in the future. For now it helps with issue credentials logic // public func issueCredentialProtocol() { diff --git a/AtalaPrismSDK/PrismAgent/Sources/Protocols/ProofPresentation/Presentation.swift b/AtalaPrismSDK/PrismAgent/Sources/Protocols/ProofPresentation/Presentation.swift index 9927cf45..467f8a2d 100644 --- a/AtalaPrismSDK/PrismAgent/Sources/Protocols/ProofPresentation/Presentation.swift +++ b/AtalaPrismSDK/PrismAgent/Sources/Protocols/ProofPresentation/Presentation.swift @@ -2,18 +2,18 @@ import Core import Domain import Foundation -struct ProofTypes: Codable, Equatable { - let schema: String - let requiredFields: [String]? - let trustIssuers: [String]? +public struct ProofTypes: Codable, Equatable { + public let schema: String + public let requiredFields: [String]? + public let trustIssuers: [String]? } public struct Presentation { - struct Body: Codable, Equatable { - let goalCode: String? - let comment: String? + public struct Body: Codable, Equatable { + public let goalCode: String? + public let comment: String? - init( + public init( goalCode: String? = nil, comment: String? = nil ) { @@ -23,13 +23,13 @@ public struct Presentation { } public let id: String public let type = ProtocolTypes.didcommPresentation.rawValue - let body: Body - let attachments: [AttachmentDescriptor] + public let body: Body + public let attachments: [AttachmentDescriptor] public let thid: String? public let from: DID public let to: DID - init( + public init( id: String = UUID().uuidString, body: Body, attachments: [AttachmentDescriptor], diff --git a/AtalaPrismSDK/PrismAgent/Sources/Protocols/ProofPresentation/RequestPresentation.swift b/AtalaPrismSDK/PrismAgent/Sources/Protocols/ProofPresentation/RequestPresentation.swift index 485eca7a..9c3dd374 100644 --- a/AtalaPrismSDK/PrismAgent/Sources/Protocols/ProofPresentation/RequestPresentation.swift +++ b/AtalaPrismSDK/PrismAgent/Sources/Protocols/ProofPresentation/RequestPresentation.swift @@ -4,12 +4,12 @@ import Foundation public struct RequestPresentation { public struct Body: Codable, Equatable { - let goalCode: String? - let comment: String? - let willConfirm: Bool? - let proofTypes: [ProofTypes] + public let goalCode: String? + public let comment: String? + public let willConfirm: Bool? + public let proofTypes: [ProofTypes] - init( + public init( goalCode: String? = nil, comment: String? = nil, willConfirm: Bool? = false, diff --git a/Core/Sources/Helpers/Status.swift b/Core/Sources/Helpers/Status.swift new file mode 100644 index 00000000..c86413b2 --- /dev/null +++ b/Core/Sources/Helpers/Status.swift @@ -0,0 +1,1267 @@ +// +// Copyright © 2018 BitcoinKit developers +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// + +import Foundation + +// swiftlint:disable all + +// Copied from: https://github.com/kishikawakatsumi/KeychainAccess/blob/master/Lib/KeychainAccess/Keychain.swift +public enum Status: OSStatus, Error { + case success = 0 + case unimplemented = -4 + case diskFull = -34 + case io = -36 + case opWr = -49 + case param = -50 + case wrPerm = -61 + case allocate = -108 + case userCanceled = -128 + case badReq = -909 + case internalComponent = -2070 + case notAvailable = -25291 + case readOnly = -25292 + case authFailed = -25293 + case noSuchKeychain = -25294 + case invalidKeychain = -25295 + case duplicateKeychain = -25296 + case duplicateCallback = -25297 + case invalidCallback = -25298 + case duplicateItem = -25299 + case itemNotFound = -25300 + case bufferTooSmall = -25301 + case dataTooLarge = -25302 + case noSuchAttr = -25303 + case invalidItemRef = -25304 + case invalidSearchRef = -25305 + case noSuchClass = -25306 + case noDefaultKeychain = -25307 + case interactionNotAllowed = -25308 + case readOnlyAttr = -25309 + case wrongSecVersion = -25310 + case keySizeNotAllowed = -25311 + case noStorageModule = -25312 + case noCertificateModule = -25313 + case noPolicyModule = -25314 + case interactionRequired = -25315 + case dataNotAvailable = -25316 + case dataNotModifiable = -25317 + case createChainFailed = -25318 + case invalidPrefsDomain = -25319 + case inDarkWake = -25320 + case aclNotSimple = -25240 + case policyNotFound = -25241 + case invalidTrustSetting = -25242 + case noAccessForItem = -25243 + case invalidOwnerEdit = -25244 + case trustNotAvailable = -25245 + case unsupportedFormat = -25256 + case unknownFormat = -25257 + case keyIsSensitive = -25258 + case multiplePrivKeys = -25259 + case passphraseRequired = -25260 + case invalidPasswordRef = -25261 + case invalidTrustSettings = -25262 + case noTrustSettings = -25263 + case pkcs12VerifyFailure = -25264 + case invalidCertificate = -26265 + case notSigner = -26267 + case policyDenied = -26270 + case invalidKey = -26274 + case decode = -26275 + case `internal` = -26276 + case unsupportedAlgorithm = -26268 + case unsupportedOperation = -26271 + case unsupportedPadding = -26273 + case itemInvalidKey = -34000 + case itemInvalidKeyType = -34001 + case itemInvalidValue = -34002 + case itemClassMissing = -34003 + case itemMatchUnsupported = -34004 + case useItemListUnsupported = -34005 + case useKeychainUnsupported = -34006 + case useKeychainListUnsupported = -34007 + case returnDataUnsupported = -34008 + case returnAttributesUnsupported = -34009 + case returnRefUnsupported = -34010 + case returnPersitentRefUnsupported = -34011 + case valueRefUnsupported = -34012 + case valuePersistentRefUnsupported = -34013 + case returnMissingPointer = -34014 + case matchLimitUnsupported = -34015 + case itemIllegalQuery = -34016 + case waitForCallback = -34017 + case missingEntitlement = -34018 + case upgradePending = -34019 + case mpSignatureInvalid = -25327 + case otrTooOld = -25328 + case otrIDTooNew = -25329 + case serviceNotAvailable = -67585 + case insufficientClientID = -67586 + case deviceReset = -67587 + case deviceFailed = -67588 + case appleAddAppACLSubject = -67589 + case applePublicKeyIncomplete = -67590 + case appleSignatureMismatch = -67591 + case appleInvalidKeyStartDate = -67592 + case appleInvalidKeyEndDate = -67593 + case conversionError = -67594 + case appleSSLv2Rollback = -67595 + case quotaExceeded = -67596 + case fileTooBig = -67597 + case invalidDatabaseBlob = -67598 + case invalidKeyBlob = -67599 + case incompatibleDatabaseBlob = -67600 + case incompatibleKeyBlob = -67601 + case hostNameMismatch = -67602 + case unknownCriticalExtensionFlag = -67603 + case noBasicConstraints = -67604 + case noBasicConstraintsCA = -67605 + case invalidAuthorityKeyID = -67606 + case invalidSubjectKeyID = -67607 + case invalidKeyUsageForPolicy = -67608 + case invalidExtendedKeyUsage = -67609 + case invalidIDLinkage = -67610 + case pathLengthConstraintExceeded = -67611 + case invalidRoot = -67612 + case crlExpired = -67613 + case crlNotValidYet = -67614 + case crlNotFound = -67615 + case crlServerDown = -67616 + case crlBadURI = -67617 + case unknownCertExtension = -67618 + case unknownCRLExtension = -67619 + case crlNotTrusted = -67620 + case crlPolicyFailed = -67621 + case idpFailure = -67622 + case smimeEmailAddressesNotFound = -67623 + case smimeBadExtendedKeyUsage = -67624 + case smimeBadKeyUsage = -67625 + case smimeKeyUsageNotCritical = -67626 + case smimeNoEmailAddress = -67627 + case smimeSubjAltNameNotCritical = -67628 + case sslBadExtendedKeyUsage = -67629 + case ocspBadResponse = -67630 + case ocspBadRequest = -67631 + case ocspUnavailable = -67632 + case ocspStatusUnrecognized = -67633 + case endOfData = -67634 + case incompleteCertRevocationCheck = -67635 + case networkFailure = -67636 + case ocspNotTrustedToAnchor = -67637 + case recordModified = -67638 + case ocspSignatureError = -67639 + case ocspNoSigner = -67640 + case ocspResponderMalformedReq = -67641 + case ocspResponderInternalError = -67642 + case ocspResponderTryLater = -67643 + case ocspResponderSignatureRequired = -67644 + case ocspResponderUnauthorized = -67645 + case ocspResponseNonceMismatch = -67646 + case codeSigningBadCertChainLength = -67647 + case codeSigningNoBasicConstraints = -67648 + case codeSigningBadPathLengthConstraint = -67649 + case codeSigningNoExtendedKeyUsage = -67650 + case codeSigningDevelopment = -67651 + case resourceSignBadCertChainLength = -67652 + case resourceSignBadExtKeyUsage = -67653 + case trustSettingDeny = -67654 + case invalidSubjectName = -67655 + case unknownQualifiedCertStatement = -67656 + case mobileMeRequestQueued = -67657 + case mobileMeRequestRedirected = -67658 + case mobileMeServerError = -67659 + case mobileMeServerNotAvailable = -67660 + case mobileMeServerAlreadyExists = -67661 + case mobileMeServerServiceErr = -67662 + case mobileMeRequestAlreadyPending = -67663 + case mobileMeNoRequestPending = -67664 + case mobileMeCSRVerifyFailure = -67665 + case mobileMeFailedConsistencyCheck = -67666 + case notInitialized = -67667 + case invalidHandleUsage = -67668 + case pvcReferentNotFound = -67669 + case functionIntegrityFail = -67670 + case internalError = -67671 + case memoryError = -67672 + case invalidData = -67673 + case mdsError = -67674 + case invalidPointer = -67675 + case selfCheckFailed = -67676 + case functionFailed = -67677 + case moduleManifestVerifyFailed = -67678 + case invalidGUID = -67679 + case invalidHandle = -67680 + case invalidDBList = -67681 + case invalidPassthroughID = -67682 + case invalidNetworkAddress = -67683 + case crlAlreadySigned = -67684 + case invalidNumberOfFields = -67685 + case verificationFailure = -67686 + case unknownTag = -67687 + case invalidSignature = -67688 + case invalidName = -67689 + case invalidCertificateRef = -67690 + case invalidCertificateGroup = -67691 + case tagNotFound = -67692 + case invalidQuery = -67693 + case invalidValue = -67694 + case callbackFailed = -67695 + case aclDeleteFailed = -67696 + case aclReplaceFailed = -67697 + case aclAddFailed = -67698 + case aclChangeFailed = -67699 + case invalidAccessCredentials = -67700 + case invalidRecord = -67701 + case invalidACL = -67702 + case invalidSampleValue = -67703 + case incompatibleVersion = -67704 + case privilegeNotGranted = -67705 + case invalidScope = -67706 + case pvcAlreadyConfigured = -67707 + case invalidPVC = -67708 + case emmLoadFailed = -67709 + case emmUnloadFailed = -67710 + case addinLoadFailed = -67711 + case invalidKeyRef = -67712 + case invalidKeyHierarchy = -67713 + case addinUnloadFailed = -67714 + case libraryReferenceNotFound = -67715 + case invalidAddinFunctionTable = -67716 + case invalidServiceMask = -67717 + case moduleNotLoaded = -67718 + case invalidSubServiceID = -67719 + case attributeNotInContext = -67720 + case moduleManagerInitializeFailed = -67721 + case moduleManagerNotFound = -67722 + case eventNotificationCallbackNotFound = -67723 + case inputLengthError = -67724 + case outputLengthError = -67725 + case privilegeNotSupported = -67726 + case deviceError = -67727 + case attachHandleBusy = -67728 + case notLoggedIn = -67729 + case algorithmMismatch = -67730 + case keyUsageIncorrect = -67731 + case keyBlobTypeIncorrect = -67732 + case keyHeaderInconsistent = -67733 + case unsupportedKeyFormat = -67734 + case unsupportedKeySize = -67735 + case invalidKeyUsageMask = -67736 + case unsupportedKeyUsageMask = -67737 + case invalidKeyAttributeMask = -67738 + case unsupportedKeyAttributeMask = -67739 + case invalidKeyLabel = -67740 + case unsupportedKeyLabel = -67741 + case invalidKeyFormat = -67742 + case unsupportedVectorOfBuffers = -67743 + case invalidInputVector = -67744 + case invalidOutputVector = -67745 + case invalidContext = -67746 + case invalidAlgorithm = -67747 + case invalidAttributeKey = -67748 + case missingAttributeKey = -67749 + case invalidAttributeInitVector = -67750 + case missingAttributeInitVector = -67751 + case invalidAttributeSalt = -67752 + case missingAttributeSalt = -67753 + case invalidAttributePadding = -67754 + case missingAttributePadding = -67755 + case invalidAttributeRandom = -67756 + case missingAttributeRandom = -67757 + case invalidAttributeSeed = -67758 + case missingAttributeSeed = -67759 + case invalidAttributePassphrase = -67760 + case missingAttributePassphrase = -67761 + case invalidAttributeKeyLength = -67762 + case missingAttributeKeyLength = -67763 + case invalidAttributeBlockSize = -67764 + case missingAttributeBlockSize = -67765 + case invalidAttributeOutputSize = -67766 + case missingAttributeOutputSize = -67767 + case invalidAttributeRounds = -67768 + case missingAttributeRounds = -67769 + case invalidAlgorithmParms = -67770 + case missingAlgorithmParms = -67771 + case invalidAttributeLabel = -67772 + case missingAttributeLabel = -67773 + case invalidAttributeKeyType = -67774 + case missingAttributeKeyType = -67775 + case invalidAttributeMode = -67776 + case missingAttributeMode = -67777 + case invalidAttributeEffectiveBits = -67778 + case missingAttributeEffectiveBits = -67779 + case invalidAttributeStartDate = -67780 + case missingAttributeStartDate = -67781 + case invalidAttributeEndDate = -67782 + case missingAttributeEndDate = -67783 + case invalidAttributeVersion = -67784 + case missingAttributeVersion = -67785 + case invalidAttributePrime = -67786 + case missingAttributePrime = -67787 + case invalidAttributeBase = -67788 + case missingAttributeBase = -67789 + case invalidAttributeSubprime = -67790 + case missingAttributeSubprime = -67791 + case invalidAttributeIterationCount = -67792 + case missingAttributeIterationCount = -67793 + case invalidAttributeDLDBHandle = -67794 + case missingAttributeDLDBHandle = -67795 + case invalidAttributeAccessCredentials = -67796 + case missingAttributeAccessCredentials = -67797 + case invalidAttributePublicKeyFormat = -67798 + case missingAttributePublicKeyFormat = -67799 + case invalidAttributePrivateKeyFormat = -67800 + case missingAttributePrivateKeyFormat = -67801 + case invalidAttributeSymmetricKeyFormat = -67802 + case missingAttributeSymmetricKeyFormat = -67803 + case invalidAttributeWrappedKeyFormat = -67804 + case missingAttributeWrappedKeyFormat = -67805 + case stagedOperationInProgress = -67806 + case stagedOperationNotStarted = -67807 + case verifyFailed = -67808 + case querySizeUnknown = -67809 + case blockSizeMismatch = -67810 + case publicKeyInconsistent = -67811 + case deviceVerifyFailed = -67812 + case invalidLoginName = -67813 + case alreadyLoggedIn = -67814 + case invalidDigestAlgorithm = -67815 + case invalidCRLGroup = -67816 + case certificateCannotOperate = -67817 + case certificateExpired = -67818 + case certificateNotValidYet = -67819 + case certificateRevoked = -67820 + case certificateSuspended = -67821 + case insufficientCredentials = -67822 + case invalidAction = -67823 + case invalidAuthority = -67824 + case verifyActionFailed = -67825 + case invalidCertAuthority = -67826 + case invaldCRLAuthority = -67827 + case invalidCRLEncoding = -67828 + case invalidCRLType = -67829 + case invalidCRL = -67830 + case invalidFormType = -67831 + case invalidID = -67832 + case invalidIdentifier = -67833 + case invalidIndex = -67834 + case invalidPolicyIdentifiers = -67835 + case invalidTimeString = -67836 + case invalidReason = -67837 + case invalidRequestInputs = -67838 + case invalidResponseVector = -67839 + case invalidStopOnPolicy = -67840 + case invalidTuple = -67841 + case multipleValuesUnsupported = -67842 + case notTrusted = -67843 + case noDefaultAuthority = -67844 + case rejectedForm = -67845 + case requestLost = -67846 + case requestRejected = -67847 + case unsupportedAddressType = -67848 + case unsupportedService = -67849 + case invalidTupleGroup = -67850 + case invalidBaseACLs = -67851 + case invalidTupleCredendtials = -67852 + case invalidEncoding = -67853 + case invalidValidityPeriod = -67854 + case invalidRequestor = -67855 + case requestDescriptor = -67856 + case invalidBundleInfo = -67857 + case invalidCRLIndex = -67858 + case noFieldValues = -67859 + case unsupportedFieldFormat = -67860 + case unsupportedIndexInfo = -67861 + case unsupportedLocality = -67862 + case unsupportedNumAttributes = -67863 + case unsupportedNumIndexes = -67864 + case unsupportedNumRecordTypes = -67865 + case fieldSpecifiedMultiple = -67866 + case incompatibleFieldFormat = -67867 + case invalidParsingModule = -67868 + case databaseLocked = -67869 + case datastoreIsOpen = -67870 + case missingValue = -67871 + case unsupportedQueryLimits = -67872 + case unsupportedNumSelectionPreds = -67873 + case unsupportedOperator = -67874 + case invalidDBLocation = -67875 + case invalidAccessRequest = -67876 + case invalidIndexInfo = -67877 + case invalidNewOwner = -67878 + case invalidModifyMode = -67879 + case missingRequiredExtension = -67880 + case extendedKeyUsageNotCritical = -67881 + case timestampMissing = -67882 + case timestampInvalid = -67883 + case timestampNotTrusted = -67884 + case timestampServiceNotAvailable = -67885 + case timestampBadAlg = -67886 + case timestampBadRequest = -67887 + case timestampBadDataFormat = -67888 + case timestampTimeNotAvailable = -67889 + case timestampUnacceptedPolicy = -67890 + case timestampUnacceptedExtension = -67891 + case timestampAddInfoNotAvailable = -67892 + case timestampSystemFailure = -67893 + case signingTimeMissing = -67894 + case timestampRejection = -67895 + case timestampWaiting = -67896 + case timestampRevocationWarning = -67897 + case timestampRevocationNotification = -67898 + case unexpectedError = -99999 +} + +extension Status: RawRepresentable, CustomStringConvertible { + + public init(status: OSStatus) { + if let mappedStatus = Status(rawValue: status) { + self = mappedStatus + } else { + self = .unexpectedError + } + } + + public var description: String { + switch self { + case .success: + return "No error." + case .unimplemented: + return "Function or operation not implemented." + case .diskFull: + return "The disk is full." + case .io: + return "I/O error (bummers)" + case .opWr: + return "file already open with with write permission" + case .param: + return "One or more parameters passed to a function were not valid." + case .wrPerm: + return "write permissions error" + case .allocate: + return "Failed to allocate memory." + case .userCanceled: + return "User canceled the operation." + case .badReq: + return "Bad parameter or invalid state for operation." + case .internalComponent: + return "" + case .notAvailable: + return "No keychain is available. You may need to restart your computer." + case .readOnly: + return "This keychain cannot be modified." + case .authFailed: + return "The user name or passphrase you entered is not correct." + case .noSuchKeychain: + return "The specified keychain could not be found." + case .invalidKeychain: + return "The specified keychain is not a valid keychain file." + case .duplicateKeychain: + return "A keychain with the same name already exists." + case .duplicateCallback: + return "The specified callback function is already installed." + case .invalidCallback: + return "The specified callback function is not valid." + case .duplicateItem: + return "The specified item already exists in the keychain." + case .itemNotFound: + return "The specified item could not be found in the keychain." + case .bufferTooSmall: + return "There is not enough memory available to use the specified item." + case .dataTooLarge: + return "This item contains information which is too large or in a format that cannot be displayed." + case .noSuchAttr: + return "The specified attribute does not exist." + case .invalidItemRef: + return "The specified item is no longer valid. It may have been deleted from the keychain." + case .invalidSearchRef: + return "Unable to search the current keychain." + case .noSuchClass: + return "The specified item does not appear to be a valid keychain item." + case .noDefaultKeychain: + return "A default keychain could not be found." + case .interactionNotAllowed: + return "User interaction is not allowed." + case .readOnlyAttr: + return "The specified attribute could not be modified." + case .wrongSecVersion: + return "This keychain was created by a different version of the system software and cannot be opened." + case .keySizeNotAllowed: + return "This item specifies a key size which is too large." + case .noStorageModule: + return "A required component (data storage module) could not be loaded. You may need to restart your computer." + case .noCertificateModule: + return "A required component (certificate module) could not be loaded. You may need to restart your computer." + case .noPolicyModule: + return "A required component (policy module) could not be loaded. You may need to restart your computer." + case .interactionRequired: + return "User interaction is required, but is currently not allowed." + case .dataNotAvailable: + return "The contents of this item cannot be retrieved." + case .dataNotModifiable: + return "The contents of this item cannot be modified." + case .createChainFailed: + return "One or more certificates required to validate this certificate cannot be found." + case .invalidPrefsDomain: + return "The specified preferences domain is not valid." + case .inDarkWake: + return "In dark wake, no UI possible" + case .aclNotSimple: + return "The specified access control list is not in standard (simple) form." + case .policyNotFound: + return "The specified policy cannot be found." + case .invalidTrustSetting: + return "The specified trust setting is invalid." + case .noAccessForItem: + return "The specified item has no access control." + case .invalidOwnerEdit: + return "Invalid attempt to change the owner of this item." + case .trustNotAvailable: + return "No trust results are available." + case .unsupportedFormat: + return "Import/Export format unsupported." + case .unknownFormat: + return "Unknown format in import." + case .keyIsSensitive: + return "Key material must be wrapped for export." + case .multiplePrivKeys: + return "An attempt was made to import multiple private keys." + case .passphraseRequired: + return "Passphrase is required for import/export." + case .invalidPasswordRef: + return "The password reference was invalid." + case .invalidTrustSettings: + return "The Trust Settings Record was corrupted." + case .noTrustSettings: + return "No Trust Settings were found." + case .pkcs12VerifyFailure: + return "MAC verification failed during PKCS12 import (wrong password?)" + case .invalidCertificate: + return "This certificate could not be decoded." + case .notSigner: + return "A certificate was not signed by its proposed parent." + case .policyDenied: + return "The certificate chain was not trusted due to a policy not accepting it." + case .invalidKey: + return "The provided key material was not valid." + case .decode: + return "Unable to decode the provided data." + case .`internal`: + return "An internal error occurred in the Security framework." + case .unsupportedAlgorithm: + return "An unsupported algorithm was encountered." + case .unsupportedOperation: + return "The operation you requested is not supported by this key." + case .unsupportedPadding: + return "The padding you requested is not supported." + case .itemInvalidKey: + return "A string key in dictionary is not one of the supported keys." + case .itemInvalidKeyType: + return "A key in a dictionary is neither a CFStringRef nor a CFNumberRef." + case .itemInvalidValue: + return "A value in a dictionary is an invalid (or unsupported) CF type." + case .itemClassMissing: + return "No kSecItemClass key was specified in a dictionary." + case .itemMatchUnsupported: + return "The caller passed one or more kSecMatch keys to a function which does not support matches." + case .useItemListUnsupported: + return "The caller passed in a kSecUseItemList key to a function which does not support it." + case .useKeychainUnsupported: + return "The caller passed in a kSecUseKeychain key to a function which does not support it." + case .useKeychainListUnsupported: + return "The caller passed in a kSecUseKeychainList key to a function which does not support it." + case .returnDataUnsupported: + return "The caller passed in a kSecReturnData key to a function which does not support it." + case .returnAttributesUnsupported: + return "The caller passed in a kSecReturnAttributes key to a function which does not support it." + case .returnRefUnsupported: + return "The caller passed in a kSecReturnRef key to a function which does not support it." + case .returnPersitentRefUnsupported: + return "The caller passed in a kSecReturnPersistentRef key to a function which does not support it." + case .valueRefUnsupported: + return "The caller passed in a kSecValueRef key to a function which does not support it." + case .valuePersistentRefUnsupported: + return "The caller passed in a kSecValuePersistentRef key to a function which does not support it." + case .returnMissingPointer: + return "The caller passed asked for something to be returned but did not pass in a result pointer." + case .matchLimitUnsupported: + return "The caller passed in a kSecMatchLimit key to a call which does not support limits." + case .itemIllegalQuery: + return "The caller passed in a query which contained too many keys." + case .waitForCallback: + return "This operation is incomplete, until the callback is invoked (not an error)." + case .missingEntitlement: + return "Internal error when a required entitlement isn't present, client has neither application-identifier nor keychain-access-groups entitlements." + case .upgradePending: + return "Error returned if keychain database needs a schema migration but the device is locked, clients should wait for a device unlock notification and retry the command." + case .mpSignatureInvalid: + return "Signature invalid on MP message" + case .otrTooOld: + return "Message is too old to use" + case .otrIDTooNew: + return "Key ID is too new to use! Message from the future?" + case .serviceNotAvailable: + return "The required service is not available." + case .insufficientClientID: + return "The client ID is not correct." + case .deviceReset: + return "A device reset has occurred." + case .deviceFailed: + return "A device failure has occurred." + case .appleAddAppACLSubject: + return "Adding an application ACL subject failed." + case .applePublicKeyIncomplete: + return "The public key is incomplete." + case .appleSignatureMismatch: + return "A signature mismatch has occurred." + case .appleInvalidKeyStartDate: + return "The specified key has an invalid start date." + case .appleInvalidKeyEndDate: + return "The specified key has an invalid end date." + case .conversionError: + return "A conversion error has occurred." + case .appleSSLv2Rollback: + return "A SSLv2 rollback error has occurred." + case .quotaExceeded: + return "The quota was exceeded." + case .fileTooBig: + return "The file is too big." + case .invalidDatabaseBlob: + return "The specified database has an invalid blob." + case .invalidKeyBlob: + return "The specified database has an invalid key blob." + case .incompatibleDatabaseBlob: + return "The specified database has an incompatible blob." + case .incompatibleKeyBlob: + return "The specified database has an incompatible key blob." + case .hostNameMismatch: + return "A host name mismatch has occurred." + case .unknownCriticalExtensionFlag: + return "There is an unknown critical extension flag." + case .noBasicConstraints: + return "No basic constraints were found." + case .noBasicConstraintsCA: + return "No basic CA constraints were found." + case .invalidAuthorityKeyID: + return "The authority key ID is not valid." + case .invalidSubjectKeyID: + return "The subject key ID is not valid." + case .invalidKeyUsageForPolicy: + return "The key usage is not valid for the specified policy." + case .invalidExtendedKeyUsage: + return "The extended key usage is not valid." + case .invalidIDLinkage: + return "The ID linkage is not valid." + case .pathLengthConstraintExceeded: + return "The path length constraint was exceeded." + case .invalidRoot: + return "The root or anchor certificate is not valid." + case .crlExpired: + return "The CRL has expired." + case .crlNotValidYet: + return "The CRL is not yet valid." + case .crlNotFound: + return "The CRL was not found." + case .crlServerDown: + return "The CRL server is down." + case .crlBadURI: + return "The CRL has a bad Uniform Resource Identifier." + case .unknownCertExtension: + return "An unknown certificate extension was encountered." + case .unknownCRLExtension: + return "An unknown CRL extension was encountered." + case .crlNotTrusted: + return "The CRL is not trusted." + case .crlPolicyFailed: + return "The CRL policy failed." + case .idpFailure: + return "The issuing distribution point was not valid." + case .smimeEmailAddressesNotFound: + return "An email address mismatch was encountered." + case .smimeBadExtendedKeyUsage: + return "The appropriate extended key usage for SMIME was not found." + case .smimeBadKeyUsage: + return "The key usage is not compatible with SMIME." + case .smimeKeyUsageNotCritical: + return "The key usage extension is not marked as critical." + case .smimeNoEmailAddress: + return "No email address was found in the certificate." + case .smimeSubjAltNameNotCritical: + return "The subject alternative name extension is not marked as critical." + case .sslBadExtendedKeyUsage: + return "The appropriate extended key usage for SSL was not found." + case .ocspBadResponse: + return "The OCSP response was incorrect or could not be parsed." + case .ocspBadRequest: + return "The OCSP request was incorrect or could not be parsed." + case .ocspUnavailable: + return "OCSP service is unavailable." + case .ocspStatusUnrecognized: + return "The OCSP server did not recognize this certificate." + case .endOfData: + return "An end-of-data was detected." + case .incompleteCertRevocationCheck: + return "An incomplete certificate revocation check occurred." + case .networkFailure: + return "A network failure occurred." + case .ocspNotTrustedToAnchor: + return "The OCSP response was not trusted to a root or anchor certificate." + case .recordModified: + return "The record was modified." + case .ocspSignatureError: + return "The OCSP response had an invalid signature." + case .ocspNoSigner: + return "The OCSP response had no signer." + case .ocspResponderMalformedReq: + return "The OCSP responder was given a malformed request." + case .ocspResponderInternalError: + return "The OCSP responder encountered an internal error." + case .ocspResponderTryLater: + return "The OCSP responder is busy, try again later." + case .ocspResponderSignatureRequired: + return "The OCSP responder requires a signature." + case .ocspResponderUnauthorized: + return "The OCSP responder rejected this request as unauthorized." + case .ocspResponseNonceMismatch: + return "The OCSP response nonce did not match the request." + case .codeSigningBadCertChainLength: + return "Code signing encountered an incorrect certificate chain length." + case .codeSigningNoBasicConstraints: + return "Code signing found no basic constraints." + case .codeSigningBadPathLengthConstraint: + return "Code signing encountered an incorrect path length constraint." + case .codeSigningNoExtendedKeyUsage: + return "Code signing found no extended key usage." + case .codeSigningDevelopment: + return "Code signing indicated use of a development-only certificate." + case .resourceSignBadCertChainLength: + return "Resource signing has encountered an incorrect certificate chain length." + case .resourceSignBadExtKeyUsage: + return "Resource signing has encountered an error in the extended key usage." + case .trustSettingDeny: + return "The trust setting for this policy was set to Deny." + case .invalidSubjectName: + return "An invalid certificate subject name was encountered." + case .unknownQualifiedCertStatement: + return "An unknown qualified certificate statement was encountered." + case .mobileMeRequestQueued: + return "The MobileMe request will be sent during the next connection." + case .mobileMeRequestRedirected: + return "The MobileMe request was redirected." + case .mobileMeServerError: + return "A MobileMe server error occurred." + case .mobileMeServerNotAvailable: + return "The MobileMe server is not available." + case .mobileMeServerAlreadyExists: + return "The MobileMe server reported that the item already exists." + case .mobileMeServerServiceErr: + return "A MobileMe service error has occurred." + case .mobileMeRequestAlreadyPending: + return "A MobileMe request is already pending." + case .mobileMeNoRequestPending: + return "MobileMe has no request pending." + case .mobileMeCSRVerifyFailure: + return "A MobileMe CSR verification failure has occurred." + case .mobileMeFailedConsistencyCheck: + return "MobileMe has found a failed consistency check." + case .notInitialized: + return "A function was called without initializing CSSM." + case .invalidHandleUsage: + return "The CSSM handle does not match with the service type." + case .pvcReferentNotFound: + return "A reference to the calling module was not found in the list of authorized callers." + case .functionIntegrityFail: + return "A function address was not within the verified module." + case .internalError: + return "An internal error has occurred." + case .memoryError: + return "A memory error has occurred." + case .invalidData: + return "Invalid data was encountered." + case .mdsError: + return "A Module Directory Service error has occurred." + case .invalidPointer: + return "An invalid pointer was encountered." + case .selfCheckFailed: + return "Self-check has failed." + case .functionFailed: + return "A function has failed." + case .moduleManifestVerifyFailed: + return "A module manifest verification failure has occurred." + case .invalidGUID: + return "An invalid GUID was encountered." + case .invalidHandle: + return "An invalid handle was encountered." + case .invalidDBList: + return "An invalid DB list was encountered." + case .invalidPassthroughID: + return "An invalid passthrough ID was encountered." + case .invalidNetworkAddress: + return "An invalid network address was encountered." + case .crlAlreadySigned: + return "The certificate revocation list is already signed." + case .invalidNumberOfFields: + return "An invalid number of fields were encountered." + case .verificationFailure: + return "A verification failure occurred." + case .unknownTag: + return "An unknown tag was encountered." + case .invalidSignature: + return "An invalid signature was encountered." + case .invalidName: + return "An invalid name was encountered." + case .invalidCertificateRef: + return "An invalid certificate reference was encountered." + case .invalidCertificateGroup: + return "An invalid certificate group was encountered." + case .tagNotFound: + return "The specified tag was not found." + case .invalidQuery: + return "The specified query was not valid." + case .invalidValue: + return "An invalid value was detected." + case .callbackFailed: + return "A callback has failed." + case .aclDeleteFailed: + return "An ACL delete operation has failed." + case .aclReplaceFailed: + return "An ACL replace operation has failed." + case .aclAddFailed: + return "An ACL add operation has failed." + case .aclChangeFailed: + return "An ACL change operation has failed." + case .invalidAccessCredentials: + return "Invalid access credentials were encountered." + case .invalidRecord: + return "An invalid record was encountered." + case .invalidACL: + return "An invalid ACL was encountered." + case .invalidSampleValue: + return "An invalid sample value was encountered." + case .incompatibleVersion: + return "An incompatible version was encountered." + case .privilegeNotGranted: + return "The privilege was not granted." + case .invalidScope: + return "An invalid scope was encountered." + case .pvcAlreadyConfigured: + return "The PVC is already configured." + case .invalidPVC: + return "An invalid PVC was encountered." + case .emmLoadFailed: + return "The EMM load has failed." + case .emmUnloadFailed: + return "The EMM unload has failed." + case .addinLoadFailed: + return "The add-in load operation has failed." + case .invalidKeyRef: + return "An invalid key was encountered." + case .invalidKeyHierarchy: + return "An invalid key hierarchy was encountered." + case .addinUnloadFailed: + return "The add-in unload operation has failed." + case .libraryReferenceNotFound: + return "A library reference was not found." + case .invalidAddinFunctionTable: + return "An invalid add-in function table was encountered." + case .invalidServiceMask: + return "An invalid service mask was encountered." + case .moduleNotLoaded: + return "A module was not loaded." + case .invalidSubServiceID: + return "An invalid subservice ID was encountered." + case .attributeNotInContext: + return "An attribute was not in the context." + case .moduleManagerInitializeFailed: + return "A module failed to initialize." + case .moduleManagerNotFound: + return "A module was not found." + case .eventNotificationCallbackNotFound: + return "An event notification callback was not found." + case .inputLengthError: + return "An input length error was encountered." + case .outputLengthError: + return "An output length error was encountered." + case .privilegeNotSupported: + return "The privilege is not supported." + case .deviceError: + return "A device error was encountered." + case .attachHandleBusy: + return "The CSP handle was busy." + case .notLoggedIn: + return "You are not logged in." + case .algorithmMismatch: + return "An algorithm mismatch was encountered." + case .keyUsageIncorrect: + return "The key usage is incorrect." + case .keyBlobTypeIncorrect: + return "The key blob type is incorrect." + case .keyHeaderInconsistent: + return "The key header is inconsistent." + case .unsupportedKeyFormat: + return "The key header format is not supported." + case .unsupportedKeySize: + return "The key size is not supported." + case .invalidKeyUsageMask: + return "The key usage mask is not valid." + case .unsupportedKeyUsageMask: + return "The key usage mask is not supported." + case .invalidKeyAttributeMask: + return "The key attribute mask is not valid." + case .unsupportedKeyAttributeMask: + return "The key attribute mask is not supported." + case .invalidKeyLabel: + return "The key label is not valid." + case .unsupportedKeyLabel: + return "The key label is not supported." + case .invalidKeyFormat: + return "The key format is not valid." + case .unsupportedVectorOfBuffers: + return "The vector of buffers is not supported." + case .invalidInputVector: + return "The input vector is not valid." + case .invalidOutputVector: + return "The output vector is not valid." + case .invalidContext: + return "An invalid context was encountered." + case .invalidAlgorithm: + return "An invalid algorithm was encountered." + case .invalidAttributeKey: + return "A key attribute was not valid." + case .missingAttributeKey: + return "A key attribute was missing." + case .invalidAttributeInitVector: + return "An init vector attribute was not valid." + case .missingAttributeInitVector: + return "An init vector attribute was missing." + case .invalidAttributeSalt: + return "A salt attribute was not valid." + case .missingAttributeSalt: + return "A salt attribute was missing." + case .invalidAttributePadding: + return "A padding attribute was not valid." + case .missingAttributePadding: + return "A padding attribute was missing." + case .invalidAttributeRandom: + return "A random number attribute was not valid." + case .missingAttributeRandom: + return "A random number attribute was missing." + case .invalidAttributeSeed: + return "A seed attribute was not valid." + case .missingAttributeSeed: + return "A seed attribute was missing." + case .invalidAttributePassphrase: + return "A passphrase attribute was not valid." + case .missingAttributePassphrase: + return "A passphrase attribute was missing." + case .invalidAttributeKeyLength: + return "A key length attribute was not valid." + case .missingAttributeKeyLength: + return "A key length attribute was missing." + case .invalidAttributeBlockSize: + return "A block size attribute was not valid." + case .missingAttributeBlockSize: + return "A block size attribute was missing." + case .invalidAttributeOutputSize: + return "An output size attribute was not valid." + case .missingAttributeOutputSize: + return "An output size attribute was missing." + case .invalidAttributeRounds: + return "The number of rounds attribute was not valid." + case .missingAttributeRounds: + return "The number of rounds attribute was missing." + case .invalidAlgorithmParms: + return "An algorithm parameters attribute was not valid." + case .missingAlgorithmParms: + return "An algorithm parameters attribute was missing." + case .invalidAttributeLabel: + return "A label attribute was not valid." + case .missingAttributeLabel: + return "A label attribute was missing." + case .invalidAttributeKeyType: + return "A key type attribute was not valid." + case .missingAttributeKeyType: + return "A key type attribute was missing." + case .invalidAttributeMode: + return "A mode attribute was not valid." + case .missingAttributeMode: + return "A mode attribute was missing." + case .invalidAttributeEffectiveBits: + return "An effective bits attribute was not valid." + case .missingAttributeEffectiveBits: + return "An effective bits attribute was missing." + case .invalidAttributeStartDate: + return "A start date attribute was not valid." + case .missingAttributeStartDate: + return "A start date attribute was missing." + case .invalidAttributeEndDate: + return "An end date attribute was not valid." + case .missingAttributeEndDate: + return "An end date attribute was missing." + case .invalidAttributeVersion: + return "A version attribute was not valid." + case .missingAttributeVersion: + return "A version attribute was missing." + case .invalidAttributePrime: + return "A prime attribute was not valid." + case .missingAttributePrime: + return "A prime attribute was missing." + case .invalidAttributeBase: + return "A base attribute was not valid." + case .missingAttributeBase: + return "A base attribute was missing." + case .invalidAttributeSubprime: + return "A subprime attribute was not valid." + case .missingAttributeSubprime: + return "A subprime attribute was missing." + case .invalidAttributeIterationCount: + return "An iteration count attribute was not valid." + case .missingAttributeIterationCount: + return "An iteration count attribute was missing." + case .invalidAttributeDLDBHandle: + return "A database handle attribute was not valid." + case .missingAttributeDLDBHandle: + return "A database handle attribute was missing." + case .invalidAttributeAccessCredentials: + return "An access credentials attribute was not valid." + case .missingAttributeAccessCredentials: + return "An access credentials attribute was missing." + case .invalidAttributePublicKeyFormat: + return "A public key format attribute was not valid." + case .missingAttributePublicKeyFormat: + return "A public key format attribute was missing." + case .invalidAttributePrivateKeyFormat: + return "A private key format attribute was not valid." + case .missingAttributePrivateKeyFormat: + return "A private key format attribute was missing." + case .invalidAttributeSymmetricKeyFormat: + return "A symmetric key format attribute was not valid." + case .missingAttributeSymmetricKeyFormat: + return "A symmetric key format attribute was missing." + case .invalidAttributeWrappedKeyFormat: + return "A wrapped key format attribute was not valid." + case .missingAttributeWrappedKeyFormat: + return "A wrapped key format attribute was missing." + case .stagedOperationInProgress: + return "A staged operation is in progress." + case .stagedOperationNotStarted: + return "A staged operation was not started." + case .verifyFailed: + return "A cryptographic verification failure has occurred." + case .querySizeUnknown: + return "The query size is unknown." + case .blockSizeMismatch: + return "A block size mismatch occurred." + case .publicKeyInconsistent: + return "The public key was inconsistent." + case .deviceVerifyFailed: + return "A device verification failure has occurred." + case .invalidLoginName: + return "An invalid login name was detected." + case .alreadyLoggedIn: + return "The user is already logged in." + case .invalidDigestAlgorithm: + return "An invalid digest algorithm was detected." + case .invalidCRLGroup: + return "An invalid CRL group was detected." + case .certificateCannotOperate: + return "The certificate cannot operate." + case .certificateExpired: + return "An expired certificate was detected." + case .certificateNotValidYet: + return "The certificate is not yet valid." + case .certificateRevoked: + return "The certificate was revoked." + case .certificateSuspended: + return "The certificate was suspended." + case .insufficientCredentials: + return "Insufficient credentials were detected." + case .invalidAction: + return "The action was not valid." + case .invalidAuthority: + return "The authority was not valid." + case .verifyActionFailed: + return "A verify action has failed." + case .invalidCertAuthority: + return "The certificate authority was not valid." + case .invaldCRLAuthority: + return "The CRL authority was not valid." + case .invalidCRLEncoding: + return "The CRL encoding was not valid." + case .invalidCRLType: + return "The CRL type was not valid." + case .invalidCRL: + return "The CRL was not valid." + case .invalidFormType: + return "The form type was not valid." + case .invalidID: + return "The ID was not valid." + case .invalidIdentifier: + return "The identifier was not valid." + case .invalidIndex: + return "The index was not valid." + case .invalidPolicyIdentifiers: + return "The policy identifiers are not valid." + case .invalidTimeString: + return "The time specified was not valid." + case .invalidReason: + return "The trust policy reason was not valid." + case .invalidRequestInputs: + return "The request inputs are not valid." + case .invalidResponseVector: + return "The response vector was not valid." + case .invalidStopOnPolicy: + return "The stop-on policy was not valid." + case .invalidTuple: + return "The tuple was not valid." + case .multipleValuesUnsupported: + return "Multiple values are not supported." + case .notTrusted: + return "The trust policy was not trusted." + case .noDefaultAuthority: + return "No default authority was detected." + case .rejectedForm: + return "The trust policy had a rejected form." + case .requestLost: + return "The request was lost." + case .requestRejected: + return "The request was rejected." + case .unsupportedAddressType: + return "The address type is not supported." + case .unsupportedService: + return "The service is not supported." + case .invalidTupleGroup: + return "The tuple group was not valid." + case .invalidBaseACLs: + return "The base ACLs are not valid." + case .invalidTupleCredendtials: + return "The tuple credentials are not valid." + case .invalidEncoding: + return "The encoding was not valid." + case .invalidValidityPeriod: + return "The validity period was not valid." + case .invalidRequestor: + return "The requestor was not valid." + case .requestDescriptor: + return "The request descriptor was not valid." + case .invalidBundleInfo: + return "The bundle information was not valid." + case .invalidCRLIndex: + return "The CRL index was not valid." + case .noFieldValues: + return "No field values were detected." + case .unsupportedFieldFormat: + return "The field format is not supported." + case .unsupportedIndexInfo: + return "The index information is not supported." + case .unsupportedLocality: + return "The locality is not supported." + case .unsupportedNumAttributes: + return "The number of attributes is not supported." + case .unsupportedNumIndexes: + return "The number of indexes is not supported." + case .unsupportedNumRecordTypes: + return "The number of record types is not supported." + case .fieldSpecifiedMultiple: + return "Too many fields were specified." + case .incompatibleFieldFormat: + return "The field format was incompatible." + case .invalidParsingModule: + return "The parsing module was not valid." + case .databaseLocked: + return "The database is locked." + case .datastoreIsOpen: + return "The data store is open." + case .missingValue: + return "A missing value was detected." + case .unsupportedQueryLimits: + return "The query limits are not supported." + case .unsupportedNumSelectionPreds: + return "The number of selection predicates is not supported." + case .unsupportedOperator: + return "The operator is not supported." + case .invalidDBLocation: + return "The database location is not valid." + case .invalidAccessRequest: + return "The access request is not valid." + case .invalidIndexInfo: + return "The index information is not valid." + case .invalidNewOwner: + return "The new owner is not valid." + case .invalidModifyMode: + return "The modify mode is not valid." + case .missingRequiredExtension: + return "A required certificate extension is missing." + case .extendedKeyUsageNotCritical: + return "The extended key usage extension was not marked critical." + case .timestampMissing: + return "A timestamp was expected but was not found." + case .timestampInvalid: + return "The timestamp was not valid." + case .timestampNotTrusted: + return "The timestamp was not trusted." + case .timestampServiceNotAvailable: + return "The timestamp service is not available." + case .timestampBadAlg: + return "An unrecognized or unsupported Algorithm Identifier in timestamp." + case .timestampBadRequest: + return "The timestamp transaction is not permitted or supported." + case .timestampBadDataFormat: + return "The timestamp data submitted has the wrong format." + case .timestampTimeNotAvailable: + return "The time source for the Timestamp Authority is not available." + case .timestampUnacceptedPolicy: + return "The requested policy is not supported by the Timestamp Authority." + case .timestampUnacceptedExtension: + return "The requested extension is not supported by the Timestamp Authority." + case .timestampAddInfoNotAvailable: + return "The additional information requested is not available." + case .timestampSystemFailure: + return "The timestamp request cannot be handled due to system failure." + case .signingTimeMissing: + return "A signing time was expected but was not found." + case .timestampRejection: + return "A timestamp transaction was rejected." + case .timestampWaiting: + return "A timestamp transaction is waiting." + case .timestampRevocationWarning: + return "A timestamp authority revocation warning was issued." + case .timestampRevocationNotification: + return "A timestamp authority revocation notification was issued." + case .unexpectedError: + return "Unexpected error has occurred." + } + } +} + +extension Status: CustomNSError { + public static let errorDomain = "com.radixdlt.radidxswift.status.error" + + public var errorCode: Int { + return Int(rawValue) + } + + public var errorUserInfo: [String: Any] { + return [NSLocalizedDescriptionKey: description] + } +} +// swiftlint:enable all diff --git a/Package.swift b/Package.swift index 8a30fa5a..cf170d04 100644 --- a/Package.swift +++ b/Package.swift @@ -1,4 +1,4 @@ -// swift-tools-version: 5.6 +// swift-tools-version: 5.7 // The swift-tools-version declares the minimum version of Swift required to build this package. import PackageDescription @@ -62,15 +62,12 @@ let package = Package( url: "https://github.com/apple/swift-log.git", from: "1.4.4" ), - // This doesnt seem to be working properly on command line, removing for now -// .package(url: "https://github.com/realm/SwiftLint.git", branch: "main"), .package(url: "git@github.com:apple/swift-protobuf.git", from: "1.7.0"), .package(url: "git@github.com:antlr/antlr4.git", branch: "master"), - .package(url: "git@github.com:input-output-hk/atala-prism-didcomm-swift.git", from: "0.3.4"), - .package(url: "git@github.com:input-output-hk/atala-prism-crypto-sdk-sp.git", from: "1.4.1"), + .package(url: "git@github.com:input-output-hk/atala-prism-didcomm-swift.git", from: "0.3.6"), .package(url: "git@github.com:swift-libp2p/swift-multibase.git", branch: "main"), .package(url: "git@github.com:Kitura/Swift-JWT.git", from: "4.0.0"), - .package(url: "git@github.com:goncalo-frade-iohk/swift-docc-plugin.git", from: "1.2.0") + .package(url: "git@github.com:GigaBitcoin/secp256k1.swift.git", from: "0.5.0") ], targets: [ .target( @@ -84,8 +81,7 @@ let package = Package( "Pollux", "PrismAgent" ], - path: "AtalaPrismSDK/AtalaPrismSDK/Sources", - resources: [.process("Documentation.docc/Resources")] + path: "AtalaPrismSDK/AtalaPrismSDK/Sources" ), .target( name: "Domain", @@ -101,7 +97,7 @@ let package = Package( dependencies: [ "Domain", "Core", - .product(name: "PrismAPI", package: "atala-prism-crypto-sdk-sp"), + .product(name: "secp256k1", package: "secp256k1.swift"), .product(name: "SwiftJWT", package: "Swift-JWT") ], path: "AtalaPrismSDK/Apollo/Sources" diff --git a/Sample/AtalaPrismWalletDemo/AtalaPrismWalletDemo/Modules/AuthenticateWallet/AuthenticateWalletViewModel.swift b/Sample/AtalaPrismWalletDemo/AtalaPrismWalletDemo/Modules/AuthenticateWallet/AuthenticateWalletViewModel.swift index 949000e2..4f2906a9 100644 --- a/Sample/AtalaPrismWalletDemo/AtalaPrismWalletDemo/Modules/AuthenticateWallet/AuthenticateWalletViewModel.swift +++ b/Sample/AtalaPrismWalletDemo/AtalaPrismWalletDemo/Modules/AuthenticateWallet/AuthenticateWalletViewModel.swift @@ -52,13 +52,12 @@ class AuthenticateWalletViewModelImpl: AuthenticateWalletViewModel { } func createPrismDID() { - // Wallet logic side - let seed = createOrGetSeed() - let keyPair = apollo.createKeyPair(seed: seed, curve: .secp256k1(index: 0)) - setPrivateKey(privateKey: keyPair.privateKey) - // Integration with Atala Prism side do { + // Wallet logic side + let seed = createOrGetSeed() + let keyPair = try apollo.createKeyPair(seed: seed, curve: .secp256k1(index: 0)) + setPrivateKey(privateKey: keyPair.privateKey) did = try authenticate.createPrismDIDForAuthenticate(publicKey: keyPair.publicKey).string } catch { self.error = error diff --git a/Sample/AtalaPrismWalletDemo/AtalaPrismWalletDemo/Modules/SetupPrismAgent/SetupPrismAgentViewModel.swift b/Sample/AtalaPrismWalletDemo/AtalaPrismWalletDemo/Modules/SetupPrismAgent/SetupPrismAgentViewModel.swift index 6153d496..1dea13fe 100644 --- a/Sample/AtalaPrismWalletDemo/AtalaPrismWalletDemo/Modules/SetupPrismAgent/SetupPrismAgentViewModel.swift +++ b/Sample/AtalaPrismWalletDemo/AtalaPrismWalletDemo/Modules/SetupPrismAgent/SetupPrismAgentViewModel.swift @@ -50,15 +50,17 @@ final class SetupPrismAgentViewModelImpl: ObservableObject, SetupPrismAgentViewM func parseOOBMessage() async throws { do { - let message = try await agent.parseOOBInvitation(url: oobUrl) + let message = try agent.parseOOBInvitation(url: oobUrl) try await agent.acceptDIDCommInvitation(invitation: message) - } catch let error as MercuryError { + } catch let error as CommonError { switch error { - case let .urlSessionError(statusCode, error, msg): - print("Error: \(statusCode)") + case let .httpError(_, message): + print("Error: \(message)") default: break } + } catch let error as LocalizedError { + print("Error: \(error.errorDescription)") } } @@ -97,30 +99,31 @@ final class SetupPrismAgentViewModelImpl: ObservableObject, SetupPrismAgentViewM } func startIssueCredentialProtocol() async { - do { - try await agent.issueCredentialProtocol() - } catch let error as MercuryError { - switch error { - case let .urlSessionError(statusCode, error, msg): - print("Error: \(statusCode)") - case let .didcommError(msg): - if msg.contains("Invalid state") { - print("") - } - print("Error: \(msg)") - default: - break - } - if error.localizedDescription.contains("Invalid state") { - print("") - } - print("Error: \(error.localizedDescription)") - } catch { - await MainActor.run { - self.error = error.localizedDescription - print(error.localizedDescription) - } - } - print("Finished") + // TODO: This needs to be redone. +// do { +// try await agent.issueCredentialProtocol() +// } catch let error as MercuryError { +// switch error { +// case let .urlSessionError(statusCode, error, msg): +// print("Error: \(statusCode)") +// case let .didcommError(msg): +// if msg.contains("Invalid state") { +// print("") +// } +// print("Error: \(msg)") +// default: +// break +// } +// if error.localizedDescription.contains("Invalid state") { +// print("") +// } +// print("Error: \(error.localizedDescription)") +// } catch { +// await MainActor.run { +// self.error = error.localizedDescription +// print(error.localizedDescription) +// } +// } +// print("Finished") } } diff --git a/Sample/AtalaPrismWalletDemo/AtalaPrismWalletDemo/Modules/WalletDemo/AddNewContact/AddNewContactViewModel.swift b/Sample/AtalaPrismWalletDemo/AtalaPrismWalletDemo/Modules/WalletDemo/AddNewContact/AddNewContactViewModel.swift index eb10114a..a9faf547 100644 --- a/Sample/AtalaPrismWalletDemo/AtalaPrismWalletDemo/Modules/WalletDemo/AddNewContact/AddNewContactViewModel.swift +++ b/Sample/AtalaPrismWalletDemo/AtalaPrismWalletDemo/Modules/WalletDemo/AddNewContact/AddNewContactViewModel.swift @@ -68,9 +68,7 @@ final class AddNewContactViewModelImpl: AddNewContactViewModel { } } catch let error as MercuryError { switch error { - case let .urlSessionError(statusCode, error, msg): - print("HTTP Error: \(statusCode)") - case let .didcommError(msg): + case let .didcommError(msg, _): print("Error: \(msg)") default: break @@ -78,11 +76,23 @@ final class AddNewContactViewModelImpl: AddNewContactViewModel { await MainActor.run { self.flowStep = .error(DisplayErrorState(error: error)) } + print("Error: \(error.errorDescription)") + + } catch let error as CommonError { + switch error { + case let .httpError(code, _): + print("HTTP Error: \(code)") + default: + break + } + await MainActor.run { + self.flowStep = .error(DisplayErrorState(error: error)) + } print("Error: \(error.localizedDescription)") - } catch { + } catch let error as LocalizedError { await MainActor.run { self.flowStep = .error(DisplayErrorState(error: error)) - print(error.localizedDescription) + print(error.errorDescription) } } } diff --git a/Sample/AtalaPrismWalletDemo/AtalaPrismWalletDemo/Modules/WalletDemo/ProofOfRequest/ProofOfRequestViewModel.swift b/Sample/AtalaPrismWalletDemo/AtalaPrismWalletDemo/Modules/WalletDemo/ProofOfRequest/ProofOfRequestViewModel.swift index a85f64ad..3b53ebab 100644 --- a/Sample/AtalaPrismWalletDemo/AtalaPrismWalletDemo/Modules/WalletDemo/ProofOfRequest/ProofOfRequestViewModel.swift +++ b/Sample/AtalaPrismWalletDemo/AtalaPrismWalletDemo/Modules/WalletDemo/ProofOfRequest/ProofOfRequestViewModel.swift @@ -59,7 +59,7 @@ final class ProofOfRequestViewModelImpl: ProofOfRequestViewModel { loading = true Task { do { - try await agent.presentCredentialProof( + try await self.presentCredentialProof( request: self.proofOfRequest, credential: selectedCredential ) @@ -81,6 +81,29 @@ final class ProofOfRequestViewModelImpl: ProofOfRequestViewModel { } } + func presentCredentialProof( + request: RequestPresentation, + credential: VerifiableCredential + ) async throws { + guard let jwtBase64 = credential.id.data(using: .utf8)?.base64UrlEncodedString() else { + throw UnknownError.somethingWentWrongError( + customMessage: "Could not decode JWT Credential", + underlyingErrors: nil + ) + } + let presentation = Presentation( + body: .init(goalCode: request.body.goalCode, comment: request.body.comment), + attachments: [try .build( + payload: AttachmentBase64(base64: jwtBase64), + mediaType: "prism/jwt" + )], + thid: request.id, + from: request.to, + to: request.from + ) + _ = try await agent.sendMessage(message: presentation.makeMessage()) + } + func confirmDismiss() { guard let index = agent.requestedPresentations diff --git a/Sample/DIDChat/DIDChat/Modules/ContactsView/ContactsView.swift b/Sample/DIDChat/DIDChat/Modules/ContactsView/ContactsView.swift index 317d992d..8d819404 100644 --- a/Sample/DIDChat/DIDChat/Modules/ContactsView/ContactsView.swift +++ b/Sample/DIDChat/DIDChat/Modules/ContactsView/ContactsView.swift @@ -36,6 +36,7 @@ struct ContactList: Vi } } } + #if !os(macOS) .navigationBarTitle("Contacts") .navigationBarItems(trailing: HStack { Button(action: { @@ -49,6 +50,7 @@ struct ContactList: Vi Image(systemName: "doc.plaintext") } }) + #endif .sheet(isPresented: $showAddContact) { AddContactView().environmentObject(viewModel) }