DEV Community: Luis Lucena

Solidity Complete Fundamentals Cheat Sheet

Luis Lucena — Thu, 01 Sep 2022 21:57:41 +0000

What is Solidity?

It is a contract-oriented high level language for implementing smart contracts. It was influenced by C++, JavaScript and Python and is designed to target the EVM.

Contracts

Contracts in solidity are similar to classes in object oriented language.
A contract can be created using "new" keyword.

contract L {
function add(unit_p, unit_q) returns(unit){
return_p+_q;
}
}
contract M{
address p;
function f(unit_p){
p = new L();
}
}

Smart Contracts

It is a computer protocol which is used to streamline the process of contracts by digitally enforcing, verifying and managing them.

Remix, Solium & Doxity

- Remix: It is a browser based IDE with integrated compiler and solidity run-time environment without server side components.

- Solium: A linter to identity and fix style security issues in solidity.

- Doxity: Used in solidity as a documentation generator.

Solograph & Assembly

- Solograph: Used to visualize solidity control flow and highlight potential security vulnerabilities.

- Solidity Assembly: An assembly language which is used without solidity & inline assembly inside solidity source code.

Gas & Block Gas Limit

- Gas: A measurement roughly equivalent to the computational steps.

- Block Gas limit: It is used to control the amount of gas consumed during the transactions.

Solidity Compiler

        Contract Definition
                |
         Solidity Compiler
                |
      Byte code - Application Binary Interface (ABI)

ABI & WEI

- ABI: A data encoding scheme called "Application Binary Interface" (ABI) is used in for working with smart contracts.

- WEI: The smallest denomination or base unit of Ether.

Global Variables

- block.blockhash(uint numberOfBlock)returns(bytes32): hash function of the given block which works for the 256 most recent blocks excluding the current block.

- block.coinbase(address): shows miner's address of current block.

- block.numer(uint): number of current block.

- block.gaslimit(uint): gaslimit of the current block.

- block.timestamp(uint): timestamp of current block.

- msg.gas(uint): the gas that remains.

- msg.value(uint): the amount of WEI sent along with the message.

- msg.sender(address): address of the message sender(current call).

- msg.sig(bytes4): first four bytes of the call data.

- now (uint): timestamp for the current block..

- tx.origin(address): the sender of the transaction(whole call chain).

Pragma

Used to specify certain conditions under which the source files can or cannot run.

Example:
- pragma solidity ^0.8.15
       This code compiles with a compiler function >=0.8.15
- A pseudocode example for pragma syntax
       'pragma' Identifier([^;]+)';'

Interface

Interface in solidity are defined as contractsm but the function bodies are omitted for the functions.
Example:
pragma solidity ^0.22
interfaceToken
{
       function transfer(address recipient, uint amount);
}

Data Types

- Boolean:
true or false
Logical:!(Logical negation), && (AND), || (OR)
Comparisons:==(equality),!=(inequality)

- Integer: Unsigned Integer, and Signed integer Comparisons:<=(Less than or equal to), <(Less than),==(equal to),!=(Not equal to),>=(Greater than or equal to),>(Greater than) Arithmetic Operators: + (Addition), - (Subtraction), Unary —, Unary +, * (Multiplication), / (Division), ** (Exponential), << (Left shift), >>(Right shift)

- Address: Holds an Ethereum address(20 byte value).
Operators: Comparisons: <=, <, ==, !=, >= and >
Balance:
- <address>.balance(uint256): balance of address in WEI
Transfer and send:
- <address>. transfer(uint256 amount): send given amount of Wei to Address, throws on failure.
- <addres>.send(uint256 amount)returns(bool): send given amount of Wei to Address, returns false on failure.

Global functions:

- keccak256(...)returns(bytes32)-computes the ethereum SHA-3 hash associated with the arguments.

- SHA256(..)returns(bytes32) — Computes the SHA-256 argument hash.

- mulmod( uint a, uint b, uint c)returns(uint): It computes (a*b)/c, if the multiplication gets executed using arbitrary precision, thus not wrapping around 2**256

- addmod(uint p, unint q, uint m)returns(uint): Computes (p+q)/m

- ecrecover(bytes32 _hash, uint8 _v, bytes32 _r, bytes32 _s)
returns (address): recovers the address linked with the public key and if an error occurs, zero is returned.

- ripemd160(...)returns(bytes20): computes the RIPEMD-160
(tightly packed) argument hash.

- <address>.balance(uint256): Returns the balance of the specified address in WEI.

- <address>.send(uint256 amount)returns(bool): It sends the specified number of WEI to the address given, on failure it returns false as an output.

- <address>.transfer(uint256 amount): Sends specified number of WEI to the particular address, on failure throws.

Access Modifiers:

- Public: Accessible from the current contract, inherited contracts externally.

- Private: Accessible only form the current contract.

- Internal: Accessible only from current contract and contracts inheriting from it.

- External: Can be accessed externally only.

Important Terms

- Voting: When the contract is quiet complex, it uses voting contract, it shows how delegated voting can be done so that vote counting is automatic and completely transparent at the same time.

- Delegate call: It is a reusable library code that can be applied to a contracts storage in solidity.

- Logs: A feature called logs is used in solidity to implement events.

- NPM: It is a convenient and portable way to install Solidity compiler.

- Truffle: It is a test bed that will allow to easily test and compile the smart contract.

- Inheritance: In solidity inheritance is more syntactic. In the final compilation the compiler copies the parent class members to create the byte-code of the derived contract with the copied members.

- This: This is a keyword that refers to the instance of the contract where the call is made.

- msg.sender: This function refers to the address where the contract is being called from.

- Pure: It is a modifier which assures not to be read from or modified.

- View: In solidity, view is a function that promises to not modify the state of the smart contract.

- Suicide: It is a alias for self destruct function, that is used to destroy the current contract.

- Delete: Delete is used to delete all elements in an array.

- Block.coinbase(address): It refers to the minter's address of the current block.

- Address(contractVar).send(amount): If a built-in send function needs to be used, it can be accessed using this function.

- Super: It is used to refer the contract that is higher by one level in the inheritance hierarchy.

Transaction Example

I hope this can be of service to you ❤️
Any feedback is welcome :)

tw: @_luisald
website: Luis Lucena

Hardhat bug fix with MetaMask due to chainId

Luis Lucena — Sun, 10 Jul 2022 22:29:30 +0000

Fix

This is a Hardhat error that originates because MetaMask takes the default network and hardhat works with another network. Here is a sample of the error and how to fix it.

Config your hardhat.config.js file

Manually add the chaindId:1337 to avoid the conflict with MetaMask

e.g

require("@nomicfoundation/hardhat-toolbox");
// The next line is part of the sample project, you don't need it in your
// project. It imports a Hardhat task definition, that can be used for
// testing the frontend.
require("./tasks/faucet");
/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
  solidity: "0.8.9",
  networks: {
    hardhat: {
      chainId: 1337 // We set 1337 to make interacting with MetaMask simpler
    }
  }
};

Boot up local development blockchain

$ npx hardhat node

Connect development blockchain accounts to MetaMask

Copy private key of the addresses and import to MetaMask
Connect your MetaMask to hardhat blockchain, network 127.0.0.1:8545.
If you have not added hardhat to the list of networks on your MetaMask, open up a browser, click the fox icon, then click the top center drop down button that lists all the available networks then click add networks. A form should pop up. For the "Network Name" field enter "Hardhat". For the "New RPC URL" field enter "http://127.0.0.1:8545". For the chain ID enter "1337". Then click save.

Migrate Smart Contracts

$ npx hardhat run src/contracts/scripts/deploy.js --network localhost

Finally

Once you have your test account on the hardhat node you will have 10000 ETH to deploy your contracts.

Happy coding!❤️
💫 contributions are appreciate..
ETH address: luislucena.eth
tw: _luisald

Web3 terms you should know

Luis Lucena — Sat, 02 Jul 2022 05:55:35 +0000

CEX: Centralized Exchange
DEX: Decentralized Exchange
DEFI: Decentralized finance
CEFI: Centralized finance
DAOS: Decentralized Autonomous Organization
DApps: Decentralized Applications
TVL: Total Value Locked
PoW: Proof of Work
PoS: Proof of Stake
APY: Annual percentage yield
IR: Interest Rate

NFT: Non Fungible Token
DYOR: Do your own research
NFA: Not Financial Advice
BTFD: Buy the fucking dip
Wagmi: We are gonna make it
KYC: Know Your Customer
P2P: Peer To Peer
FUD: fear, uncertainly, doubt
FOMO: fear of missing out

ATH: all time High
ATL: all time Low
TF: Time Frame
HTF: higher time Frame
LTF: lower time Frame
ST: short term
LT: long term
IT: Intermediate Term
SL: Stop Loss
TL: Trend Line
WR: Win Rate

R/R: Risk/Reward
BE: Break Even
TP: Take Profit
TA: Technical Analysis (or AT)

FA: Fundamental Analysis (or AF)
EW: Elliott Waves
SMC: Smart money concept
PA: Price Action

VSA: Volume Spread Analysis
PDH: Previous Day High
PDL: Previous Day Low
PWH: Previous Week High
PWL: Previous Week Low
PMH: Previous Month High
PML: Previous Month Low
EQH: Equal Highs
EQL: Equal Lows
HH: Higher High
HL: Higher Low
LH: Lower High
LL: Lower Low

HTF: Higher Time Frame
RN: Round Numbers
OSOK: One Shot One Kill
BMS: Break in Market
OB: Order Block
BR: Breaker
MB: Mitigation Block
RB: Reclaimed Block-Rejection Block
PB: Propulsion Block
VB: Vacuum Block
FVG: Fair Value Gap
LV: Liquidity Void
LP:Liquidity Pool

CL: Candy Land
CPR: Central Pivot Range
BISI: Buy Side Imbalance Sell Side Inefficiency
SIBI: Sell Side Imbalance Buy Side Inefficiency
OF: Order Flow
AD: Accumulation y/o Distribution
AMD: Accumulation, Manipulation and Distribution
OHLC: Open, High, Low and Close

IRL: Internal Range Liquidity
ERL: External Range Liquidity
Fib: Fibonacci
OTE: Optimal Trade Entry
FV: Fair Value
SMT: Smart Money Tool / Technique
IOF: Institutional Order Flow
TS: Trailing Stop
KZ: Kill Zone
AR: Automatic Rally
ST: Secondary Test
SC: Selling Climax

BC: Buying Climax
BUEC: Backup to the edge of the creek
LPS: Last Point of Support
TR: Trading Range
JAC: Cross or Jump the creek
SOS: Sign of Strength
E/R: Effort versus Result
PS: Preliminary Supply
SOW: Sign of Weakness
LPSY: Last Point Of Supply

C/E: Law of Cause and Effect
S/E: Law of Supply & Demand
UTAD: Upthrust After Distribution
UT: Upthrust

✨ Let's learn the terms mostly mentioned on the web3!

tw: _luisald
website: Luis Lucena
contribution:
ETH address: luislucena.eth

Browser-Game with Solidity, JS, BSC, NodeJS, Hardhat , Chainlink

Luis Lucena — Tue, 08 Feb 2022 01:19:03 +0000

The Crypto Purge 💸

The most revolutionary crypto shooter-survival real-time NFT-based game on Binance Smart Chain.

Inspiration

The Crypto Purge is a crypto shooter-survival real-time NFT-based game inspired by The Purge (an American dystopian action horror film).

What it does

Players will have multiple modes to play the game, single and multiplayer. Single mode includes killing zombies and social ranking with friends for earn prizes, the top scorers on the leaderboard will split the prize pool grant. Multiplayer mode allows players to contribute a certain amount of tokens to the prize pool before each game and the prize pool is split by Smart Contracts and a Server Side authority between the winners of the game. The game allow users to mint custom skins with NFTs to be used in the game (Chainlink VRF and Oracles to assign provably rare traits). Player will differ in appearance and style, but they will have no effect on the game mode. All players will have an equal change of winning the game.

How we built it

The Crypto Purge has a crypto integrated backend that runs on Binance Smart Chain. Smart contracts are responsible for prize pool redistribution and web3.js (Metamask, etc) takes care of the wallet connection. We built the app using ReactJS, Phaser Framework, Hardhat with Chainlink Oracles for smart contracts development and NodeJS with Express Framework using Socket.io for real-time connections.

Challenges we ran into

Creating a decentralized real-time game that requires a back-end connection using WebSockets is the most challenging part of the project, additionally because "don’t trust the player. Always assume the worst – that players will try to cheat", so it requires an authority server to create a cheat-proof architecture as cheating players tends to drive the players away from the game, therefore the core problems are human nature and physics.

Developing an authoritative server architecture introduce a whole new class of challenges; Client-Side Prediction, Server Reconciliation, Entity Interpolation, Lag Compensation dealing with networks and scaling the system itself.

Accomplishments that we're proud of

We're proud to have created the real-time connection of the game, creating the smart contracts of the platform and the base architecture of the project; front-end, back-end and the smart contracts development using Hardhat with Chainlink Oracles.

What we learned

We learned about Blockchain, Smart Contracts, NFTs, Chainlink Oracles, 2D Games with WebGL/Canvas using Frameworks like PhaserJS, Physics, Real-time connections with WebSockets, Crypto wallets and much more!

What's next for The Crypto Purge

Allow gamers to edit their profile.
Open Marketplace to buy and mint custom skins.
Allow gamers to mint weapons and other assets.
Allow gamers to have an inventory.
Add a better configuration for the monorepo and create a Docker image with the configuration to run the project anywhere.
Use Microservices strategy for complex calculations and horizontal scaling, To infinity and beyond!
Share the end results and inspire others with Open Source contributions.

Built With
alchemyapi,blockchain,canvas,chainlink,css3,ethers,express.js,github,hardhat,heroku,html5,javascript,phaser.js,react,socket.io,solidity,web3,webgl

GitHub repo

Made with ❤️ by Luis Lucena and J.D Nicholls

Twitter: Luis Lucena and J.D Nicholls

What are MetaMask "Accounts" or "Sub-Accounts"? And why are they not as private as they are supposed to be?

Luis Lucena — Mon, 07 Feb 2022 00:15:34 +0000

When a wallet is created in Metamask, the famous seed phrase (or seed phrase) is generated, which are 12 words that must be stored securely. This seed phrase is generated by the BIP39 standard (BIP = Bitcoin Improvement Proposals). They come from a list of 2048 words.

Each of these words corresponds to a number, so the 12 words are actually equivalent to 12 numbers, which it is important that they are in order.

Based on the 12 numbers (seed integer) and using the SHA256 hash function, a private key is generated. Then the public key corresponding to the private key is derived using the ECDSA (Elliptic Curve Signature Algorithm).

Finally, the previously derived public key is hashed with the keccak256 hash function and from the resulting hash the last 20 bytes are taken, a 0x is added in front and this results in your Ethereum address.

Let's say to sum it up, the flow goes something like this:
Seed phrase > Seed integer > SHA256 > Private Key > ECDSA > Public Key > keccak256 > Last 20 bytes + 0x > Your Ethereum address🤓

Then the password with which you configure MetaMask is used to encrypt the private key on the device (browser or cell phone). This is why it is VERY important not to set a basic password, because if the key store file is stolen, they will be able to crack it easily and empty your wallet

So far it's all very nice and quite simple. This address created is your "Default account" or the first account or address you see created in MetaMask as soon as you generate it or import the seed phrase.

Then let's remember that MetaMask allows us to create N "Accounts" or "sub accounts" or "address". These accounts are all controlled by the same seed phrase but each one has its own address and therefore its own public key and private key.

To create these sub-accounts, MetaMask takes the private key of Account 1, hashes it, and from this hash function comes Account 2. It then hashes Account 2 to generate Account 3 and so on N times. Each account is the resulting hash of the previous account.

As each Account has its own address and therefore its own public and private key (and they were generated by hashing each one from the previous one), the different addresses or accounts cannot "IN PRINCIPLE" be linked by someone who does not know the private key

This means that although I control N address, nobody could know that they are all controlled by the same wallet, so this is supposed to be a mechanism that gives some privacy, since I can have different wallets for each thing and nobody knows that they are all mine.

Before we go on, let's remember: each wallet has 1 seed phrase and with this seed phrase controls N amount of address which each one has its own private key and its own public key.

All very nice and very secure at cryptographic level, BUT (there is always a but) the system has a flaw (flaw for us who want privacy, feature for those who want to investigate us Woman detective)

Every time we install MetaMask, the app defines an API TOKEN (an identifier) that the app is going to use to connect to the Ethereum node you use (Infura by default) to bring the balance data and do the balanceOf() and to relay the transaction.

So if you have address A, address B and address C, the RPC node you use sees that the transactions going out of the 3 addresses all use the same API TOKEN (also called API KEY) and therefore knows that all 3 belong to the same wallet.

In addition to this, the nodes can save the IP (by default it is a data that is discarded, but not all do it clearly), but this is something that is quite well known so many assume that by changing the IP via VPN every time you go to operate with another address you were ok.

What can we do about it? Every time we are going to make a new transfer from a different address we have to uninstall Metamask and reinstall it, so the API key is reset. Besides changing our IP obviously, with a VPN.

The other solution is to have our own node and interact from our wallet directly with it, this way we make sure that the node we operate against is not storing any of this data that can link the addresses.

Many will think it's too convoluted, but this is one of the mechanisms used by companies doing on-chain analysis to identify everything from funds originating from hacks to following traces of individuals and organizations seeking privacy.

It does not come to the point of the thread but since we are, another mechanism is to track via cookies and browser extensions, which are the addresses we are looking for in browsers, thus linking the addresses and "inferring" that they are of the same owner

Sources:
https://t.co/ZBSBWI2Psk
https://t.co/oBZTY6TJyJ
https://t.co/wLhQPXYvlj

I hope you found it interesting, ideas and criticisms are welcome❤️❤️