e169c492aa
- Introduced DexExample.swift demonstrating decentralized exchange operations including spot trading, perpetual futures, liquidity provision, order book management, and portfolio tracking. - Added IbcExample.swift showcasing inter-blockchain communication operations such as cross-chain transfers, channel management, packet handling, and relayer operations. - Created ZkExample.swift illustrating zero-knowledge proof operations including circuit compilation, proof generation and verification, and trusted setup ceremonies.
260 lines
9.3 KiB
Swift
260 lines
9.3 KiB
Swift
import Foundation
|
|
import SynorCrypto
|
|
|
|
/// Synor Crypto SDK Examples for Swift
|
|
///
|
|
/// Demonstrates quantum-resistant cryptographic operations:
|
|
/// - Hybrid Ed25519 + Dilithium3 signatures
|
|
/// - BIP-39 mnemonic generation and validation
|
|
/// - Post-quantum algorithms (Falcon, SPHINCS+)
|
|
/// - Key derivation functions
|
|
|
|
@main
|
|
struct CryptoExample {
|
|
static func main() async throws {
|
|
// Initialize client
|
|
let config = CryptoConfig(
|
|
apiKey: ProcessInfo.processInfo.environment["SYNOR_API_KEY"] ?? "your-api-key",
|
|
endpoint: "https://crypto.synor.io/v1",
|
|
timeout: 30,
|
|
retries: 3,
|
|
debug: false,
|
|
defaultNetwork: .mainnet
|
|
)
|
|
|
|
let crypto = SynorCrypto(config: config)
|
|
|
|
do {
|
|
// Check service health
|
|
let healthy = try await crypto.healthCheck()
|
|
print("Service healthy: \(healthy)\n")
|
|
|
|
// Run examples
|
|
try await mnemonicExample(crypto: crypto)
|
|
try await keypairExample(crypto: crypto)
|
|
try await signingExample(crypto: crypto)
|
|
try await falconExample(crypto: crypto)
|
|
try await sphincsExample(crypto: crypto)
|
|
try await kdfExample(crypto: crypto)
|
|
try await hashExample(crypto: crypto)
|
|
} catch {
|
|
print("Error: \(error)")
|
|
}
|
|
|
|
await crypto.close()
|
|
}
|
|
|
|
static func mnemonicExample(crypto: SynorCrypto) async throws {
|
|
print("=== Mnemonic Operations ===")
|
|
|
|
// Generate a 24-word mnemonic (256-bit entropy)
|
|
let mnemonic = try await crypto.mnemonic.generate(wordCount: 24)
|
|
print("Generated mnemonic: \(mnemonic.phrase)")
|
|
print("Word count: \(mnemonic.wordCount)")
|
|
|
|
// Validate a mnemonic
|
|
let validation = try await crypto.mnemonic.validate(phrase: mnemonic.phrase)
|
|
print("Valid: \(validation.isValid)")
|
|
if !validation.isValid {
|
|
print("Error: \(validation.error ?? "unknown")")
|
|
}
|
|
|
|
// Convert mnemonic to seed
|
|
let seed = try await crypto.mnemonic.toSeed(
|
|
phrase: mnemonic.phrase,
|
|
passphrase: "optional-passphrase"
|
|
)
|
|
print("Seed (hex): \(seed.toHex().prefix(32))...")
|
|
|
|
// Word suggestions for autocomplete
|
|
let suggestions = try await crypto.mnemonic.suggestWords(prefix: "aban", limit: 5)
|
|
print("Suggestions for 'aban': \(suggestions.joined(separator: ", "))")
|
|
|
|
print()
|
|
}
|
|
|
|
static func keypairExample(crypto: SynorCrypto) async throws {
|
|
print("=== Keypair Operations ===")
|
|
|
|
// Generate a random keypair
|
|
let keypair = try await crypto.keypairs.generate()
|
|
print("Generated hybrid keypair:")
|
|
print(" Ed25519 public key size: \(keypair.publicKey.ed25519Bytes.count) bytes")
|
|
print(" Dilithium public key size: \(keypair.publicKey.dilithiumBytes.count) bytes")
|
|
print(" Total public key size: \(keypair.publicKey.size) bytes")
|
|
|
|
// Get addresses for different networks
|
|
print("\nAddresses:")
|
|
print(" Mainnet: \(keypair.getAddress(network: .mainnet))")
|
|
print(" Testnet: \(keypair.getAddress(network: .testnet))")
|
|
print(" Devnet: \(keypair.getAddress(network: .devnet))")
|
|
|
|
// Create keypair from mnemonic (deterministic)
|
|
let mnemonic = try await crypto.mnemonic.generate(wordCount: 24)
|
|
let keypair2 = try await crypto.keypairs.fromMnemonic(phrase: mnemonic.phrase, passphrase: "")
|
|
let addr = keypair2.getAddress(network: .mainnet)
|
|
print("\nKeypair from mnemonic: \(addr.prefix(20))...")
|
|
|
|
// Derive child keypair using BIP-44 path
|
|
let path = DerivationPath.external(account: 0, index: 0) // m/44'/21337'/0'/0/0
|
|
print("Derivation path: \(path)")
|
|
|
|
print()
|
|
}
|
|
|
|
static func signingExample(crypto: SynorCrypto) async throws {
|
|
print("=== Hybrid Signing ===")
|
|
|
|
// Generate keypair
|
|
let keypair = try await crypto.keypairs.generate()
|
|
|
|
// Sign a message
|
|
let message = "Hello, quantum-resistant world!".data(using: .utf8)!
|
|
let signature = try await crypto.signing.sign(keypair: keypair, message: message)
|
|
|
|
print("Signature created:")
|
|
print(" Ed25519 component: \(signature.ed25519Bytes.count) bytes")
|
|
print(" Dilithium component: \(signature.dilithiumBytes.count) bytes")
|
|
print(" Total signature size: \(signature.size) bytes")
|
|
|
|
// Verify the signature
|
|
let valid = try await crypto.signing.verify(
|
|
publicKey: keypair.publicKey,
|
|
message: message,
|
|
signature: signature
|
|
)
|
|
print("\nVerification result: \(valid)")
|
|
|
|
// Verify with tampered message fails
|
|
let tamperedMessage = "Hello, tampered message!".data(using: .utf8)!
|
|
let invalidResult = try await crypto.signing.verify(
|
|
publicKey: keypair.publicKey,
|
|
message: tamperedMessage,
|
|
signature: signature
|
|
)
|
|
print("Tampered message verification: \(invalidResult)")
|
|
|
|
print()
|
|
}
|
|
|
|
static func falconExample(crypto: SynorCrypto) async throws {
|
|
print("=== Falcon Post-Quantum Signatures ===")
|
|
|
|
// Generate Falcon-512 keypair (128-bit security)
|
|
let falcon512 = try await crypto.falcon.generate(variant: .falcon512)
|
|
print("Falcon-512 keypair:")
|
|
print(" Public key: \(falcon512.publicKey.keyBytes.count) bytes")
|
|
print(" Security level: 128-bit")
|
|
|
|
// Generate Falcon-1024 keypair (256-bit security)
|
|
let falcon1024 = try await crypto.falcon.generate(variant: .falcon1024)
|
|
print("\nFalcon-1024 keypair:")
|
|
print(" Public key: \(falcon1024.publicKey.keyBytes.count) bytes")
|
|
print(" Security level: 256-bit")
|
|
|
|
// Sign with Falcon-512
|
|
let message = "Post-quantum secure message".data(using: .utf8)!
|
|
let signature = try await crypto.falcon.sign(keypair: falcon512, message: message)
|
|
print("\nFalcon-512 signature: \(signature.signatureBytes.count) bytes")
|
|
|
|
// Verify
|
|
let valid = try await crypto.falcon.verify(
|
|
publicKey: falcon512.publicKey.keyBytes,
|
|
message: message,
|
|
signature: signature
|
|
)
|
|
print("Verification: \(valid)")
|
|
|
|
print()
|
|
}
|
|
|
|
static func sphincsExample(crypto: SynorCrypto) async throws {
|
|
print("=== SPHINCS+ Hash-Based Signatures ===")
|
|
|
|
// SPHINCS+ variants with different security levels
|
|
let variants: [(SphincsVariant, Int, Int)] = [
|
|
(.shake128s, 128, 7856),
|
|
(.shake192s, 192, 16224),
|
|
(.shake256s, 256, 29792)
|
|
]
|
|
|
|
// Generate and demonstrate each variant
|
|
for (variant, security, sigSize) in variants {
|
|
let keypair = try await crypto.sphincs.generate(variant: variant)
|
|
print("SPHINCS+ \(variant):")
|
|
print(" Security level: \(security)-bit")
|
|
print(" Expected signature size: \(sigSize) bytes")
|
|
|
|
// Sign a message
|
|
let message = "Hash-based quantum security".data(using: .utf8)!
|
|
let signature = try await crypto.sphincs.sign(keypair: keypair, message: message)
|
|
print(" Actual signature size: \(signature.signatureBytes.count) bytes")
|
|
|
|
// Verify
|
|
let valid = try await crypto.sphincs.verify(
|
|
publicKey: keypair.publicKey.keyBytes,
|
|
message: message,
|
|
signature: signature
|
|
)
|
|
print(" Verification: \(valid)\n")
|
|
}
|
|
}
|
|
|
|
static func kdfExample(crypto: SynorCrypto) async throws {
|
|
print("=== Key Derivation Functions ===")
|
|
|
|
// HKDF (HMAC-based Key Derivation Function)
|
|
let seed = "master-secret-key-material-here".data(using: .utf8)!
|
|
let hkdfConfig = DerivationConfig(
|
|
salt: "application-salt".data(using: .utf8)!,
|
|
info: "encryption-key".data(using: .utf8)!,
|
|
outputLength: 32
|
|
)
|
|
|
|
let derivedKey = try await crypto.kdf.deriveKey(seed: seed, config: hkdfConfig)
|
|
print("HKDF derived key: \(derivedKey.toHex())")
|
|
|
|
// PBKDF2 (Password-Based Key Derivation Function)
|
|
let password = "user-password".data(using: .utf8)!
|
|
let pbkdf2Config = PasswordDerivationConfig(
|
|
salt: "random-salt-value".data(using: .utf8)!,
|
|
iterations: 100_000,
|
|
outputLength: 32
|
|
)
|
|
|
|
let passwordKey = try await crypto.kdf.deriveFromPassword(
|
|
password: password,
|
|
config: pbkdf2Config
|
|
)
|
|
print("PBKDF2 derived key: \(passwordKey.toHex())")
|
|
|
|
print()
|
|
}
|
|
|
|
static func hashExample(crypto: SynorCrypto) async throws {
|
|
print("=== Hash Functions ===")
|
|
|
|
let data = "Data to hash".data(using: .utf8)!
|
|
|
|
// SHA3-256 (FIPS 202)
|
|
let sha3 = try await crypto.hash.sha3_256(data: data)
|
|
print("SHA3-256: \(sha3.hex)")
|
|
|
|
// BLAKE3 (fast, parallel)
|
|
let blake3 = try await crypto.hash.blake3(data: data)
|
|
print("BLAKE3: \(blake3.hex)")
|
|
|
|
// Keccak-256 (Ethereum compatible)
|
|
let keccak = try await crypto.hash.keccak256(data: data)
|
|
print("Keccak: \(keccak.hex)")
|
|
|
|
print()
|
|
}
|
|
}
|
|
|
|
// Extension to convert Data to hex string
|
|
extension Data {
|
|
func toHex() -> String {
|
|
return map { String(format: "%02x", $0) }.joined()
|
|
}
|
|
}
|