A commission must be paid for any transactions on the blockchain.

Transaction fees are introduced to encourage and reward miners or validators who expend their computing resources to validate all transactions and create new blocks.

The more complex the transaction, the more expensive it will be.
This is because a certain amount of gas must be paid for any computational step (line of code). Any action within a transaction: allocating or overwriting a memory cell, or any logical or arithmetic operation requires a certain amount of gas.

On Ethereum, the minimum amount of gas = 21,000 is the cost of forming a transaction. For each additional computational step, gas is still charged.

Depending on how complex the transaction is, more gas will be spent. The maximum amount of gas that can be in a transaction = is 8,000,000 gas. The most expensive are either rewriting a huge number of values in a smart contract or deploying a new heavy smart contract.

How is the amount of ether taken per transaction calculated?
1 eth = 10¹⁸wei = 10⁹gwei

To calculate the cost of a transaction, you must:
21,000(transaction formation cost)*15(gas cost at the moment of article writing)*10^-9=0,000,315 eth.

If we want to calculate in dollars, then we need to multiply by the price of ether.

That is approximately $1,500 * 0,000,315 eth = $0.4725 — the cost of a transaction on Ethereum for sending from one address to another.

To spend as little money on a transaction as possible, it is necessary to write optimized code. If unnecessary checks are present or duplicated in the code, or work with memory allocation is incorrectly performed, then the transaction becomes more expensive. The more complex and less optimized the function, the more expensive the transaction.

Therefore, to write optimized code, you need to have basic knowledge of Solidity and know the main ways to optimize smart contracts:
— a competent approach to building a smart contract architecture
— avoid having a huge number of cycles in smart contracts. Cycles in smart contracts are bad
— avoid a huge number of unnecessary variables, the absence of which will not affect performance in any way. Since each variable requires the allocation of a memory area, which will entail additional calculations and, as a result, will lead to an increase in the cost of transactions with a call to this function
— avoid unnecessary checks (require). If the inherited library already has the necessary checks, duplicating them will make the function call more expensive.
— define function access modifiers correctly.
— in the conditions in the first place you need to put the option that will be the most likely. So you do not have to spend additional gas to find the right option.

What can the lack of optimization lead to:
— сalculations will be more expensive
— overflow risks
— smart contract efficiency will decrease

Smart contract checks are covered by the developers themselves with the help of unit tests. Also, developers write down all usage scenarios and add them to autotests. For this, smart contract developers use the TypeScript language, as well as auxiliary tools web3, ethers, mocha, solidity coverage, etc.
Also, it is important to have a background in another language to have experience in building a competent smart contract architecture.

Contact us and let’s start working together on your projects! https://crypton.studio/



Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store