How Blockchain-Based Land Registries can Lift Countries out of Poverty
Securing property rights with a simple DApp
What does home mean to you?
Our homes are our safe space. Our shelter. Where we are loved, cherished, and respected. Where we can be ourselves. Where we are welcomed with open arms.
Home is a feeling of belonging.
But that’s if you’re lucky enough to have one and call it your own.
When we’re asked where our home is, we usually don’t have to think twice. We know where we live, what our addresses are, and 99% of the time, no one will debate us on that. But that isn’t the case for 70% of the world.
The Failed System of Land Registration
Land registration seems like a simple enough task. All you really have to do is maintain a list of records of the different properties, who owns them, and track any transfers of ownership. But what we’ve come to find is that it presents many, many more challenges.
For anyone who’s ever been through the process of buying a home, you’ll know that it’s an extremely lengthy, cumbersome process, filled with far too much back-and-forth, several intermediaries, and a truckload of paperwork. In fact, the entire process, from first finding the home to actually making the payment and transferring ownership, normally takes months.
Fortunately however, at the end of the day, we can peacefully put the case to rest, knowing that the land we bought is now ours. But for individuals in third-world countries, there are still many things they could worry about.
According to the World Bank, despite recognizing the importance of land rights, 70% of the world’s population still lacks access to proper land titling.
For example, in the wake of the 2010 earthquake in Haiti, 60 years of archives held in government buildings were destroyed. Among these archives were land registrations for many small farmers. Without official records of prior ownership, these farmers had no proof, and to this day, they are still fighting over these lands.
But even without disasters such as the Haiti quake, land registry systems in developing countries are still extremely underdeveloped. In fact, in many African countries, over 90% of rural land is unregistered, and in India, the lack of secure land ownership is a greater cause of poverty than an illiteracy rate of 77.7%.
Some land registry systems go as far as to even being corrupt. In Honduras for instance, the country’s database was hacked and tampered with, allowing government officials to steal properties by placing them under their own name.
Because property acts as a major store of wealth and assets, without functional land tenure systems, economies lack the foundation for sustainable growth. From the words of Hernando de Soto, the Peruvian economist and politician known for his work on the informal economy:
Because the rights to possessions are not adequately documented, assets cannot readily be turned into capital, cannot be traded outside of narrow, local circles where people know and trust each other, cannot be used as collateral for a loan, and cannot be used as a share against an investment.
The value of these locked-up properties, as well as the lost economic opportunities for their supposed owners, is estimated to be $20 trillion USD worldwide. Without an official, legal title to their property, people are left unable to claim what should be rightfully theirs.
Bringing Land Registries to the Blockchain
One potential solution to the many different problems concerning land registration is blockchain technology. Put simply, blockchain is an immutable, digital ledger that allows data to be stored and shared globally across thousands of computers in the network.
There are two key features of blockchain that allow it to address the issue at hand:
- Immutability
- Decentralization
Immutability
The data stored on a blockchain is immutable, meaning it cannot be changed or altered. Once information is added, it is timestamped and stays there forever. If someone were to try and alter the information, it would invalidate all data added afterwards, making it clearly visible to everyone in the network that there is malicious intent at play. With that being said, if something has to be changed, the only way to do so would be to add the new piece of information on top of the old one, keeping a complete history of all data.
When used with land registration, this allows blockchain to be a permanent, traceable, and undisputable record of property ownership. No one can tamper with the information or make unagreed upon changes in regards to the ownership of a property.
Decentralization
Blockchain is a decentralized database, meaning that there is no central authority governing the network. Rather, each computer in the network stores its own copy of the data, and they all work together to maintain its security.
The problem with a centralized network is that it has a single point of failure. Just like with the archives in Haiti, because the documents were all stored on paper and in that one location, the system was vulnerable to disaster. With blockchain however, it would require multiple points of failure to make the system vulnerable — 51% of the network to be exact. Because a copy of the ledger is stored on each node, rewriting the truth would be much more difficult. In terms of land registration, this not only protects the documents against disasters, but also against corruption.
I built a simple decentralized application (DApp) on Ethereum that allows for viewing, registering, and transferring lands, securing property rights and decentralizing land registration. Check it out below!
How I Made It
The backend of the DApp is controlled by a smart contract written in Solidity with the Remix IDE. A smart contract is a self-executing computer program that runs on the blockchain, following the terms of the agreement that are coded into it.
To perform certain actions, we’ll have to pay gas — fees in Ethereum. This includes deploying the contract, registering properties, and transferring properties. No fees are required for viewing the lands.
The frontend was created with HTML, CSS, and JavaScript, connecting it to the smart contract through the contract address and ABI in a configuration JavaScript file.
Toolkit for this Project
- MetaMask → A browser extension crypto wallet to manage your digital assets and make payments.
- Remix IDE → A browser-based compiler and IDE that allows users to build and deploy Ethereum smart contracts with Solidity.
- Kovan Faucet → You can get one free test Ether every 24 hours to make transactions when testing your contract.
- Kovan Ethereum Test Network → Testnets in Ethereum are networks used to test your contract code before deploying it to the mainnet. This is essential, since you cannot edit your smart contract after doing so.
- Injected Web3 environment → A Web3 instance is injected by MetaMask to initialize the application.
- Visual Studio Code → A free source-code editor, used to create the frontend application.
Smart Contract Code
To begin, we’ll have to specify our compiler version and create the contract.
pragma solidity ^0.4.0;contract MyLandContract
{
We then create our land struct, in which we define the attributes that each listed land will contain.
struct Land //creates land object
{
address ownerAddress; //stores owner address
string location; //physical location of land
uint cost; //cost of land
uint landID; //each land is uniquely identifiable
}Next, we create the constructor, a function that is executed only once upon the creation of the contract. We also define our state variables and initialize them inside the constructor.
address public owner; //address of whoever deployed the contractuint public totalLandsCounter; //total no of lands at any time
constructor() public
{
owner = msg.sender;
totalLandsCounter = 0;
}
We create two different event types: one to register a land, and another to transfer ownership of a land.
//land registration event
event Register(address _owner, uint _landID);
//land transfer event
event Transfer(address indexed _from, address indexed _to, uint _landID);Next, we have a function modifier, which is used to modify the behaviour of a function in Solidity. This is typically used to set a prerequisite to the function. In our case, we want to ensure that only the contract owner is able to use certain functions.
modifier isOwner //check if function caller is owner of contract
{
require(msg.sender == owner);
_;
}We then create a mapping of each address to an array of land structs, since one account can own multiple different properties.
mapping (address => Land[]) public __ownedLands;Our first function is to register a land. Using the function modifier, we check to make sure that the individual trying to do so is the contract owner. We then increase our total lands counter by one to account for this new land, and create the land object using parameters passed through the function. Finally, we add this to the array of lands mapped to the address of the contract owner, and notify the network by calling the event we created earlier.
//owner adds lands with this function
function registerLand(string _location, uint _cost) public isOwner
{
totalLandsCounter++; //increment total lands counter
Land memory myLand = Land(
{
ownerAddress: msg.sender,
location: _location,
cost: _cost,
landID: totalLandsCounter //nth land added
});
__ownedLands[msg.sender].push(myLand);
emit Register(msg.sender, totalLandsCounter); //notify world
}Our second function is to transfer a land. Before that can take place however, we need to check if the individual actually owns the land that they wish to sell. If all is well, we proceed with creating a copy of that land, keeping the same information for all aspects except the address, since we swap that out for the buyer’s address. This land object is then added to the buyer’s collection and removed from the owner’s collection.
Note that because blockchain is immutable, it is impossible to delete objects, which is why for the buyer, we must copy the land information over, and for the seller, the value of that element in the array where the land used to be will simply return all zero’s.
function transferLand(address _landBuyer, uint _landID) public returns (bool)
{
//find out the particular land ID in owner's collection
for(uint i=0; i < __ownedLands[msg.sender].length; i++)
{
//if given land ID is indeed in owner's collection
if (__ownedLands[msg.sender][i].landID == _landID)
{
//copy land in new owner's collection
Land memory myLand = Land(
{
ownerAddress:_landBuyer,
location: __ownedLands[msg.sender][i].location,
cost: __ownedLands[msg.sender][i].cost,
landID: _landID
});
__ownedLands[_landBuyer].push(myLand);
//remove land from current ownerAddress - assigns everything a value of 0
delete __ownedLands[msg.sender][i];//inform the network
emit Transfer(msg.sender, _landBuyer, _landID);
return true;
}
}
//if true was never returned, the land is not in the owner's collection, so the function returns false
return false;
}
We then have a function to display the properties of a land.
//get land details of an account to display to front end
function getLand(address _landHolder, uint _index) public view returns (string, uint, address, uint)
{
return (__ownedLands[_landHolder][_index].location,
__ownedLands[_landHolder][_index].cost,
__ownedLands[_landHolder][_index].ownerAddress,
__ownedLands[_landHolder][_index].landID);
}Lastly, we have a function to display the total number of lands owned by an account.
function getNoOfLands(address _landHolder) public view returns(uint)
{
return __ownedLands[_landHolder].length;
}A Future of Shared Prosperity
Despite everything a blockchain-based land registry system is capable of accomplishing, there are still many obstacles developing nations may face on the road to securing land ownership. Governments may reject a system that reduces their own power, and blockchain can’t fix situations where documents have already been lost.
But we can still remain hopeful. In some countries such as Ghana and Ukraine, government and nonprofit organizations are already starting to make this a reality. Even at its simplest level, having a system like this in place would streamline the traditional process, reducing delays, fraud, and human error. By helping to secure property rights through blockchain, we redistribute power back to its owner, taking us one step closer to equitable and resilient communities.
If you enjoyed reading this article or learned something new, be sure to drop a follow on Medium and connect with me on LinkedIn! Also, if you’d like to keep up with the projects I’m working on, feel free to subscribe to my monthly newsletter. Thanks for reading!
