Our platform makes it simple to quickly stand up blockchain applications across industries, and some of our most successful projects have been in the insurance and healthcare space.
The ability to build collaborative business networks, tokenize claims, then automate payments on receipt of a claim has the potential to bring enormous efficiency to an expensive, paper-intensive process.
In this tutorial, we’ll look at how you can use the Kaleido platform’s FireFly Sandbox to set up a basic insurance claim application.
By the end of this article you’ll have:
This process will show how data can be transferred off and on the blockchain and demonstrate the ways Kaleido makes it easy to track and trace information.
If you haven’t already, sign up for a Kaleido account here. Create an account and password and you will be all set. Everything in this tutorial can be done on the starter tier, which is free!
To get started, use the Create a Network button. This will prompt you to select your home region. Next you will set up your environment. For this tutorial, we will be using the FireFly Private Network Sandbox.
Next you will choose your protocol. For this example, choose Ethereum. Next you can deploy via cloud and select Besu as your provider and PoA as your consensus algorithm. For a more detailed look at protocols, consensus mechanisms, and other features, check out our blog on how to build a blockchain.
In this tutorial, you will need to create two memberships, two FireFly nodes, two Blockchain Nodes, and two IPFS nodes. You can name these whatever you want however we will be referring to them with the following names.
Memberships (2): Insurance Company A, Insurance Company B
FireFly Nodes (2): FF_A_Insurance, FF_B_Insurance
Blockchain Nodes (2): Node_A, Node_B
IPFS (2): IPFS_A, IPFS_B
You will work through a screen like the one above for both your Insurance Company A and Insurance Company B memberships.
Once your network loads, which may take a couple minutes, you will be brought to a dashboard that looks like this.
Click the “Initialize” button which will begin the process for setting up your FireFly node and network. Check out the FireFly docs to get a more in-depth understanding on what FireFly does. A namespace is an isolated environment within a FireFly runtime. In this case, we will want to build a multi-party namespace for our two FireFly nodes that will give the two organizations the ability to establish on-chain and off-chain communication. Give your Namespace a name such as “Insurance_Namespace” and click “Initialize”. Then in the next screen reuse the Node and Organization (membership) names you created above and click “Register”.
Your Namespace should now be created and you may find this under “Namespaces” for your FF_A_Insurance FireFly node in the left nav. Repeat this process for the FF_B_Insurance FireFly node and make sure that the Namespace is also designated as “Insurance_Namespace”.
After completing the steps above, verify that both FireFly nodes are correctly registered to the Namespace. You can do so by clicking “Open Web UI” for the FireFly Explorer. You can find this by going to either of your FireFly nodes and selecting “Dashboard” in the left nav. If both nodes are registered correctly you will see something like the screenshot below where the Network Map shows both Insurance_Company_A and Insurance_Company_B.
Click on Digital Assets > Tokens to create your ERC721 contract. You can choose the signing account and utilize the Token Factory. For template type, select KaleidoERC721MintableBurnable and follow the instructions.
Click “Deploy Token Instance” to deploy the smart contract to the chain. Now head over to Digital Assets > Tokens and you will see your deployed token. What we have just done is use the ERC721 contract template that was preloaded to create your own NFT contract. You may deploy as many NFT contracts as you want, however, for this demo we will only be using one.
Now that we have deployed an ERC721 contract, the next step is to mint a NFT of the Claim to Insurance Company A so that they can send it to Insurance Company B. First we’ll have to teach FireFly about your NFT. Copy the address of your contract from the screen below and then head to the FireFly Sandbox. To do so, go to FireFly > FF_A_Insurance > Dashboard and click “Open Web UI” for FireFly Sandbox.
Navigate to the “Tokens” tab of the Sandbox and click into the Create a Token Pool box. Create a token pool by entering the Name & Symbol of the NFT you just created. Make sure Type is “Non-Fungible” and for the contract address paste the address that you copied in the previous step and click “run”. Once the operation is done, FireFly can now interact with your contract. You’ll see that balances for your token now appear as FireFly is now indexing your smart contract.
Head back to the Kaleido console and go to Blockchain > IPFS > IPFS_A and click “Open Web UI”.
Click the “Files” tab and upload a Claims Form. For this tutorial we found an example claim off Google.
Take note of the URL of the file and copy it. Then go to your favorite text editor and input the following, replacing the IPFS url with what you just copied. Save the file as “claim.json”. This will be the metadata of your NFT. You can have any fields you want but we will use name, description, and image for now.
{
"name": "User 1 Claim",
"description": "Example of a Claim",
"image": "https://u0ft4pca4s-u0kk2wcils-ipfs.us0-aws.kaleido.io/ipfs/Qmbo8PfVs4WWanjFPMboP8Gx5hunN1Tn5kLMmhvB3L1LVd/#/files/preview/Claim%20Form.png",
}
Now take note of the url path for your new JSON path. You will use this to input into the URI of your NFT. The URI is a reference that points to a resource. In this instance the resource is a JSON file but it could be any other form of data. The URI refers to the metadata or attributes associated with a specific token.
Head back to the Kaleido console and click on Digital Assets > Tokens and select your Claims token. Then select a signing account, give your token an ID, and click MINT. The token index keeps track of NFTs minted by the contract. Since NFTs are non-fungible, each NFT must have a unique index (i.e. no other token created can have an index of “1”).
You have now minted a NFT. Go to your FireFly Explorer UI and you will see your token transfer.
Click on Transfer Tokens in the Sandbox and attach a message to let Insurance Company B know that the claim has been sent.
The message could be a simple text saying “sent” or you could attach files such as proof of claim or any other details. The message or file that you attach will be stored off-chain into IPFS.
If it is public the message will be viewable by all parties in your FireFLy network. If it is a private message only parties privy to the message will see the content. Other parties will see a hash of the message signifying that something has happened on the blockchain but not necessarily what.
Make sure to enter a token index of 1 (matching your minted NFT), select the correct recipient, and enter a Tag and Topic if you wish. The Tag and Topic are constructs that allow FireFly to better index and organize your messages and events.
Messaging is a powerful tool in FireFly as messages themselves are entirely off-chain. What this does is protect sensitive information by keeping it off-chain but having an on-chain proof that it has occurred. In this case, the NFT that is minted will forever be on-chain and tied to a hash. From those looking at on-chain transactions, this hash is indecipherable but those who have received the message off-chain would be able to see that the Claim is tied to the NFT.
Messages in FireFly are encrypted with 2 layers of encryption and what we’re essentially doing is using messages, encryption, and events to exchange information but using blockchain as the state machine or safekeeper or source of truth. Check out this article for an overview on deciding what goes on-chain vs. off-chain and tradeoffs in the decision.
In the FireFly UI click on Off-Chain > Messages and you will see the message you sent above from Insurance Company A to Insurance Company B.
Head to Blockchain > Events and you will see everything that has happened on chain. In this case this would include a token transfer (minting and transfer of a NFT) as well as BatchPins of off chain messages.
The tutorial we just went through is a very simplified example of an insurance claims use case. In the real world, Insurance Company B would likely need to send some payment for the claim. But this example serves as a model for how Kaleido can help in delivery vs. payment (DvP) scenarios. Essentially, using this process, two parties could send assets to an escrow contract and utilizing various messaging, subscriptions, and event-listening operations, the application will facilitate a secure transaction between the two parties.
If an insurance claim app or another use case for DvP is your goal, schedule a demo with one of our blockchain specialists and we can help you get started.
Start testing your blockchain use case by simulating a multi-party system for free.
Try it FreeStart testing your blockchain use case by simulating a multi-party system for free.
Try it Free
Start testing your blockchain use case by simulating a multi-party system for free.
Try it FreeStart testing your blockchain use case by simulating a multi-party system for free.
Try it Free
Your guide to everything from asset tokenization to zero knowledge proofs
Download Now
Learn how Swift, the world’s leading provider of secure financial messaging services, utilizes Kaleido in its CBDC Sandbox project.
Download Now
