Enterprise Integration for Ethereum

The Ethereum Ecosystem

Ethereum is an open-source, public blockchain platform for running smart contracts. It provides a decentralized Turing-complete virtual machine that can execute scripts and a cryptocurrency used to compensate participant mining nodes for computations performed or to mitigate spam. Today, Ethereum is one of the most established and mature blockchain platforms, with interest from small and large companies, nonprofit organizations, and governments. There is a lot that can be said about the Ethereum ecosystem and the pace it moves. However, the facts talk for themselves; Ethereum has the momentum and all the indications of a technology with potential:

• Ethereum has an order of magnitude and more active developers than any other blockchain platform, and as dictated by the Metcalfe's law, this gap widens day by day. Ethereum coding school CryptoZombies has over 200K users, and Truffle development framework has over half a million downloads.
• The Ethereum platform has the richest tools and infrastructure ecosystem for building decentralized applications: Truffle, Infura, Web3.js, OpenZeppelin, Geth, Parity, Ganache, MetaMask, CryptoZombies, MyCrypto, Etherscan, ERC20 (for ICOs), etc.
• The cloud platforms Amazon Web Services and Microsoft Azure offer services for one-click Ethereum infrastructure deployment and management.
• The Ethereum technology has the interest of enterprise software companies. Customized Ethereum-based applications are being developed and experimented with by financial institutions such as JPMorgan Chase, Deloitte, R3, Innovate UK,  Barclays, UBS, Credit Suisse, and many others. One of the best-known in this area is the J. P. Morgan Chase-developed permission of the Ethereum blockchain called Quorum.
• In 2017, Enterprise Ethereum Alliance (EEA) was setup up by various blockchain start-ups, Fortune 500 companies, research groups, and others with the aim to help the adoption of Ethereum-based technology. It provides standards and resources for businesses to learn about Ethereum and leverage this groundbreaking technology to address specific industry use cases.

Ethereum has passed the moment when it was a hipster technology or a scientific experiment, and now, it is a fundamental, open-source, decentralization technology that enterprise companies are looking into. Talking about open source and the enterprise, I thought I would also make my tiny contribution to the Ethereum ecosystem and help with its adoption.

Open Source Enterprise Integration

Ethereum is distributed and decentralized, but it is mostly a closed system with the embedded ledger, the currency, and the executing nodes. In order to be useful for the enterprise, Ethereum has to be well integrated with existing legacy and new systems. Luckily, Ethereum offers a robust and lightweight JSON-RPC API with good support for the JavaScript language. However, in enterprise companies, JavaScript is not the primary choice for integration. It is rather Java, followed by .Net. Java is not necessarily lightweight or fast-evolving, but it has a huge developer community and a mature library ecosystem, making it the top choice for the majority of enterprise companies. The main factor contributing to the productivity of the Java language is the reuse of existing libraries and avoiding reinventing the wheel. One of the most popular libraries enabling reuse and avoiding reinventing the wheel for integration is Apache Camel. Luckily, Camel happens to be my passion and a project I have been contributing to for many years, so connecting the two was the most natural thing for me to do.

Building Blocks of Apache Camel

For those who are coming from a blockchain background and are not familiar with Camel, here is a very brief intro. Apache Camel is a lightweight open-source integration library that is composed conceptually of three parts:

• Implementations of the widely used Enterprise Integration Patterns (EIPs). (Notice this is not an Ethereum Improvement Proposal that shares the same acronym.) EIPs provide a common notation, language, and definition of the concepts in the enterprise integration space (think of publish-subscribe, dead letter channel, content-based router, filter, splitter, aggregator, throttler, retry, circuit breaker, etc.). Some of these patterns have been around for over a decade, and some are new, but they are well-known by anyone doing messaging and distributed system integration for a living.
• The second major part of Apache Camel is the huge connectors library. Basically, as long as there is a Java library for a protocol, system endpoint, or SaaS API, most likely there is a Camel connector for it (think of HTTP, JMS, SOAP, REST, AWS SQS, DropBox, Twitter, and now Ethereum, etc.). Connectors abstract away the complexity of configuring the different libraries and provide a unified URI-based approach for connecting to all kinds of systems.
• And the last piece of Apache Camel is the Domain Specific Language (DSL) that wires together connectors and EIPs in a higher level integration focused language. The DSL, combined with connectors and patterns, makes developers highly productive in connecting systems and creates solutions that are industry standard and easier to maintain for long periods. All these are characteristics that are important for enterprise companies looking to create modern solutions based on mature technology.

Companies are more integrated than ever, and the systems within the companies are more integrated than ever. And if you are a Java shop, most likely, there is already some Apache Camel-based integration in use somewhere in the organization. Now you can use Camel and all the capabilities it provides also to talk to Ethereum.

Apache Camel Connector for Ethereum

The natural intersection of the two technologies is a Camel connector for Ethereum. Such a connector would allow for the integration of Ethereum with any other system, interaction style, and protocol. For that purpose, I evaluated the existing Java libraries for Ethereum and came to the conclusion that web3j is the right fit for this use case. Web3j is an actively developed, feature-rich Java library for interacting with Ethereum-compatible nodes over JSON-RPC. Camel-web3j connector (the technical name for the Camel Ethereum connector) is a thin wrapper that gives an easy way to use the capabilities offered by web3j from Apache Camel DSL. Currently, the connector offers the following features:

• Works with Geth, Parity, and Ganache.
• Support for Infura API.
• Support for JP Morgan's Quorum API.
• Support for JSON-RPC API over HTTP and IPC.
• Implementation of all web3, net, eth, and shh operations.
• Support for filters. 
• Support for Ethereum Name Service (ENS).
• Fully unit and integration tested (over 100 and growing).

The full power of this integration comes not from the connector features but when the connector is used together with the other connectors, patterns, and all other Camel capabilities to provide a complete integration framework around Ethereum.

Ethereum Compatible JSON-RPC APIs

Next, I'm going to focus on adding support for Parity's Personal and Geth's Personal client API, Ethereum wallet support, and others. The aim is to keep the component up-to-date with the web3j capabilities that are useful in system-to-system integration scenarios with Apache Camel. The connector is pushed to Apache Camel 2.22 and ready for early adopters to give it a try and provide feedback. To get started, have a look at the unit tests to discover how each operation is configured and the integration tests to see how to connect to Ganache or Ethereum mainnet, etc. Enjoy.

Use Cases for Apache Camel

Below is the Enterprise Ethereum Architecture Stack (EEAS), which represents a conceptual framework of the common layers and components of an Enterprise Ethereum (EE) application according to the client specification v1.0.

Enterprise Ethereum Architecture Stack

If you wonder where exactly Camel fits here, Camel-web3j is part of the tooling layer as an integration library with a focus on system-to-system integration. It uses the public Ethereum JSON-RPC API, which any Enterprise Ethereum compatible implementation must support and keep backward compatible with.

Then, Camel would primarily be used to interact with services that are external to Ethereum but trusted by smart contracts (so-called Oracles). In a similar manner, Camel can be used to interact with Enterprise Management Systems to send alerts and metrics, report faults, change configurations, etc.

The main use cases I can think of for this connector are:

• Listen for new block events happening in the Ethereum network, filter, transform, enrich and publish them into other systems. For example, listen for new blocks, retrieve their transactions, filter out uninteresting ones, enrich others, and process them. That can be done using Ethereum node filter capabilities or purely with Camel, using polling consumers to query a node periodically and idempotent filters to prevent processing previously processed blocks, etc.
• The other use case would be to listen for events and commands coming from an enterprise system (maybe a step in the business process) and then tell the Ethereum network about it. For example, a KYC is approved or payment is received in one system, which causes Camel to talk to the second system and retrieve a user's ERC20 address and perform an Ethereum transaction.

Real-world uses of Camel would involve a more complex mixture of the above scenarios, ensuring high availability, resilience, replay, auditing, etc., in which Camel is really good.

Ethereum Oracle Implemented in Apache Camel

"Talk is cheap. Show me the code." — Linus Torvalds

On many occasions, smart contracts need information from the real world to operate. An oracle is, simply put, a smart contract that is able to interact with the outside world. The demonstrate the usage of Camel-web3j, I created a Camel route that represents an oracle. The route listens for CallbackGetBTCCap events on a specific topic, and when such an event is received, the Camel route generates a random value and passes it to the same contract by calling the setBTCCap method. That is basically a "Hello world!" the Ethereum way.

To trigger the event, you can call the updateBTCCap method on the smart contract using the following unit test:

mvn test -Dtest=CamelOracleRouteTest#updateBTCCap

To check the current price in the contract, you can call the getBTCCap method on the smart contract using the following unit test:

mvn test -Dtest=CamelOracleRouteTest#getBTCCap

Check the full instructions, the smart contract, and Camel routes on GitHub, and try it for yourself. If you use the component and have questions or feedback, if you like this and you are interested in implementing Camel connector for other blockchain projects, reach out. Take care.