Writing SmartContracts with Java framework in Takamaka Technology

Writing smartcontracts with Java

Takamaka framework for writing smartcontracts with java allows programmers to use a subset of Java to write code that can then be installed and executed in blockchain. Programmers will never have to deal with object storage, this will be (instead) completely transparent.

Takamaka is different from other attempts to use Java to write Smart Contracts , where programmers must use explicit method calls to make data persistent on blockchain.

Writing smart contracts in Java means that developer’s do not have to learn another programming language, but instead use a well-understood and stable development platform, along with all of its modern tools.

Programmers can use the functionality of the latest versions of Java, however there are (as a matter of course) limitations to the type of code that can be executed within a blockchain. The most important limitation is that programmers can only call a part of the huge Java library, whose behavior is deterministic and whose methods are guaranteed.

Takamaka Java framework included in Hotmoka project

The Takamaka programming language runtime is included in the Hotmoka project, a framework for collaborative nodes whose long-term goal is to unify the programming model for blockchain and the Internet of Things. The most significant aspects of Hotmoka and Takamaka were described by Professor Fausto Spoto at these recently published Links [Spoto19] [Spoto20] .

A Hotmoka node executes Java code remotely. Said node can be any type of machine, such as a device of an IoT network or a blockchain node.

The compiled jars of the Hotmoka project and the Takamaka language runtime are available in the public Maven repository. In other words, you don’t need to download anything to start using Hotmoka nodes and programming those nodes in Takamaka

Takamaka framework for writing smart contracts with java, allows programmers to use a subset of Java to write code in blockchain

Takamaka is therefore the language that can be used to write smart contracts for Hotmoka nodes. Hotmoka nodes and Takamaka code have exactly the same relationship that exists between Ethereum nodes and Solidity code.

Hotmoka allows to develop smart contracts in Java with the Takamaka support library, within your preferred IDE. The compiled bytecode is verified, instrumented and installed in the Hotmoka node store, while the underlying Tendermint engine provides consensus.

Moka allows you to perform a wide variety of operations on a Hotmoka node.
However, it is a technical tool, intended mostly for developers, because most users will only perform simple tasks with a Hotmoka node.

Mokito is the Android app that allows you to connect to a Hotmoka node, view its manifest, browse objects in its state, create and manipulate accounts, and send and receive crypto.

The advantages of hotmoka

It is widely known that the Java language, which is strongly typed, dissuades hackers from attacks in solidity, due to the fact that known vulnerabilities cannot take place.

IERC721Receiver is the interface built within Hotmoka, which is not susceptible to the same vulnerabilities present in solidity.

On the implementative level, downloading the source code *HERE*, it is currently possible to integrate any Ethereum token by migrating the Smart Contract in question to Hotmoka

Oracles and applications which interface and communicate with the SCs written in solidity which have now migrated to Hotmoka (Takamaka), will maintain all their features and interactions, while the interface remains the same.

Thanks to this integration, it will be possible to transfer solidity contracts in Hotmoka, taking advantage of simple and quick methods, which are highly reliable and with lower implementation and functional costs in terms of gas.

Use cases

Among the main cases to be taken into account is the implementation of NFT contracts, carried out for the most part in Solidity, through the ERC721 standard. (The ERC721 is an interface for distributive contracts within the Ethereum blockchain).

Thanks to the IERC721Receiver for writing Takamaka smart contract, it will be possible to codify NFT contracts in Java, and execute them within the Hotmoka blockchain (TAKAMAKA).

For more information, please check out the links below.




GitHub — Hotmoka/hotmoka_tutorial: progetti di esempio dal tutorial su Hotmoka


Resta aggiornato con la Newsletter Settimanale