In this hands-on course grounded in first-principle thinking, you will learn to develop and deploy probabilistic play-to-earn games from scratch in Solidity.

data.tar.gz

Ethereum

Default

Solidity is a high-level programming language used for implementing smart contracts. Solidity is widely-used in developing Play-to-earn (P2E) games. P2E are NFT-gated games on the blockchain, where players can earn cryptocurrency and prizes that have real-world value. The ability to make these games is currently one of the most sought-after skills among blockchain developers.

In this course, you will be introduced to Solidity and the fundamentals of the Ethereum network. This course also gives a preliminary introduction to blockchains so users who don’t have any prior knowledge of it can brush up on their concepts—to assist them in developing and deploying P2E smart contracts in Solidity. Next, this course will also address a few technical challenges that P2E games present. 

By the end of this course, you will be able to create and deploy your own P2E game on an Ethereum test network.

Developing Play-to-Earn Games in Solidity

In the following contract, what would be the initial value of the `z` variable?
```
pragma solidity >=0.5.0 <0.9.0;
contract exampleBooleans {
 bool x;
 bool y = true;
 bool public z = !x || !y;
}
```

In the following contract, what would be the initial value of the <code>z</code> variable?
<pre><code>pragma solidity &gt;=0.5.0 &lt;0.9.0;
contract exampleBooleans {
 bool x;
 bool y = true;
 bool public z = !x || !y;
}
</code></pre>

The `myAddress` variable has `internal` visibility.

The `address` type has to be explicitly converted to `address payable`.

We did not specify the right compiler version.

The `address(this)` variable is undefined at this point.

Why does the following contract result in a compilation error?

```
pragma solidity >=0.5.0 <0.9.0;
contract exampleAddress {
 address payable internal myAddress = address(this);
}
```

Why does the following contract result in a compilation error?
<pre><code>pragma solidity &gt;=0.5.0 &lt;0.9.0;
contract exampleAddress {
 address payable internal myAddress = address(this);
}
</code></pre>

Records a list of addresses that called the `mysteryFunction()`

Verifies whether a user holds at least 100,000,000,000,000,000 ETH and records their address if so.

Verifies whether a user holds at least 100,000,000,000,000,000 ETH and records a timestamp if so.

Verifies whether a user holds at least 0.1 ETH and records a timestamp if so.

What does the following contract do?

```
pragma solidity >=0.5.0 <0.9.0;
contract mysteryContract {
 uint constant 
 threshold=100000000000000000;
 mapping(address =>uint) record;

 function mysteryFunction() public {
 if (msg.sender.balance>threshold {
 record[msg.sender]=block.timestamp; 
 }
 }
}
```

What does the following contract do?
<pre><code>pragma solidity &gt;=0.5.0 &lt;0.9.0;
contract mysteryContract {
 uint constant 
 threshold=100000000000000000;
 mapping(address =&gt;uint) record;

 function mysteryFunction() public {
 if (msg.sender.balance&gt;threshold {
 record[msg.sender]=block.timestamp; 
 }
 }
}
</code></pre>

What are the respective values of the `num` variables in the `Callee` and `Caller` contracts of the following code, after executing the `exampleCall()` function once?

```
pragma solidity >=0.5.0 <0.9.0;

contract Callee {
 uint public num;
 function increment() external 
 returns (uint) {
 num++; 
 return num;
 }
}

contract Caller {
 event callMade(address _caller, 
 bool _sent, bytes _data);
 uint public num;

 function exampleCall(address _callee) public { 
_callee.call(abi.encodeWithSignature("increment()"));
_callee.delegatecall(abi.encodeWithSignature("increment()"));
 }
}
```

What are the respective values of the <code>num</code> variables in the <code>Callee</code> and <code>Caller</code> contracts of the following code, after executing the <code>exampleCall()</code> function once?
<pre><code>pragma solidity &gt;=0.5.0 &lt;0.9.0;

contract Callee {
 uint public num;
 function increment() external 
 returns (uint) {
 num++; 
 return num;
 }
}

contract Caller {
 event callMade(address _caller, 
 bool _sent, bytes _data);
 uint public num;

 function exampleCall(address _callee) public { 
_callee.call(abi.encodeWithSignature(&quot;increment()&quot;));
_callee.delegatecall(abi.encodeWithSignature(&quot;increment()&quot;));
 }
}
</code></pre>

```
if (holdsNFT[msg.sender] && msg.sender.balance>0 && msg.value>0 ){}
```

```s
if (msg.sender.balance>0 && holdsNFT[msg.sender]   && msg.value>0 ){}
```

```s
if (msg.sender.balance>0 && msg.value>0 && holdsNFT[msg.sender]){}
```

```s
if (holdsNFT[msg.sender] && msg.value>0  ){}
```

What is the most gas-efficient way to rewrite a conditional verifying that: `msg.sender` holds a non-zero balance and a very expensive NFT via a `mapping(address => bool) holdsNFT` and has sent a non-zero amount of ETH to the contract?




What is the most gas-efficient way to rewrite a conditional verifying that: <code>msg.sender</code> holds a non-zero balance and a very expensive NFT via a <code>mapping(address =&gt; bool) holdsNFT</code> and has sent a non-zero amount of ETH to the contract?

Let’s practice what we've learned so far.

Let’s practice what we’ve learned so far.

Quiz yourself on Solidity smart contract structure and syntax

Introduction

Ethereum Fundamentals

Solidity Smart Contract Structure and Syntax

Inheritance

Off-Chain Oracles

Putting it All Together: The Treasure Hunt Game

Conclusion

Quiz: Solidity Smart Contract Structure and Syntax