Solidity – Gas, gas price, fee and gas usage

gas – is the name for a special unit used in Ethereum

gas price – a value set by the creator of the transaction; it’s a single gas unit’s price;

fee – the result of gas * gas price

Transactions costs x Ethereum system

• Have in mind if the gas price is too low, no one will process your transaction;

• The fees are paid in ether, though, which is different from gas;

• The transaction fails (still goes into the blockchain) in case of gas price is fine but the gas cost runs “over budget”. You don’t get the money back for the work that the miners did.

• Transaction fee = Amount of work that goes into something + storage space your code will take;

Optimize gas usage of your smart contract

Gas is necessary for the execution of smart contracts, but you shouldn’t specify too low or high price. Consider optimizing your smart contract to minimize the amount of gas required.

What should I take into account for optimized contracts?

Global Variables usage – storage: Global variables are stored in a contract’s state on the blockchain, so you are going to be charged if you use global variables. Just use when it is necessary, this is a practice in several languages, but it is especially crucial in ethereum development;

Contract Size: The size of your contract will influence the transaction cost for all interactions with it. So how big is your contract, more expansive your contract will be to processed in the Ethereum’s network. If you are able to break the Solidity contract up into smaller separate contracts, this will decrease user’s gas costs;

Further Details

Take a look in this documentation from ConsenSys for Ethereum Smart Contract Security Best Practices and this Medium post about Optimizing gas usage.

Solidity – Block and Transaction Properties

Solidity provides special variables and functions which always exist in the global namespace and are mainly used to provide information about the blockchain or are general-use utility functions. The following is a list of properties related to the block and transactions:

• block.blockhash (uint blockNumber) returns (bytes32): Hash of the given block, works for only the 256 most recent blocks
• block.coinbase (address): Current block miner’s address
• block.difficult (uint): Current block difficulty
• block.gaslimit (uint): Current block gas limit
• block.number (uint): Current block number
• block.timestamp (uint): Current block timestamp
• msg.data (bytes): Complete call data
• msg.gas (uint): Remaining gas
• msg.sender (address): Sender of the message (current call)
• msg.sig (bytes4): First 4 bytes of the call data (function identifier)
• msg.value (uint): Number of wei sent with the message
• now (uint): Current block timestamp (alias for block.timestamp)
• tx.gasprice (uint): Gas price of the transaction
• tx.origin (address): Sender of the transaction (full call chain)

Solidity – Hashes and Typecasting

Hashes

In Solidity, it is possible to use the keccak256 function to get a hash. Ethereum’s KECCAK-256 algorithm produces a 256-bit hexadecimal number.

keccak256(…) returns (bytes32): compute the Ethereum-SHA-3 (Keccak-256) hash of the (tightly packed) arguments

Usage Examples

keccak256(6382179)
keccak256(97, 98, 99)

Typecasting

Solidity is a statically typed language, which means that the type of each variable (state and local) needs to be specified at compile-time. Solidity is able to perform operations between two variables that have the same type. Therefore you can convert one of the variables to the type of the others.

uint256 z = y * uint256(x);
uint8 x = 8;
uint256 y = 10 ** 18;

Hello Solidity, hello Ethereum

According to official Solidity docs is a contract-oriented, Solidity is a high-level language for implementing smart contracts. It was influenced by C++, Python and JavaScript and is designed to target the Ethereum Virtual Machine (EVM).

Alright, let’s talk about Solidity’ syntax and its features. Basically I’m mention the following subjects: Contracts, Types of variables, Math operations, Functions, Arrays, Structs and Events.

Let’s start

A contract is the fundamental building block of Ethereum applications — everything goes inside the contracts. This is very similar to Java, commonly all the code is encapsuled in ‘Class’.

First important thing you need to learn is how Solidity handles variables. Solidity is a statically typed language, which means that the type of each variable. Once you start coding variables and functions inside you Contract file, you need to understand Solidity has two types of variables: state and local. State variables are permanently stored in contract storage - into the Ethereum blockchain, it may cost some ‘gas’ in case you try to modify them. Local variable you can modify them freely but remember you will loose their value right after the context/scope change - they are not stored.

Booleans bool: The possible values are constants true and false.

Integers int / uint: Signed and unsigned integers of various sizes. Keywords uint8 to uint256 in steps of 8 (unsigned of 8 up to 256 bits) and int8 to int256. uint and int are aliases for uint256 and int256, respectively.

Address address: Holds a 20 byte value (size of an Ethereum address). Address types also have members and serve as a base for all contracts.

Members of Addresses balance and transfer: It is possible to query the balance of an address using the property balance and to send Ether (in units of wei) to an address using the transfer function.

Fixed-size byte arrays bytes1, bytes2, bytes3, …, bytes32. byte is an alias for bytes1.

Dynamically-sized byte array bytes: Dynamically-sized byte array. string: Dynamically-sized UTF-8-encoded string.

String Literals They are written with either double or single-quotes (“foo” or ‘bar’). They do not imply trailing zeroes as in C; “foo” represents three bytes not four. As with integer literals, their type can vary, but they are implicitly convertible to bytes1, …, bytes32, if they fit, to bytes and to string.

Math Operations

Solidity offers the following math operations (it is almost the same as in most programming languages):

Addition: x + y Subtraction: x - y, Multiplication: x * y Division: x / y Modulus / remainder: x % y Support an exponential operator (i.e. “x to the power of y”, x^y):

Structs

Sometimes you need a more complex data type. For this, Solidity provides structs:

`struct Person { uint age; string name; } Structs allow you to create more complicated data types that have multiple properties.

Events

Events are a way for your contract to communicate that something happened on the blockchain to your app front-end, which can be ‘listening’ for certain events and take action when they happen.

Events are inheritable members of contracts. When they are called, they cause the arguments to be stored in the transaction’s log - a special data structure in the blockchain. These logs are associated with the address of the contract and will be incorporated into the blockchain and stay there as long as a block is accessible (forever as of Frontier and Homestead, but this might change with Serenity). Log and event data is not accessible from within contracts (not even from the contract that created them).

Further details

I’d recommend this article Ethereum Smart Contract Best Practices for beginners.

Architecture Components – let's make Android great again

Google I/O 2017 brought a new package of outstanding news. In my point of view, one of the most relevant news were Architecture components, a new bunch of libraries that help developers design apps with testability, maintainability and clean code.

Room

This is my favorite library of Architecture Components, surely. Room is an object mapping library that let the code clean and collaborate with SQL queries. Furthermore, the library provides SQL queries validation compilation time, annotations and observables for database changes. I knew this today would come, a day that Google will release a library for persistence such Apple offer for iOS (Core Data). Hereafter I have no doubt Room will be a reference for the persistence layer although there are tons of similar libraries such as ORMLite, Active Android or GreenDAO.

ViewModel

• Provide data for fragment/activity;
• Independent of View: configuration changes don’t affect ViewModel;
• Similar to an usual presenter however the retention/loading is built-in;
• Retention happens through FragmentManager and HolderFragment;

Live Data

it is responsible for listen and propagate data changes: an observable data holder It allows broadcasting of data changes all over the architecture layers taking into account all system issues eg. memory leaks.

Lifecycle Owner - Lifecycle

It allows the creation of lifecycle-aware components which are able to adjust itself automatically according to the current lifecycle. This feature is possible because Lifecycle owner associates a class to the lifecycle via an abstract class called getLifecycle().

Further Details

I recommend this project which Google team implemented samples of Architecture Componentes and this video from Google I/O.