mirror of
https://github.com/LeCoupa/awesome-cheatsheets.git
synced 2026-01-27 13:48:01 -08:00
221 lines
10 KiB
Solidity
221 lines
10 KiB
Solidity
/* *******************************************************************************************
|
|
* Defining Licensing of the smart contract =>
|
|
******************************************************************************************** */
|
|
|
|
// SPDX-License-Identifier: MIT
|
|
// List of allowed SPDX licenses to use => https://spdx.org/licenses/
|
|
|
|
/* *******************************************************************************************
|
|
* Defining solidity compiler(solc) version for compiling the smart contract =>
|
|
- Some possible ways to use:
|
|
- pragma solidity 0.8.0; ==> compiler version set exactly on 0.8.0 version
|
|
- pragma solidity ^0.8.0; ==> compiler version set above 0.8.0 version and lower than 0.9.0 version
|
|
- pragma solidity >= 0.7.0 < 0.9.0; ==> compiler version set equal or above 0.7.0 version and lower than 0.9.0 version
|
|
******************************************************************************************** */
|
|
|
|
pragma solidity ^0.8.0;
|
|
|
|
/* *******************************************************************************************
|
|
* Creating the smart contract => contract ContractName {}
|
|
|
|
- Note: Contracts are like classes in other programming languages.
|
|
- Note: Naming convention is like this for declaring contract: MyContract
|
|
|
|
******************************************************************************************** */
|
|
contract HelloWorld {
|
|
/* *******************************************************************************************
|
|
|
|
* Data types:
|
|
* 1) Value types:
|
|
- Value stored in smart contract storage slot
|
|
- bool
|
|
- int
|
|
- uint
|
|
- address
|
|
- bytes1 ... bytes32
|
|
- enum
|
|
|
|
* 2) Reference types:
|
|
- A reference to a stored value in smart contract storage slot will be set
|
|
- array
|
|
- string
|
|
- mapping
|
|
- struct
|
|
- bytes
|
|
|
|
******************************************************************************************** */
|
|
/* *******************************************************************************************
|
|
|
|
* Variable types:
|
|
* 1) State variables => Variables which
|
|
- Get permanently stored on blockchain(smart contract storage)
|
|
- Use most gas usage in smart contracts
|
|
- Accessible on whole smart contract
|
|
|
|
* 2) Local variables => Variables which
|
|
- Not stored on blockchain
|
|
- Use less gas in smart contracts
|
|
- Are living and working just in function body
|
|
|
|
* 3) Global variables => Variables which
|
|
- Provide information about the blockchain
|
|
- Can be used both as state variables and local variables
|
|
- Mainly used to determine contract owner and checking time
|
|
******************************************************************************************** */
|
|
/* *******************************************************************************************
|
|
|
|
* Visibility:
|
|
* 1) Variables:
|
|
- public
|
|
- private
|
|
- internal
|
|
|
|
* Ex: uint public number;
|
|
|
|
- Note: visibility is just for state variables and not applicable on local variables
|
|
- Note: default visibility of a state variable is(if we don't declare visibility scope) --> internal
|
|
- Note: if declare a variable to have 'public' scope, automatically a 'getter function' will be created for that variable
|
|
|
|
* 2) Functions:
|
|
- public
|
|
- private
|
|
- internal
|
|
- external
|
|
|
|
* Ex: function setNumber() public {}
|
|
|
|
******************************************************************************************** */
|
|
/* *******************************************************************************************
|
|
|
|
* Function types:
|
|
* 1) Non-Payable => Functions which
|
|
- Write on the blockchain
|
|
- Are our default functions type
|
|
- Are not able to accept deposits on the smart contract
|
|
|
|
* Ex: function setNumber() public {}
|
|
|
|
* 2) View => Functions which
|
|
- Are able to show us data
|
|
- Read from blockchain
|
|
|
|
* Ex: function setNumber() public view {}
|
|
|
|
* 3) Pure => Functions which
|
|
- Neither read nor write on blockchain
|
|
- Just do a specific work for us (ex: making sum of 2 numbers and returning back the value)
|
|
|
|
* Ex: function setNumber() public pure {}
|
|
|
|
* 3) Payable => Functions which
|
|
- Are able to accept Ether deposits on the smart contract
|
|
|
|
* Ex: function setNumber() public payable {}
|
|
|
|
******************************************************************************************** */
|
|
/* *******************************************************************************************
|
|
* Constructor => A function which
|
|
- Is optional
|
|
- Does not have a name
|
|
- Does not have visibility scope
|
|
- Executed during contract deployment
|
|
- Can take parameters while deploying
|
|
- Initializes smart contract state variables
|
|
- Will be at most 1 within each smart contract
|
|
- Can have payable attribute associatede with it
|
|
|
|
* Ex: constructor(uint _number) { number = _number; }
|
|
******************************************************************************************** */
|
|
/* *******************************************************************************************
|
|
* Data Locations =>
|
|
* Each variable declared and used in a contract has a data location:
|
|
- Storage:
|
|
- global memory available to all functions within a contract.
|
|
- oermanent storage that Ethereum stores on every node.
|
|
- Memory:
|
|
- local memroy available to every function within a contract.
|
|
- short living in functions.
|
|
- Calldata:
|
|
- where all incoming function execution data is stored(including function arguments)
|
|
- non-modifiable memory location(note: similar to memrory location, except it is not modifiable)
|
|
- Stack
|
|
- a stack which is maintained by EVM(Etheereum Virtual Machine) for loading variables and
|
|
intermediate values for working with Ethereum instruction set(the working set memory for the EVM).
|
|
- max limit is 1024 levels, and exceeding this limit(by storing anything more than that), raises an exception.
|
|
|
|
- Note: data location of variable, is dependent on:
|
|
- Location of the variable declaration
|
|
- Data type of the variable
|
|
- Note: We face them mostly, when are working with reference type variables.
|
|
|
|
******************************************************************************************** */
|
|
/* *******************************************************************************************
|
|
* Events =>
|
|
- Used for logging(like other languages)
|
|
- Used to notify applications about changes in contracts
|
|
- can be used to "call" JavaScript callbacks in the user interface of a dapp
|
|
- Primarily for informing the calling application about the current state of the contract
|
|
- Declared with 'event' keyword
|
|
- Firing them with 'emit' keyword
|
|
|
|
- Note: Events can be declared anonymous.
|
|
- Note: Events can have 'indexed' keyword in variable declaration(to make easier filtering of some specific data)
|
|
|
|
* Ex: event EventName(address sender,uint number)
|
|
* emit EventName(address(0), 10)
|
|
|
|
******************************************************************************************** */
|
|
/* *******************************************************************************************
|
|
* Error handling =>
|
|
* 1) Require
|
|
- Check a condition,
|
|
if true => go to next line codes,
|
|
if false => show a string message and revert to privious state
|
|
- Refund remaining gas to the caller
|
|
|
|
- Note: Use require conditions, all at beginning the function.
|
|
|
|
* Ex: require(number >= 10, "number must be greater than 10");
|
|
|
|
* 1) Revert
|
|
- Similar to require, but can have more complex conditions
|
|
- Refund remaining gas to the caller
|
|
|
|
* Ex: if(number <= 10) { revert("number must be greater than 10"); }
|
|
|
|
* 1) Assert
|
|
- Mainly used in writing contract tests
|
|
- Don't refund remaining gas to the caller
|
|
|
|
|
|
* Ex: uint number = 123;
|
|
* assert(number == 10);
|
|
|
|
******************************************************************************************** */
|
|
/* *******************************************************************************************
|
|
* Enum =>
|
|
- A user defined data type
|
|
|
|
* Ex: enum OrderStatus { pending, accepted, completed, rejected};
|
|
* OrderStatus order = OrderStatus.accepted;
|
|
|
|
******************************************************************************************** */
|
|
/* *******************************************************************************************
|
|
* Mapping =>
|
|
* Declaration: `mapping(_KeyType => _ValueType) mappingName`
|
|
- Mappings are like **Dictionary** or **hash table** which are virtually initialized
|
|
such that every possible key exists and is mapped to a specific value.
|
|
- Note: **key** can be any type which EVM internally knows about it(exceptions are: a dynamically sized array, a contract, an enum, or a struct.
|
|
- Note: **value** can actually be any type, including mappings.
|
|
|
|
******************************************************************************************** */
|
|
/* *******************************************************************************************
|
|
|
|
* Struct
|
|
* Somehow we can pack some data types(and ofcourse data values) of an specific entity with structs:
|
|
|
|
* Ex: struct UserInfo { string fName; string lName; uint8 age; address wallet;}
|
|
* UserInfo user;
|
|
******************************************************************************************** */
|
|
}
|