What is TuumIO Protocol?

TuumIO.Protocol is a secure and decentralized platform that empowers individuals to take control of their data using blockchain technology. It is designed to reduce reliance on centralized IT systems and provides a foundation for Web3 development.

Key Components

Chains: Enterprise-level solutions that offer a wide range of products and services categorized by various industries, such as healthcare, finance, gaming, and more.

dApp: A decentralized application in Web3 that offers various functionalities, including interactions, data exchanges, and workflows for specific user roles.

TuumIO Wallet: A mobile application that allows users to store and manage digital assets, and serves as a gateway to chains and dApps.

Use Case Examples

Remote patient monitoring

Facilitates treatment adjustments and supports patients in managing their conditions remotely, without direct intervention from care providers.

Insurance claims processing

Manages the submission and processing of insurance claims. Patients can submit claims for reimbursement plans, such as vision or dental insurance, ensuring faster and more transparent processing.

Employee rewards system

Addresses burnout and high turnover among employees by implementing a rewards system. This can include gift cards, paid time offs, discount vouchers, wellness programs, and more.

input.json

The input.json file is a hierarchical structure of objects defined within a network. It contains information about the network, roles, journeys, cards, events, event handlers, and TuumIO ledgers.

TuumIO Data Node

The TuumIO Data Node (TDN) serves as the network's central database for storing and processing data files. It facilitates data exchange with external client systems, including electronic medical records, claims systems, member systems, and payment systems.

TuumIO Card definitions

A TuumIO Card is an interactive module encapsulating multiple data types, user interface elements, and interoperable functions. The TuumIO Card definition structure includes card data, layout, card footer, and UI actions.

Event definitions

Events define the interactions and communication between roles or nodes in the network, such as sending and receiving information. Events are chained together in a time series on a blockchain, creating a secure, transparent, and immutable record of transactions within the network.

Event handlers

An event handler is a set of instructions that execute tasks based on specific events. These tasks include updating records, transforming data, and identifying recipients for the next event.

Python event handlers

Python event handlers are designed to execute complex events and transactions that require data processing, analysis, import, and export. They can fetch external data in HL7, X12 EDI, XML, JSON, or CSV formats.

Resources

Resources contain predefined data that is inserted or updated automatically during initialization.

Transactional data

Transactional data consists of configurable data that can be referenced from roles, cards, or events within the network.

Deployment readiness checklist

Before testing and publishing the network, make sure that:

• All files and data are correctly referenced in the input.json file.

• There are no logical errors in the referenced data.

• The /definitions folder and input.json file are packaged into one zip file.

• The DDF and CSV files are ready for upload.

• You have the test environment details where you want to publish the protocol. For more information, see Publishing the protocol.

TuumIO Wallet Your all-in-one companion for managing health, finance, and beyond. TuumIO Wallet connects you to a wide range of app networks, including the powerful Care.Trials, giving you complete control over the healthcare services you choose to use.

Powered by blockchain technology, TuumIO Wallet ensures your data remains secure and private. With no ads and total privacy protection, your information is never accessed, aggregated, brokered, or sold without your consent. Only you can see what's in your TuumIO Wallet—not even TuumIO has access.

Care.Trials Join groundbreaking clinical trials with TuumIO Wallet. Care.Trials connects you to the latest medical research studies, seeking participants for conditions like cancer, diabetes, mental health, and more. Find local wellness and prevention studies, and take part in the journey toward better medicine.

Buy SOLVE Easily purchase SOLVE tokens directly in your TuumIO Wallet using traditional payment methods. Choose the amount you want in SOLVE or USD.

Track Your SOLVE Keep an eye on your SOLVE activity with the SOLVE Transaction Statement, tracking all your interactions within the app network.

TuumIO Protocol defines the rules governing information communication and data exchange. It employs an event-driven architecture and utilizes JSON files to represent configurations for roles, relationships, journeys, events, and interactions. By using standard data structures, it reduces complexity and enables interoperability between systems.

In this guide, you'll learn how to manually author TuumIO Protocol using provided examples.

Structure of files and folders

Prerequisites

Before you begin, ensure you have the following:

• An Integrated Development Environment (IDE) or a text editor to manually author files.

• The required Python packages to configure and run Python event handlers.

• Postman API platform and the network environment details for publishing.

• BrowserStack, a cloud web and mobile testing platform, for testing the application.

Transactional data contains configurable data that can be referenced from roles, cards, or events within the network. The following example shows the definition of transactional data in td/td-default.json.

{
    "id": "td-default",
    "path": "td/td-default.json",
    "definition": {
        "collection": "DEFAULT",
        "description": "DEFAULT",
        "name": "DEFAULT",
        "resource": "DEFAULT",
        "status": "RELEASED",
        "type": "TRANSACTIONAL_DATA"
    },
    "structure": {
        "attributes": [
            {
                "code": "transactionalGuid",
                "name": "transactionalGuid",
                "type_definition": {
                    "type": "string"
                },
                "order": 1,
                "required": false,
                "system": false
            },
            {
                "code": "createdAt",
                "name": "createdAt",
                "type_definition": {
                    "type": "timestamp"
                },
                "order": 2,
                "required": false,
                "system": false
            },
            {
                "code": "answer",
                "name": "answer",
                "type_definition": {
                    "type": "string"
                },
                "order": 3,
                "required": false,
                "system": false
            },
            {
                "name": "senderNodeAddress",
                "code": "senderNodeAddress",
                "type_definition": {
                    "type": "string"
                },
                "required": false,
                "system": false,
                "order": 4
            }
        ]
    }
}

Overview

Welcome to the Library Explorer example, an app designed for exploring educational materials in a digital library. The underlying structure can be adapted for Web3 integration, allowing you to extend the app's functionality such as minting non-fungible tokens (NFTs) for digital content like e-books.

Here's how the app works:

1. Launch the app.

2. Fill in the details of the material that match your interest (title, author, subject).

3. Browse the catalog of recommended materials.

Steps

Our support team is here for you! Reach out at [email protected].

Join the conversation:

• Telegram

• Discord

Understand the structure of the input.json file

• Open the input.json file in a text editor.

• Save and validate the input.json file.

Define the data structure

Create the definitions for cards

Create events and event handler definitions

Configure Python event handlers

Reviewing ID and medical records

1. Sign in to the TuumIO Wallet app.

5. Approve or reject the records.

Viewing history of reviewed records

1. Sign in to the TuumIO Wallet app.

2. From the Manage Networks screen, tap Care.Trials.

Reviewing lead eligibility

1. Sign in to the TuumIO Wallet app.

2. From the Manage Networks screen, tap Care.Trials.

4. Select the lead you want to review.

5. • View the details of the trial

   • Ask a question to the lead

6. Approve or reject the lead.

Viewing lead verification details

1. Sign in to the TuumIO Wallet app.

2. From the Manage Networks screen, tap Care.Trials.

Application Layer

The Application Layer handles configuration, administration, and communication within networks, allowing users to interact with decentralized applications (dApps).

• TuumIO Wallet: A mobile app that allows users to store and manage digital assets and serves as a gateway to various industry services and dApps.

• Journeys: A sequence of interconnected cards outlining specific workflows for roles such as participants, administrators, managers and employees.

• TuumIO Card: An interactive module that combines text, images, buttons, and interoperable functions on the app's user interface.

• TuumIO Network: A digital network of various healthcare roles, operating based on the rules defined in the TuumIO Protocol.

• TuumIO Protocol: A governance framework that defines the rules for data exchange and communication, facilitating secure transactions and interactions within the network.

Data Layer

The Data Layer provides secure, transparent, decentralized data storage and records management.

• MainNet: Holds the core registry service that maps TuumIO Wallet users to their respective TuumIO Networks, such as the country matrix for region-based services.

• Event Ledger: A decentralized, immutable record of event logs from sender and recipient node addresses, including payload data.

• TuumIO Data Node (CDN): A specialized node created for each network. It manages data storage, processing, and exchanges with external systems.

Compute Layer

The Compute Layer manages core operations and node management, ensuring secure data and event transmission across the network.

• TuumIO Node: An entity that manages data storage and event handling across the network. It is a secure, versatile object deployable in any environment.

• Network Onboarding Manager (NOM): Facilitates the initial creation and assignments of TuumIO Nodes upon joining the network.

• Node Lifecycle Manager (NLM): Manages the creation and lifecycle states of TuumIO Nodes, including active, start, stop, and hibernate states.

• Base Node Services (BNS): Ensures secure transmission of events and data through the blockchain.

Buying SOLVE

1. Sign in to the TuumIO Wallet app.

4. Enter the amount in USD.

5. The equivalent amount in SOLVE is calculated automatically.

7. Tap Buy.

Depositing SOLVE

1. Sign in to the TuumIO Wallet app.

2. From the bottom navigation bar, tap FUNDS.

Transferring SOLVE

1. Sign in to the TuumIO Wallet app.

2. From the bottom navigation bar, tap FUNDS.

4. Enter the amount in SOLVE.

6. Tap Transfer.

8. Tap Confirm.

Paying bills

1. Sign in to the TuumIO Wallet app.

2. From the bottom navigation bar, tap FUNDS.

4. Select the bill you want to pay.

5. Send your payment.

Viewing transactions history

1. Sign in to the TuumIO Wallet app.

2. From the bottom navigation bar, tap FUNDS.

The Profile screen allows users to view the details they have saved in the application. The following information is displayed:

1. Wallet ID

2. Nickname

3. Country

4. Verification method

5. Financial information

The information is clearly labeled so users understand which details are public, private, or shared only with us. Users can update their nickname and financial information; however, other details cannot be changed.

Users can also view detailed descriptions of each field and learn how their data is being securely stored.

Additionally, users have the option to delete their wallet account if they no longer wish to use the service.

Getting started

Participate in clinical trials to help discover new treatments and contribute to medical advancements. Join Care.Trials and search for clinical trials near you.

Types of roles in Care.Trials

• Participants — When you join Care.Trials as a participant, you will have access to available trials that match your profile. Use swiping to like or skip matched trials.

• Physician — The physician, also known as principal investigator, helps connect patients to relevant clinical trials. In Care.Trials, the physician can browse trials, refer patients and search for trial sponsors.

• Site Admin — The site admin helps coordinate clinical trials in a specific site location. In Care.Trials, the site admin can view leads and interact with the participants.

• Trial Admin — The trial admin oversees the clinical trials in all sites. In Care.Trials, the trial admin can activate trials and set the budget for a trial site.

• Nurse — The nurse in Care.Trials can review medical records and verify the eligibility of participants.

Joining the Care.Trials network

1. Sign in to the TuumIO Wallet app.

4. Please review the terms and conditions.

5. Tap the join button.

6. Wait up to 5 minutes to connect your TuumIO Wallet to the network.

2. Sign in to your account.

3. From the homepage, navigate to App Live.

4. Upload the app.

5. Select the operating system and device model.

6. Wait for the app to load on the device, then start testing. Note: To view event payload and analyze data flow, select the Network tab > Enable for all traffic, and then save the configuration.

Caira is an AI Patient AIdvocate here to provide you with a "wow" experience on Care.Trials. Caira is focused on helping you understand clinical trials and the benefits they offer. Whether it's discovering new opportunities for improving your health or meeting people from different walks of life, Caira is here to assist you with all the information you need about becoming a part of Care.Trials. If you have any questions, feel free to ask!

Using Caira Assistant

1. Sign in to the TuumIO Wallet app.

4. Share your query to Caira.

How TuumIO Data Node works?

The TuumIO Data Node (TDN) is responsible for storing and exchanging data files within the TuumIO Network. It can convert external data files into events, and events into external data files. When receiving data files, the TuumIO Data Node extracts and transforms the data, and then creates events. Event handlers can be created in TuumIO Protocol to manage the events generated by the TuumIO Data Node.

Data definition file

The data definition file (DDF) defines the model and structure for organizing data in the TDN. This file is used in TDN to process incoming data files and generate events for distribution to TuumIO Nodes. The DDF and raw CSV files are uploaded to the environment repository for processing. For more information, see Updating TDN.

The following example shows data definition in ddf/us-doctors-sample.json.

{
    "ddf_type": "us-doctors-sample",
    "meta_data": {
        "description": "Sample"
    },
    "messages": [
        {
            "message_category": "CSV",
            "message_type": "Doctors",
            "meta_data": {
                "description": "Sample",
                "indices": "us-doctors-sample"
            },
            "events": [
                {
                    "to_role": "rl-patient",
                    "event": "ev-cdn-broadcast"
                }
            ],
            "attributes": [
                {
                    "name": "Provider",
                    "description": "Provider",
                    "required": false,
                    "index_field": true,
                    "type": "integer",
                    "data_location": "Provider"
                },
                {
                    "name": "License",
                    "description": "License",
                    "required": false,
                    "index_field": true,
                    "type": "string",
                    "data_location": "License"
                },
                {
                    "name": "Specialization",
                    "description": "Specialization",
                    "required": false,
                    "index_field": true,
                    "type": "string",
                    "data_location": "Specialization"
                },
                {
                    "name": "Address",
                    "description": "Address",
                    "required": false,
                    "index_field": true,
                    "type": "string",
                    "data_location": "Address"
                }
            ]
        }
    ]
}

Signing up to TuumIO Wallet

1. Open the TuumIO Wallet app from your mobile device.

4. • Choose 'Continue with Facebook' to sign up using your Facebook account.

7. Allow the app to use biometrics for added security when accessing your account.

8. Use fingerprint scan or facial recognition.

9. Wait a few seconds for your account to be created.

Signing up to TuumIO Wallet using Apple ID on iOS device

1. Open the TuumIO Wallet app from your mobile device.

2. Tap Create a new TuumIO Wallet.

3. Allow the app to access your device's location.

5. Authorise the app to create account using your Apple ID.

6. Set up a 6-digit Wallet PIN, and then proceed.

7. Wait a few seconds for your account to be created.

Signing in to TuumIO Wallet

1. Open the TuumIO Wallet app from your mobile device.

4. If biometrics is enabled, use fingerprint scan or facial recognition.

5. Wait a few seconds for the home screen to load.

Resetting your passcode

1. Open your TuumIO Wallet app.

Saving your recovery phrase

1. Sign in to your TuumIO Wallet app.

4. Enter your Wallet PIN, then tap Next.

Recovering the access

1. Open the TuumIO Wallet app from your mobile device.

2. Tap 'I already have a TuumIO Wallet'.

5. Allow the app to use biometrics for added security when accessing your account.

6. Use fingerprint scan or facial recognition.

7. Wait a few seconds for the home screen to load.

Getting matched for clinical trials

1. Sign in to the TuumIO Wallet app.

2. From the Manage Networks screen, tap Care.Trials.

5. Tap Start to proceed**.**

8. Tap Submit.

9. Wait up to 5 minutes to search for available trials near you.

Swiping matched trials

1. Sign in to the TuumIO Wallet app.

2. From the Manage Networks screen, tap Care.Trials.

5. Like the trial you want to participate in. You can also skip or go back to the previous trial.

Uploading your medical records and ID

1. Sign in to the TuumIO Wallet app.

2. From the Manage Networks screen, tap Care.Trials.

6. Select a file from your device or take a photo.

7. Tap Upload.

Submitting records for review or verification

1. Sign in to the TuumIO Wallet app.

2. From the Manage Networks screen, tap Care.Trials.

3. Tap Records Review and ID Verification.

7. Confirm your payment.

Viewing records history

1. Sign in to the TuumIO Wallet app.

2. From the Manage Networks screen, tap Care.Trials.

3. Tap Records Review and ID Verification.

Managing liked trials

1. Sign in to the TuumIO Wallet app.

2. From the Manage Networks screen, tap Care.Trials.

4. • Matched — View the clinical trials you liked that the site admin has responded to.

   • No response — View the clinical trials you liked that the site admin has not yet responded to.

   • Not a fit — View trials you liked but don't match your profile.

TuumIO Ledger specifications

A TuumIO ledger is used to store and manage data related to events or transactions within the network. If necessary, include details about tuumIO_ledgers and tuumIO_ledger_tags in your protocol.

Use tags to categorize data within TuumIO ledgers, such as Appointments, Prescriptions, Results, and others.

Declare the attributes and values for the TuumIO ledgers.

Activating a trial

1. Sign in to the TuumIO Wallet app.

2. From the Manage Networks screen, tap Care.Trials.

4. Tap Activate Trial.

7. Tap Request code. Wait for the activation code to be sent to your email.

10. Tap Activate.

Updating trial info

1. Sign in to the TuumIO Wallet app.

2. From the Manage Networks screen, tap Care.Trials.

7. Tap Update.

Setting the budget

1. Sign in to the TuumIO Wallet app.

2. From the Manage Networks screen, tap Care.Trials.

4. Select the site you want to update.

9. Tap Submit.

Checking the site statistics

1. Sign in to the TuumIO Wallet app.

2. From the Manage Networks screen, tap Care.Trials.

4. Select the site you want to update.

The Python event handler contains a set of base classes that provide an interface to the platform's core components, such as Vault, Wallet, Node, and TuumIO Data Node (TDN). The following template includes base classes and functions that provide features to retrieve, search, update, and save data.

Python template

class TDN:
    def __init__(self, index: str):
        self.context = context
        self.index = index
    def find_all(self, parameters: SearchRequest) -> List:
        return self.context.getCareDataNodeProvider().findAll(self.index, parameters)
    def find_first(self, parameters: SearchRequest) -> SearchResponse:
        return self.context.getCareDataNodeProvider().findFirst(self.index, parameters)
    def raw_search(self, from_row, num_rows, search_request) -> List:
        return self.context.getCareDataNodeProvider().rawSearch(self.index, from_row, num_rows, search_request)

class Wallet:
    def __init__(self):
        self.context = context
    def get_wallet_profile(self) -> WalletProfile:
        return self.context.getMainNetNodeProvider().getMainNetProfile(ProfileType.WALLET)
    def get_phone_profile(self) -> PhoneProfile:
        return self.context.getMainNetNodeProvider().getMainNetProfile(ProfileType.PHONE)
    def get_contact_profile(self) -> ContactProfile:
        return self.context.getMainNetNodeProvider().getMainNetProfile(ProfileType.CONTACT)
    def update_wallet_profile(self, data: Map, attribute_mapping: Map) -> Map:
        self.context.getMainNetNodeProvider().updateWalletProfile(data, attribute_mapping)
        return data
    def update_phone_profile(self, data: Map, attribute_mapping: Map) -> Map:
        self.context.getMainNetNodeProvider().updatePhoneProfile(data, attribute_mapping)
        return data
    def update_contact_profile(self, data: Map, attribute_mapping: Map) -> Map:
        self.context.getMainNetNodeProvider().updateContactProfile(data, attribute_mapping)
        return data

class Vault:
    def __init__(self):
        self.context = context
    def save(self, collection: str, data: Map) -> Map:
        vault = self.context.getVaultStorage(collection)
        guid = vault.save(data)
        return vault.getByGuid(guid)
    def update(self, collection: str, criteria: List, data: Map, insert_if_absent: bool) -> Map:
        vault = self.context.getVaultStorage(collection)
        guid = vault.update(criteria, data, insert_if_absent)
        return vault.getByGuid(guid)
    def search(self, collection: str, filters: List) -> List:
        vault = self.context.getVaultStorage(collection)
        return vault.search(filters)

class Node:
    def __init__(self, context: HandlerExecutionContext):
        self.context = context

    def info(self) -> NodeInfo:
        return self.context.getNodeInfo()


def execute(ctx: HandlerExecutionContext) -> Map:
    result = HashMap(arguments())
    # PUT YOUR CODE HERE
    return result

Use case example

1. Define the event in the input.json file.

{
    "id": "ev-tdn-broadcast",
    "name": "N.TDN.BROADCAST.MESSAGE",
    "code": "N.TDN.BROADCAST.MESSAGE",
    "description": "TDN broadcast message",
    "status": "Active",
    "type": "NODE_TO_ROLE",
    "from_role": "DATA_NODE",
    "to_role": "PATIENT",
    "event_definition_ref": "event/ev-cdn-broadcast.json",
    "node_event_handlers": [
      "eh-n-patient-process-py"
    ]
  }

1. Create the event definition: event/ev-cdn-broadcast.json.

{
  "definition": {
    "description": "Broadcast TDN message",
    "name": "N_TDN_BROADCAST_MESSAGE",
    "resource": "N_TDN_BROADCAST_MESSAGE",
    "type": "EVENT_DATA"
  },
  "structure": {
    "attributes": [
      {
        "code": "transactionalGuid",
        "name": "transactionalGuid",
        "type_definition": {
          "type": "string"
        },
        "order": 1,
        "system": false
      },
      {
        "code": "indexName",
        "name": "indexName",
        "type_definition": {
          "type": "string"
        },
        "order": 2,
        "system": false
      },
      {
        "code": "ddfType",
        "name": "ddfType",
        "type_definition": {
          "type": "string"
        },
        "order": 3,
        "system": false
      },
      {
        "code": "msgType",
        "name": "msgType",
        "type_definition": {
          "type": "string"
        },
        "order": 4,
        "system": false
      },
      {
        "code": "attributes",
        "name": "attributes",
        "type_definition": {
          "type": "collection",
          "item_type_definition": {
            "type": "string"
          }  
        },
        "order": 5,
        "system": false
      }
    ]
  }
}

1. Define the event handler in the input.json file.

 {
    "id": "eh-n-patient-process-py",
    "name": "N.TDN.BROADCAST.MESSAGE",
    "description": "N.TDN.BROADCAST.MESSAGE",
    "status": "Active",
    "event": "ev-tdn-broadcast",
    "type": "NODE_EVENT_HANDLER",
    "python_event_handler_ref": "python-event-handler/eh-n-patient-process.py"
  }

1. Create a Python event handler definition that saves the data.

def execute(ctx: HandlerExecutionContext) -> Map:
    result = HashMap(arguments())
    # PUT YOUR CODE HERE
    start_row = 0
    num_rows = 10
    query = {
      "match_all": {}
    }
    page = CDN('DOCTORS').search(start_row, num_rows, query)
    Vault('MY_DATA').save(page.getContent())
    return result

Activating a site

1. Sign in to the TuumIO Wallet app.

2. From the Manage Networks screen, tap Care.Trials.

4. Tap Activate Site.

7. Tap Request code. Wait for the activation code to be sent to your email.

10. Tap Activate Site.

Buying leads

1. Sign in to the TuumIO Wallet app.

2. From the Manage Networks screen, tap Care.Trials.

5. Tap Buy the lead you want to buy.

Updating trial info

1. Sign in to the TuumIO Wallet app.

2. From the Manage Networks screen, tap Care.Trials.

7. Tap Update.

Upgrade your plan

1. Sign in to the TuumIO Wallet app.

2. From the Manage Networks screen, tap Care.Trials.

Buying campaigns

1. Sign in to the TuumIO Wallet app.

2. From the Manage Networks screen, tap Care.Trials.

4. In the "Active site" list, select the trial you want to update.

7. Tap Buy Now, then confirm your payment.

Requesting budget

1. Sign in to the TuumIO Wallet app.

2. From the Manage Networks screen, tap Care.Trials.

4. In the "Active site" list, select the trial you want to update.

7. Tap Request.

Checking statistics

1. Sign in to the TuumIO Wallet app.

2. From the Manage Networks screen, tap Care.Trials.

4. In the "Active site" list, select a trial.

Connecting with the lead

1. Sign in to the TuumIO Wallet app.

2. From the Manage Networks screen, tap Care.Trials.

5. • Share trial info — Share the details about the trial with the participant.

   • Participant records & ID — Request records and ID from the participant.

   • Ask a question — Send questions to the participant.

   • Set an appointment — Send an appointment request to the participant containing the trial facility details.

Submitting records to Nurse for review and verification

1. Sign in to the TuumIO Wallet app.

2. From the Manage Networks screen, tap Care.Trials.

4. In Purchased Leads, select the lead you want to connect with.

7. Select the record you want to submit for review or verification.

Cards

A card contains multiple data types, user interface elements, and interactive functions triggered by events.

Card definition structure

• Card data - The information or data displayed within the card, such as texts, images, and links.

• Card layout - The arrangement and organization of elements within the card, including body content style, and footer menus.

• Card footer - The additional options, navigation buttons, or menus at the bottom of the card for user interaction and navigation.

• Card UI actions - The actions triggered by user interactions within the card, such as navigation, form submissions, or data updates.

Card data

Card data can include text, images, links or different types of information relevant to a healthcare journey.

Card layout

Card footer

The card footer includes buttons or actions used to interact with the card itself or navigate to other related cards. These buttons or actions can perform specific tasks like submitting information, saving changes, or going back to previous screens.

Card UI actions

The card UI actions define user interactions within the card's content. These actions trigger functionalities like navigation, data updates, input validation, or external function calls.

Roles

A role is a fundamental element of TuumIO Protocol that represents a specific participant type, such as patients or doctors. Each role is defined with the corresponding cards and events.

Journeys

A journey is a sequence of interconnected cards, defining a specific workflow for a role or network.

Journey definitions

The following example shows the "Get Started" and the "Join as Doctor" journeys.

Journey data model

Here is another example of a "Book Appointment" journey that defines the events, roles, and permissions for synchronizing data across multiple nodes.

Verifying ID and medical license

1. Sign in to the TuumIO Wallet app.

2. From the Manage Networks screen, tap Care.Trials.

5. Tap Submit.

Viewing history of submitted IDs

1. Sign in to the TuumIO Wallet app.

2. From the Manage Networks screen, tap Care.Trials.

Fetch MainNet authorization token

Initiate a request with the appropriate details for your environment.

POST

https://{{abc-care-env}}/core-registry-service/oauth/token?grant_type=password&username=%2B{{networkAuthorPhone}}&password={{networkAuthorPassword}}&blockchainAddress={{networkAuthorWalletId}}

Pre-request script:

pm.globals.set("abc-care-env", "dev.env.abc.net");
pm.globals.set("xxx-env", "site000.abc.net/sample-net");


pm.globals.set("networkAuthorPhone", "91888888888");
pm.globals.set("networkAuthorWalletId", "0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
pm.globals.set("networkAuthorPassword", "999999");
pm.globals.set("networkId", "dev-network-xxx");

Fetch network authorization token

POST

https://{{eks-env}}/nom/oauth/token?grant_type=exchange_token&exchange_token={{networkAuthorMainNetToken}}

Get sponsor address

GET

https://{{eks-env}}/nom/v2/holders/me

Post-request script:

const jsonData = pm.response.json().nodes;
const networkId = pm.globals.get("networkId");
const node = jsonData.filter(r => r.networkId === networkId && r.roleId === 'NETWORK_SPONSOR')[0];
pm.globals.set("sponsorWalletAddress", node.scAddress);

Upload the protocol package

POST

https://{{eks-env}}/generic-protocol-service/v2/packaging/{{networkId}}/restore/zip

Publish the protocol package

POST

https://{{eks-env}}/generic-protocol-service/v2/packaging/{{networkId}}/publish

curl --location --globoff 'https://{{eks-env}}/generic-protocol-service/v2/packaging/{{networkId}}/publish' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer {{networkAuthorCANToken}}' \
--data '{
    "certificates":"CERT-12345-2022",
    "effectiveDate": "20-05-2022",
    "sponsorWalletAddress": "{{sponsorWalletAddress}}"
    
    

}'

Get publishing state

GET

https://{{eks-env}}/generic-protocol-service/v2/packaging/{{networkId}}/{{networkVersion}}

curl --location --globoff 'https://{{eks-env}}/generic-protocol-service/v2/packaging/{{networkId}}/{{networkVersion}}' \
--header 'Authorization: Bearer {{networkAuthorCANToken}}'

Update TDN

Upload the CSV file with the same attributes as the uploaded DDF in the input folder of the Amazon S3 bucket. If necessary, delete existing data.

Uploading data definition file (DDF)

The data definition file contains the model and structure for organizing data in TDN.

POST

https://{{eks-env}}/{{network-id}}/data-node/v1/ddf

curl --location 'https://data-node/v1/ddf?status=ACTIVE' \
--header 'Authorization: Basic Y2FyZS1iYWNrZW5kOnNlY3JldA==' \
--header 'Content-Type: application/json' \
--data '{
    "ddf_type": "us-doctors-sample",
    "meta_data": {
        "description": "Sample"
    },
    "messages": [
        {
            "message_category": "CSV",
            "message_type": "Doctors",
            "meta_data": {
                "description": "Sample",
                "indices": "us-doctors-sample"
            },
            "events": [
                {
                    "to_role": "rl-patient",
                    "event": "ev-cdn-broadcast"
                }
            ],
            "attributes": [
                {
                    "name": "Provider",
                    "description": "Provider",
                    "required": false,
                    "index_field": true,
                    "type": "integer",
                    "data_location": "Provider"
                },
                {
                    "name": "License",
                    "description": "License",
                    "required": false,
                    "index_field": true,
                    "type": "string",
                    "data_location": "License"
                },
                {
                    "name": "Specialization",
                    "description": "Specialization",
                    "required": false,
                    "index_field": true,
                    "type": "string",
                    "data_location": "Specialization"
                },
                {
                    "name": "Address",
                    "description": "Address",
                    "required": false,
                    "index_field": true,
                    "type": "string",
                    "data_location": "Address"
                }
            ]
        }
    ]
}'

Searching data

POST

https://{{eks-env}}/{{network-id}}/elasticsearch/us-doctors-sample/_search

curl --location 'https://elasticsearch/us-doctors-sample/_search' \
--header 'Content-Type: application/json' \
--header 'Authorization: Basic ZWxhc3RpYzpweFkwMXNQTXMyZTRTdFp3M2U1MjU5N3U=' \
--data '{

"query": {

"match_all": {}

}

}'

Deleting existing data from TDN

POST

https://{{eks-env}}/{{network-id}}/elasticsearch/us-doctors-sample/_delete_by_query

curl --location 'https://{{eks-env}}/{{network-id}}/elasticsearch/us-doctors-sample/_delete_by_query' \
--header 'Content-Type: application/json' \
--header 'Authorization: Basic ZWxhc3RpYzpweFkwMXNQTXMyZTRTdFp3M2U1MjU5N3U=' \
--data '{

"query": {

"match_all": {}

}

}'

Checking the count

POST

https://{{eks-env}}/{{network-id}}/elasticsearch/us-doctors-sample/_count

curl --location --globoff 'https://{{eks-env}}/{{network-id}}/elasticsearch/us-doctors-sample/_count' \
--header 'Content-Type: application/json' \
--header 'Authorization: Basic ZWxhc3RpYzo5UlBJMTMzNFNydHBOMzI1NFNRcjd4clI=' \
--data '{

"query": {

"match_all": {}

}

}'

Types of node event handlers

• VAULT_INSERT — This event handler is used to insert a record into a specific collection in the vault.

• VAULT_UPDATE — This event handler is used to update a record in a specific collection in the vault based on the dynamic search criteria.

• MAPPER — This event handler is used for data transformation, such as excluding, appending, or generating data in the execution chain.

• NEXT_EVENT_RECIPIENT — This event handler is used to identify the recipient for the next event.

• EXPRESSION_LANGUAGE — This event handler allows writing data manipulation expressions to easily access, filter, and calculate values.

• CUSTOM — This event handler is used to specify a specific Java class that implements a legacy JAR (Java Archive) handler.

Handler definition constants

Handler data source (GenericHandlerDataSource)

• EMPTY— An empty source or collection.

• EVENT_PAYLOAD — The payload source of events processed in the handlers chain.

• HANDLER_ARGUMENTS — The response value from the previous handler in the chain.

• PERSISTED_ENTITY — For vault-related handlers, it is the state of inserted or updated documents in a collection.

Dynamic handler value (DynamicHandlerValue)

It uses "source" and "value" fields to link data. The actual value can be determined dynamically based on the information in the "source" field. Here are the possible values:

Handler definition examples

Vault Insert handler

Vault Update handler

Data Transformation handler

Next Event Recipient handler

Expression Language handler

Here are the operators supported in the language:

Here are the parameters in the event handler definition:

In Example 1, let's assume that the HANDLER_ARGUMENTS has variables a and b. If the variables represent numeric values, such as a=1 and b=2, then the result will be 1+2=3. If the variables represent string values, such as a='1' and b='2', then the result will be '1'+'2'='12'.

In Example 2, let's assume that the HANDLER_ARGUMENTS has a variable user, which represent a list with the following value:

The expression arguments[users].?[country=='USA'].size() will filter the items which has the country value set to "USA". Then it calculates the size, which returns the count. In this case, the result will be 1.

In Example 3, let's assume that the HANDLER_ARGUMENTS has a variable user, which represent a list with the following value:

The expression arguments[users].?[country=='USA'].size() > 0 ? 'USA_PRESENT' : 'USA_NOT_PRESENT' will filter the items which has the country value set to "USA". Then it calculates the size, which returns the count. In this case, the count is 1. If the count is greater than 0, then the result will be 'USA_PRESENT'.

Custom (JAR) handler

Network metadata

{
    "tuumIO_protocol": {
        "network_id": "dev-network-xxx",
        "node_url": "https://site000.abc.net",
        "name": "My TuumIO Network",
        "version": 1,
        "description": "This is a sample TuumIO network.",
        "publish_date": "2024-03-27",
        "effective_date": "2024-03-27",

Author details and countries