Solidity

This is the approved revision of this page, as well as being the most recent.
Solidity programming language – Ethereum, smart contract, blockchain

Solidity is a contract-oriented programming language for writing smart contracts. It is used for implementing smart contracts on various blockchain platforms. It was developed by Gavin Wood, Christian Reitwiessner, Alex Beregszaszi, Liana Husikyan, Yoichi Hirai and several former Ethereum core contributors to enable writing smart contracts on blockchain platforms such as Ethereum.

Contents

Solidity Smart ContractsEdit

Solidity was initially proposed in August 2014 by Gavin Wood; the language was later developed by the Ethereum project's Solidity team, led by Christian Reitwiessner. It is one of four languages (the others being Serpent, LLL, Viper (experimental) and Mutan (deprecated)) designed to target the Ethereum Virtual Machine (EVM).

A Cornell University researcher stated that Solidity was partially to blame for The DAO hack that took place in 2016. He stated: "this was actually not a flaw or exploit in the DAO contract itself: technically the EVM was operating as intended, but Solidity was introducing security flaws into contracts that were not only missed by the community, but missed by the designers of the language themselves."

Solidity TutorialEdit

Solidity is a statically-typed programming language designed for developing smart contracts that run on the EVM. Solidity is compiled to bytecode that is executable on the EVM. With Solidity, developers are able to write applications that implement self-enforcing business logic embodied in smart contracts, leaving a non-repudiable and authoritative record of transactions. Writing smart contracts in smart contract specific languages such as Solidity is referred to as easy (ostensibly for those who already have programming skills).

As specified by Wood it is designed around the ECMAScript syntax to make it familiar for existing web developers; unlike ECMAScript it has static typing and variadic return types. Compared to other EVM-targeting languages of the time such as Serpent and Mutan, Solidity contained a number of important differences. Complex member variables for contracts including arbitrarily hierarchical mappings and structs were supported. Contracts support inheritance, including multiple inheritance with C3 linearization. An application binary interface (ABI) facilitating multiple type-safe functions within a single contract was also introduced (and later supported by Serpent). A documentation system for specifying a user-centric description of the ramifications of a method-call was also included in the proposal, known as "Natural Language Specification".

Example of a Solidity code:

contract GavCoin
{
 mapping(address=>uint) balances;
 uint constant totalCoins = 100000000000;

 /// Endows creator of contract with 1m GAV.
 function GavCoin(){
 balances[msg.sender] = totalCoins;
 }

 /// Send $((valueInmGAV / 1000).fixed(0,3)) GAV from the account of $(message.caller.address()), to an account accessible only by $(to.address()).
 function send(address to, uint256 valueInmGAV) {
 if (balances[msg.sender] >= valueInmGAV) {
 balances[to] += valueInmGAV;
 balances[msg.sender] -= valueInmGAV;
 }
 }

 /// getter function for the balance
 function balance(address who) constant returns (uint256 balanceInmGAV) {
 balanceInmGAV = balances[who];
 }

}

Development platform availabilityEdit

See alsoEdit

External linksEdit

SourceEdit


Licence.png