Tworzenie własnej kryptowaluty może brzmieć jak zadanie dla zaawansowanych programistów blockchain, ale dzięki nowoczesnym narzędziom i technologiom jest to bardziej dostępne, niż się wydaje. Swift, choć nie jest pierwszym wyborem do tego celu, daje programistom możliwość eksperymentowania i budowania podstawowych systemów kryptowalutowych dzięki wsparciu dla kryptografii oraz frameworkom, takim jak CryptoKit.
W tym artykule pokażemy, jak stworzyć prostą wersję kryptowaluty w Swift. Oczywiście nie będzie to w pełni funkcjonalny system na miarę Bitcoina, ale taki, który pokaże zasady działania blockchainu i tokenów.
Czym jest kryptowaluta?
Kryptowaluta to cyfrowy środek wymiany, który wykorzystuje technologię blockchain, aby zapewnić bezpieczeństwo, przejrzystość i decentralizację. Główne cechy kryptowaluty to:
Decentralizacja – brak centralnego zarządzania.
Bezpieczeństwo – każda transakcja jest kryptograficznie zabezpieczona.
Niezmienność – zapis w blockchainie nie może zostać zmodyfikowany.
Podstawowe komponenty kryptowaluty
Tworząc kryptowalutę w Swift, musimy zaimplementować trzy kluczowe elementy:
Blockchain – łańcuch bloków, w którym zapisane są transakcje.
Transakcje – zapis transferu wartości pomiędzy użytkownikami.
Tokeny – reprezentacja wartości w systemie.
Jak stworzyć prosty blockchain w Swift
Na potrzeby tego projektu blockchain będzie prostą strukturą, która przechowuje bloki zawierające dane transakcji. Każdy blok ma unikalny identyfikator (hash) oraz odniesienie do poprzedniego bloku.
import Foundation
import CryptoKit
struct Block {
let index: Int
let timestamp: Date
let previousHash: String
let data: String
let hash: String
init(index: Int, timestamp: Date, previousHash: String, data: String) {
self.index = index
self.timestamp = timestamp
self.previousHash = previousHash
self.data = data
self.hash = Block.generateHash(index: index, timestamp: timestamp, previousHash: previousHash, data: data)
}
static func generateHash(index: Int, timestamp: Date, previousHash: String, data: String) -> String {
let input = "\(index)\(timestamp)\(previousHash)\(data)"
let hash = SHA256.hash(data: Data(input.utf8))
return hash.compactMap { String(format: "%02x", $0) }.joined()
}
}
var blockchain: [Block] = [Block(index: 0, timestamp: Date(), previousHash: "0", data: "Genesis Block")]
func addBlock(data: String) {
let lastBlock = blockchain.last!
let newBlock = Block(index: lastBlock.index + 1, timestamp: Date(), previousHash: lastBlock.hash, data: data)
blockchain.append(newBlock)
}
addBlock(data: "Pierwsza transakcja")
addBlock(data: "Druga transakcja")
for block in blockchain {
print("Index: \(block.index), Hash: \(block.hash)")
}Dodanie funkcji transakcji
W blockchainie transakcje są podstawą każdej kryptowaluty. Możemy zdefiniować prostą strukturę transakcji:
struct Transaction {
let sender: String
let receiver: String
let amount: Double
}
struct BlockWithTransactions {
let index: Int
let timestamp: Date
let previousHash: String
let transactions: [Transaction]
let hash: String
init(index: Int, timestamp: Date, previousHash: String, transactions: [Transaction]) {
self.index = index
self.timestamp = timestamp
self.previousHash = previousHash
self.transactions = transactions
self.hash = BlockWithTransactions.generateHash(index: index, timestamp: timestamp, previousHash: previousHash, transactions: transactions)
}
static func generateHash(index: Int, timestamp: Date, previousHash: String, transactions: [Transaction]) -> String {
let transactionsData = transactions.map { "\($0.sender)\($0.receiver)\($0.amount)" }.joined()
let input = "\(index)\(timestamp)\(previousHash)\(transactionsData)"
let hash = SHA256.hash(data: Data(input.utf8))
return hash.compactMap { String(format: "%02x", $0) }.joined()
}
}Wykorzystanie kryptografii do podpisów
Aby transakcje były bezpieczne i możliwe do zweryfikowania, dodamy podpisy cyfrowe za pomocą CryptoKit:
import CryptoKit
struct SignedTransaction {
let sender: P256.Signing.PublicKey
let receiver: P256.Signing.PublicKey
let amount: Double
let signature: Data
func isValid() -> Bool {
let data = "\(sender)\(receiver)\(amount)".data(using: .utf8)!
return sender.isValidSignature(signature, for: data)
}
}
let senderPrivateKey = P256.Signing.PrivateKey()
let receiverPrivateKey = P256.Signing.PrivateKey()
let senderPublicKey = senderPrivateKey.publicKey
let receiverPublicKey = receiverPrivateKey.publicKey
let amount = 100.0
let data = "\(senderPublicKey)\(receiverPublicKey)\(amount)".data(using: .utf8)!
let signature = try! senderPrivateKey.signature(for: data)
let transaction = SignedTransaction(sender: senderPublicKey, receiver: receiverPublicKey, amount: amount, signature: signature)
print("Czy transakcja jest prawidłowa? \(transaction.isValid())")Co dalej?
Ten prosty przykład pokazuje podstawy tworzenia kryptowaluty w Swift. Oczywiście, aby stworzyć w pełni funkcjonalny system, należałoby zaimplementować:
Mechanizm konsensusu (np. Proof of Work lub Proof of Stake),
Zarządzanie portfelami i saldami użytkowników,
Komunikację sieciową między węzłami blockchaina,
Mechanizmy ochrony przed atakami (np. Double Spend).
Tworzenie kryptowaluty to ambitne wyzwanie, ale też doskonały sposób na naukę blockchainu, kryptografii i programowania systemów rozproszonych. Dzięki Swift i CryptoKit masz solidne podstawy, by zacząć swoją przygodę z tym fascynującym tematem!
