Building your first Swift blockchain application

As a revolutionary technology, blockchain is gaining more and more popularity. Why? Because blockchain is the underlying technology of many cryptocurrencies, such as Bitcoin (BTC), Ethereum (ETH) and Litecoin (LTC). How does blockchain work? This tutorial will cover all the knowledge related to blockchain and teach you how to build a Swift blockchain. Let's get started!

How blockchain works

As the name suggests, blockchain is a chain of connected blocks. Each block contains three pieces of information: data, hash, and the hash of the previous block.

1. Data – Due to different application scenarios, the data stored in the block depends on the type of blockchain. For example, in the Bitcoin blockchain, the data stored is the transaction information: the transfer amount and the information of the two parties to the transaction.
2. Hash – You can think of a hash as a digital fingerprint that uniquely identifies a block and its data. The importance of a hash is that it is a unique alphanumeric code, usually 64 characters. When a block is created, a hash is created with it. When a block is modified, the hash is modified as well. Therefore, the hash is very important when you want to see any changes made to a block.
3. Hash of the previous block – By storing the hash of the previous block, you can reconstruct the process of linking each block into the blockchain! This makes the blockchain extremely secure.

Let’s look at this picture:

You can see that each block contains data (not specified in the picture), a hash, and the hash of the previous block. For example, the yellow block contains its own hash: H7s6, and the hash of the red block: 8SD9. This makes them form a chain that is connected to each other. Now, suppose there is a hacker who is ready to maliciously tamper with the red block. Remember, whenever a block is tampered with in any way, the hash of that block will change! When the next block checks and finds that the previous hash is inconsistent, the hacker will not be able to access it because his connection with the previous block has been cut off (Translator's note: If a hacker wants to tamper with a block, he needs to change all the blocks after this block, and this workload is difficult to achieve).

This makes the blockchain extremely secure, and it is almost impossible to roll back or tamper with any data. Although hashing provides a huge guarantee for confidentiality and privacy, there are two more secure and proper measures to make the blockchain even more secure: Proof-of-Work and Smart Contracts. I will not go into detail in this article, you can learn more about it here.

The final way blockchain ensures its security is based on its location. Unlike most data stored on servers and databases, blockchain uses a peer-to-peer (P2P) network. P2P is a network that allows anyone to join, and the data on the network is distributed to every recipient.

Every time someone joins the network, they get a full copy of the blockchain. Every time someone creates a new block, it is broadcast to the entire network. Before adding the block to the chain, the node goes through several complex procedures to determine if the block has been tampered with. This way, everyone and everywhere can use this information. If you are a fan of the HBO American drama Silicon Valley, this should be familiar to you. In the show, the protagonist (Richard) used a similar technology to create a new type of Internet (Translator's Note: Interestingly, the show also issued the blockchain digital currency PiedPaperCoin, interested friends can watch this show).

Because everyone has a copy of the blockchain or a node, they can reach a consensus and decide which blocks are valid. Therefore, if you want to attack a block, you must attack more than 50% of the blocks on the network at the same time (translator: 51% attack) so that your block can catch up and replace the original blockchain. So the blockchain is probably one of the most secure technologies created in the past decade.

About the sample program

Now that you have a basic understanding of the principles of blockchain, let's start writing an example program! You can download the original project here.

As you can see, we have two Bitcoin wallets. The first account 1065 has 500 BTC, while the second account 0217 has no BTC. We can send Bitcoin to another account through the send button. To earn BTC, we can click the Mine button to get a 50 BTC reward. Our main job is to view the console output and observe the transaction process between the two accounts.

In the left navigation bar, you can see two important classes: Block and Blockchain. Currently, both classes have empty implementations. I will show you how to write relevant logic in these two classes. Let's get started!

Defining blocks in Swift

First open Block.swift and add the code to define a block. Before that, we need to define what a block is. We have previously defined that a block is made up of three parts: a hash, the actual recorded data, and the hash of the previous block. When we want to build our blockchain, we must know whether the block is the first or second. We can easily define this in a Swift class as follows:

 var hash: String!
 var data: String!
 var previousHash: String!
 var index : Int !

Now we need to add the most important code. I mentioned that if a block is modified, the hash will also change, which is one of the features that makes blockchain so secure. Therefore we need to create a function to generate a hash composed of random letters and numbers. This function only needs a few lines of code:

 func generateHash() -> String {
 return NSUUID().uuidString.replacingOccurrences( of : "-" , with : "" )
 }

NSUUID is an object that represents a universally unique value and can be bridged to UUID. It can quickly generate 32-bit strings. This function generates a UUID, removes the hyphens, and then returns a String, and finally uses the result as the hash of the block. Block.swift now looks like this:

Now that we have defined the Block class, let’s define the Blockchain class. First, switch to Blockchain.swift.

Defining a blockchain in Swift

As before, let's start by analyzing the basic principles of blockchain. In very basic terms, a blockchain is just a series of blocks connected together, or a list of items. Does this sound familiar? In fact, this is the definition of an array! And this array is made up of blocks! Next, add the following code:

 var chain = [Block]()

Quick tip: This approach can be applied to anything in the world of computer science. If you have a big problem, try breaking it down into smaller problems and building a solution to it, just like we did with how to add blocks and blockchains in Swift.

You will notice that inside the array is the Block class we defined earlier. This is all the variables needed for the blockchain. To complete the functionality, we need to add two more functions to the class. Please try to solve this problem according to the method I taught you before.

What are the two main functions in blockchain?

I hope you can think about this question carefully and answer it! In fact, the two main functions of the blockchain are to create the genesis block (the initial block) and to add new blocks to its end. Of course, I am not going to implement the functions of forking the blockchain and adding smart contracts now, but you must understand that these two are basic functions! Add the following code to Blockchain.swift:

 func createGenesisBlock(data:String) {
    let genesisBlock = Block()
    genesisBlock.hash = genesisBlock.generateHash()
 genesisBlock.data = data
    genesisBlock.previousHash = "0000"  
 genesisBlock.index = 0
    chain.append(genesisBlock)
 } 
 
 func createBlock(data:String) {
 let newBlock = Block()
    newBlock.hash = newBlock.generateHash()
 newBlock.data = data
    newBlock.previousHash = chain[ chain.count -1].hash
    newBlock.index = chain.count  
 chain.append(newBlock)
 }

1. The first function we add is to create the genesis block. To do this, we create a function that takes the block data as an input parameter. Then we define a variable genesisBlock of type Block, which has all the variables and functions previously defined in Block.swift. We assign generateHash() to the hash and the input data parameter to the data. Since this is the first block, we set the hash of the previous block to 0000 so that we know this is the starting block. Finally, we set index to 0 and add this block to the blockchain.

2. The second function we created applies to all blocks after genesisBlock and can create the remaining blocks. You will notice that it is very similar to the first function. The only difference is that we set the value of previousHash to the hash of the previous block and set index to its position in the blockchain. That's it, the blockchain is defined! Your code should look like the image below!

Wallet backend

Now switch to ViewController.swift and you’ll see that all the outlets are already connected. We just need to process the transaction and log it to the console.

However, before that, we need to take a look at the Bitcoin blockchain. Bitcoin is generated by a general account, which we call 0000. When you mine a BTC, it means that you have solved a math problem, so a certain number of bitcoins will be issued as a reward. This provides a smart way to issue coins and can motivate more people to mine. In our application, let's set the mining reward to 100 BTC. First, add the required variables to the view controller:

 let firstAccount = 1065
 let secondAccount = 0217
 let bitcoinChain = Blockchain()
 let reward = 100
 var accounts: [String: Int ] = [ "0000" : 10000000]
 let invalidAlert = UIAlertController(title: "Invalid Transaction" , message: "Please check the details of your transaction as we were unable to process this." , preferredStyle: .alert)

First, define two accounts with numbers 1065 and 0217. Then add a variable called bitcoinChain as our blockchain and set reward to 100. We need a master account as the source of all bitcoins: the genesis account 0000. It contains 10 million bitcoins. You can think of this account as a bank where all the 100 bitcoins generated by rewards are distributed to legitimate accounts. We also define a reminder pop-up window that pops up whenever a transaction cannot be completed.

Now, let's write a few common functions that the runtime will need. Can you guess what they are?

1. The first function is used to process transactions. We need to ensure that the accounts of both parties to the transaction can receive or deduct the correct amount and record this information in our blockchain.
2. The next function prints the entire record to the console - it will show each block and the data within it.
3. The last one is a function used to verify whether the blockchain is valid, by checking whether the previousHash of the next block matches the hash of the previous block. Since we will not demonstrate any hacking methods, in our sample program, the blockchain is always valid.

Transaction Function

Below is a generic trading function. Please enter the following code below the variables we defined:

 func transaction ( from : String, to : String, amount: Int , type: String) {
 // 1
    if accounts[ from ] == nil {
        self.present(invalidAlert, animated: true , completion: nil)
 return  
    } else if accounts[ from ]!-amount < 0 {
        self.present(invalidAlert, animated: true , completion: nil)
 return  
 } else {
        accounts.updateValue(accounts[ from ]!-amount, forKey: from )
 } 
     
 // 2
    if accounts[ to ] == nil {
        accounts.updateValue(amount, forKey: to )
 } else {
        accounts.updateValue(accounts[ to ]!+amount, forKey: to )
 } 
     
 // 3
 if type == "genesis" {
        bitcoinChain.createGenesisBlock(data: "From: \(from); To: \(to); Amount: \(amount)BTC" )
    } else if type == "normal" {
        bitcoinChain.createBlock(data: "From: \(from); To: \(to); Amount: \(amount)BTC" )
 }
 }

The amount of code may seem large, but it mainly defines some rules that each transaction must follow. At the beginning, there are four parameters of the function:

to, from, amount, type. The first three parameters need no further explanation, while Type is mainly used to define the type of transaction. There are two types in total: normal and genesis. Normal transactions will occur between accounts 1065 and 2017, while genesis transactions will involve account 0000.

1. The first if-else conditional statement processes the information of the account to be transferred out. If the account does not exist or the balance is insufficient, it will prompt that the transaction is illegal and return.
2. The second if-else conditional statement handles the transfer to an account. If the account does not exist, a new account is created and the corresponding bitcoins are transferred to it. Otherwise, the correct amount of bitcoins is transferred to the account.
3. The last if-else conditional statement handles the transaction type. If the type is genesis, a genesis block is added, otherwise a new block is created to store the data.

Print Function

To ensure that the transaction is executed correctly, we want to get a list of all transactions after each transaction. The following is the code below our transaction function to print relevant information:

 func chainState() {
 for i in 0...bitcoinChain.chain.count -1 {
        print( "\tBlock: \(bitcoinChain.chain[i].index!)\n\tHash: \(bitcoinChain.chain[i].hash!)\n\tPreviousHash: \(bitcoinChain.chain[i].previousHash!)\n\tData: \(bitcoinChain.chain[i].data!)" )
 }
    redLabel.text = "Balance: \(accounts[String(describing: firstAccount)]!) BTC"  
    blueLabel.text = "Balance: \(accounts[String(describing: secondAccount)]!) BTC"  
 print(accounts)
 print(chainValidity())
 }

This is a simple loop statement that iterates through all blocks in the bitcoinChain and prints the block number, hash, pre-hash, and stored data. At the same time, we update the label in the interface so that the correct amount of BTC in the account can be displayed. Finally, print all accounts (should be 3) and verify the validity of the blockchain.

You should now see an error on the last line of the function. This is because we haven’t implemented the chainValidity() function yet, so let’s do that right away.

Validity Function

The criterion for judging whether a chain is valid is whether the hash of the previous block matches the hash of the current block. We can use a loop statement again to iterate through all the blocks:

 func chainValidity() -> String {
 var isChainValid = true  
 for i in 1...bitcoinChain.chain.count -1 {
        if bitcoinChain.chain[i].previousHash != bitcoinChain.chain[i-1].hash {
            isChainValid = false  
 }
 }
 return   "Chain is valid: \(isChainValid)\n"  
 }

As before, we iterate over all blocks in the bitcoinChain and check if the hash of the previous block is consistent with the previousHash of the current block.

That’s it! We have defined all the functions we need! Your ViewController.swift should look like this:

The final touch is to connect the button to the function. Let’s get started right away!

Make everything connected

When our app is first launched, we need to send 50 BTC from the genesis account 0000 to our first account. Then we need to transfer 10 BTC from the first account to the second account. This only takes three lines of code. The final code in viewDidLoad is as follows:

 override func viewDidLoad() {
 super.viewDidLoad()
 transaction ( from : "0000" , to : "\(firstAccount)" , amount: 50, type: "genesis" )
 transaction ( from : "\(firstAccount)" , to : "\(secondAccount)" , amount: 10, type: "normal" )
 chainState()
    self.invalidAlert.addAction(UIAlertAction(title: "OK" , style: . default , handler: nil))
 }

We use the defined function to transfer money and call the chainState() function. Finally, we also add a UIAlertAction titled OK to invalidAlert.

Now let's implement the remaining four functions: reset(), break(), reset(), and build().

Mining function

The mining function is very simple and only requires three lines of code. Add the following code:

 @IBAction func redMine(_ sender: Any ) {
 transaction ( from : "0000" , to : "\(firstAccount)" , amount: 100, type: "normal" )
    print( "New block mined by: \(firstAccount)" )
 chainState()
 } 
     
 @IBAction func blueMine(_ sender: Any ) {
 transaction ( from : "0000" , to : "\(secondAccount)" , amount: 100, type: "normal" )
    print( "New block mined by: \(secondAccount)" )
 chainState()
 }

In the first mining function, we used the transaction function to send 100 BTC from the genesis account to the first account. We printed the mined block and then printed the state of the blockchain. Similarly, in the blueMine function, we transferred 100 BTC to the second account.

Send Function

The sending function is slightly similar to the mining function:

 @IBAction func redSend(_ sender: Any ) {
 if redAmount.text == "" {
        present(invalidAlert, animated: true , completion: nil)
 } else {
 transaction ( from : "\(firstAccount)" , to : "\(secondAccount)" , amount: Int (redAmount.text!)!, type: "normal" )
        print( "\(redAmount.text!) BTC sent from \(firstAccount) to \(secondAccount)" )
 chainState()
 redAmount.text = ""  
 }
 } 
     
 @IBAction func blueSend(_ sender: Any ) {
    if blueAmount.text == "" {
        present(invalidAlert, animated: true , completion: nil)
 } else {
 transaction ( from : "\(secondAccount)" , to : "\(firstAccount)" , amount: Int (blueAmount.text!)!, type: "normal" )
        print( "\(blueAmount.text!) BTC sent from \(secondAccount) to \(firstAccount)" )
 chainState()
 blueAmount.text = ""  
 }
 }

First, we check if the text value of redAmount or blueAmount is empty. If it is empty, a prompt box pops up to indicate invalid transaction. If it is not empty, we proceed to the next step. We use the transaction function to transfer money from the first account to the second account (or vice versa) with the amount entered. We print the amount transferred and call the chainState() method. Finally, the text box is cleared.

That's it, the work is done! Please check whether your code is consistent with the picture:

Now run the app and test it out. From the front end, it looks like a normal trading app, but behind the scenes it’s the blockchain! Try using the app to transfer BTC from one account to another, feel free to test it out, and have fun!

in conclusion

In this tutorial, you have learned how to create a blockchain using Swift and created your own Bitcoin transaction system. Please note that the backend of a real cryptocurrency is completely different from our implementation above, because it requires the use of smart contracts to achieve distribution, and this example is only for learning.

In this example, we applied blockchain technology to cryptocurrency. Can you think of other application scenarios for blockchain? Please leave a comment and share with everyone! I hope you can learn something new!

For reference, you can download the complete example from GitHub.