# Why you should revert early Ethereum transactions that revert still have to pay the gas used up until the revert was triggered; If they run out of gas they pay the full limit. If they hits a revert opcode, probably from a `require` statement as a result of maybe an integer overflow check, they'd pay the gas up until the `revert` opcode was hit. They don't pay for the gas afterwards. The implication is we should revert as early as possible in the execution to save the users gas incase a transaction reverts. Here are two (2) example contracts: ```solidity // DO NOT USE IN PRODUCTION // USED FOR EXPLANATION ONLY contract Example1 { uint256 public a; function simpleCheck(uint256 b) external { require(b < 4, "b must be less that 4"); a = b; } } contract Example2 { uint256 public a; function simpleCheck(uint256 b) external { a = b; require(b < 4, "b must be less that 4"); } } ``` From the contract`Example2` we would write to storage and then revert, while in `Example1` we would revert and then write to storage. So executing the first function from `Exapmle1` by calling `simpleCheck(6)`; it's obvious that the function would revert since `6` is greater than `4`. On executing this function the amout of gas used was `21,920`. ![Example1 transaction info](https://i.imgur.com/YNp6deJ.png) Now, executing the `simpleCheck` function from `Example2` which does `SSTORE` before reverting, the gas used was `44,034`; the extra `20,000` gas is coming for the storage value `a` being written to. ![Example2 transaction info](https://i.imgur.com/IZEPfs3.png) So I think that explains why you should do a revert quite early. Though there are situations where it is wise to do the check a little later and here is an example: ```solidity // DO NOT USE IN PRODUCTION // USED FOR EXPLANATION ONLY contract Example3 { uint256 public a; function multiplyOverflow(uint256 b) external { uint256 answer = a << b; // a * (2^b) require(answer > a, "overflow"); } } ``` From `Example3` above the function `multiplyOverflow` has a check after the multiplication and this is because it can get quite expensive to do a check for a multiplication function, so trying to anticipate if this function would revert might make it more expensive; Sometimes it is a good idea to do the check afterwards. In many cases where you use a contract from an external source it would be a great idea to do a check after executing a function from the contract, since there is a possibility that it can be mallicious. ---- If you found this helpful, consider following me on Twitter [@0xosas](https://twitter.com/0xosas).
Last changed by  
 
0xosas
91

Read more

An experimental minsweeper implementation

Well, this article is relating to my last article on tictactoe game and this is because of similar logic being used. A Minsweeper Game The objective of the game is to clear a board that contains hidden "mines" or "bombs" without detonating any of them, and they are randomly placed in a 9x9 grid (beginners level). On every right opeing there's a clue which indicate how many bombs are in the adjacent cells. At any point, you can perform 2 actions: Marking a cell - marking or flagging a cell that you think might be a bomb Revealing a cell - revealing the cell. If it is an empty cell, then all of the surrounding empty cells will also be revealed. Revealing a cell containing a bomb is game over.

8/17/2022
Ethereum block limit

The first crypto-currency Bitcion has limited a block size to 1-MB, and this is beacause if a block is too large it becomes expensive to store or sync with other nodes across the world or the blockchain. Ethereum doesn't place a block limit like Bitcion does, it just limits the total amount of computation on a single block since each computation has a gas cost. And the reason for this is, if a block has too much computation on it, it becomes difficult for nodes to verify the transactions quickly. So with a block limit set, if a transactions requires too much gas the transactions gets reverted. What is gas? Gas is a transaction unit that represents computational effort. It’s the fuel you must buy to get miners to add your transaction to a block. At the time of writting the block limit is 30 million (30,000,000) gas; An eth transfer cost 21 thousand (21,000) gas, so doing the math you'd see that a single block can hold just 1,428 transfers approximately. A few relating terms.

8/3/2022
Optimized tic-tac-toe game in Solidity

Building on Ethereum can be expensive, and many times it intuitive to gain control over your code and one way to achieve this is by utilzing bit operations. Many developers use it as a means of optimization, expecially in the case of ethereum when you code now cost you money. Here I'd be explaining a program I wrote not long ago, just so you'd gain an understanding of a simple use case of bit operations. Also, I assume you understand how to work with bitwise operators, and if you don't check out my article on how they work here. What is Tic-tac-toe Tic-tac-toe is a 2 player game where players take turns to make a finite amount of moves until either all moves has been exhausted (its a draw) or a player has won. Here is a typical tic-tac-toe game. # an empty game # game where play x won

8/3/2022
Bit Operations

This is an introduction to using bitwise operators and you'd learn how to do magical stuffs with them. So basically bit operations are used to manipulate bits (binary numbers) and here are the signs used: Bitwise AND & A bitwise AND is a binary operation that takes two bits and performs the logical AND operation on them. If the bits compared are 1, then bit in the resulting binary representation is 1 (1 & 1 = 1); otherwise, the result is 0 (1 & 0 = 0 and 0 & 0 = 0) source. Here is a typical example: A B A & B

7/27/2022
Read more from 0xosas
Published on HackMD