You cannot risk to perform Untrusted Transactions with Your Business Partners?

Today, relationships between companies and organizations generate vast amounts of mutual data. For example, trading companies continuously generate data about the trades they perform with each other. For various reasons, the parties in these relationships somehow have to keep track of this data. Obviously, outsourcing it to a cloud service is often impossible due to a lack of trust against the provider, in particular when dealing with highly sensitive or confidential corporate data.

As a consequence, the mutual data is typically stored individually by all involved parties in their own local databases. By this, all the data remains private between the parties. However, when keeping track of mutual data individually, there is a high risk that the stored data actually differs to some degree across the parties. Reasons for this are manifold, ranging from misinterpretation of data over type conversions to human errors. As a consequence, the databases diverge from each other over time, as shown in the following Figure:

This can lead to far-reaching problems: For example, to this day, doctors and hospitals typically keep track of patient records individually. If these records contradict each other or are incomplete, a faulty or even dangerous treatment can be the consequence. For obvious reasons, a verification of the stored data by a third-party instance is neither practical nor confidential.

This problem is present in various areas, businesses, and markets. For example:

If your company maintains data, that is in relation with other organizations, then your are likely facing the same untrusted situation.

Find out more about our solution to this problem.

chainifyDB^® solves the aforementioned problems. We establish trust in data management environments, that have been untrusted so far.

We do so by utilizing sophisticated blockchain technology. But don't worry: There is no need to rethink your entire infrastructure to leverage this new technology. chainifyDB^® keeps it simple and just integrates the powerful features, that made blockchains famous, into your current corporate landscape.

Effectively, you and your business partners can continue using your local independent database systems as before. At the same time, the chainifyDB^® network established between you and your business partners guarantees that all your mutual data is perfectly synchronized at all times.

The following Figure visualizes an infrastructure equipped with chainifyDB^®:

In contrast to other blockchain solutions on the market, chainifyDB^® is designed from the get-go as a fully seamless experience for our customers. It allows you to:

• Install chainifyDB^® minimally invasive on top of your established relational database systems.
• Query your mutual data using classical SQL.
• Formulate personal constraints on your mutual data, which your partners have to respect.
• Keep your legacy data and applications untouched and fully functioning.
• Recover your mutual data in case of external corruption or damage.
• Utilize high-performance parallel transaction execution across systems.

chainifyDB^®. More details about the features of chainifyDB^® are provided below.

chainifyDB^® is currently hosted as project within Saarland University. In March 2020, the Federal Ministry of Education and Research of Germany sponsored chainifyDB^® with a funding over 840.000 Euro (Press Release in German) in the context of the StartUpSecure programme.

Secure your Business Relationships

You can not risk to perform untrusted transactions with your business partners? You want to securely share mutual data with other organizations? You don't want to loose control about your data by moving it into the cloud?

chainifyDB^® establishes trust in environments, that have been untrusted so far. Equip your local infrastructure with sophisticated blockchain features.

• Execute trusted transactions with your trading partners, which are guaranteed to be executed on all parties in exactly the same way.
• No trusted third-party instance required to validate transactions.
• Formulate integrity constraints that must be respected by all parties.

Seamless Integration

You don't want to rethink your entire database infrastructure just to exploit blockchain technology?

Simply install chainifyDB^® on top of your established relational database management system and equip it with sophisticated blockchain features.

• Your legacy applications will function as before.
• No data migration to a new system required.
• New applications can perform trusted transactions.
• Installation on top of running databases causes zero downtime.

You and your business partners are currently using different database management systems, such as PostgreSQL and MySQL, and you don't want to switch?

No problem. chainifyDB^® is designed to be compatible with a variety of relational database management systems and even enables trusted transactions between different systems.

• Support for major open-source and commercial relational systems.
• Your favorite system is currently not officially supported? Contact us to discuss the compatibility of your system.

You don't want to rewrite your applications to work with complicated blockchain languages and interfaces?

 0  func(t *Chaincode) Deposit(stub shim.ChaincodeStubInterface,
                                        args []string) pb.Response {
 1    if len(args) != 2 {
 2      return errormsg(ERROR_WRONG_ARGS + " send_payment")
 3    }
 4    key := accountKey(args[1])
 5    accountBytes, err := stub.GetState(key)
 6    if err != nil { return errormsg(ERR_NOT_FOUND) }
 7    destAccount := Account{}
 8    err = json.Unmarshal(accountBytes, &res)
 9    if err != nil { return errormsg(ERR_NOT_FOUND) }
10     amount, _ := strconv.Atoi(args[0])
11     destAccount.checkingBalance += amount
12     accountBytes, err := json.Marshal(destAccount)
13     if err != nil { return errormsg(ERROR_PUT_STATE) }
14     key := accountKey(destAccount.CustomId)
15     err = stub.PutState(key, accountBytes)
16     if err != nil { return errormsg(ERROR_PUT_STATE) }
17     return shim.Success(nil)
18  }

Query your chainified relational database management system as before - using simple SQL.

0  BEGIN TRANSACTION
1 UPDATE Accounts
2    SET checkingBalance = checkingBalance + amount
3  WHERE acc = destAccount
4 COMMIT

Your don't want to worry about your data or the one of your trading partners getting damaged?

In case of data corruption or loss due to external causes, chainifyDB^® restores your data and the one of your partners always to a consistent state. Consequently, your data and thus your business is never at risk.