This reverts commit 7f1a2be0fe.
Added changes to changelog to include Make basfee as a reserved identifier
added changes under the breaking changes rst file
Update Changelog.md
Co-authored-by: Harikrishnan Mulackal <webmail.hari@gmail.com>
Update 090-breaking-changes.rst
moved the changes under "New restrictions" section
Update Changelog.md
avoided removing line no 6
Update docs/090-breaking-changes.rst
Co-authored-by: Alex Beregszaszi <alex@rtfs.hu>
The docs state that a plain `address` cannot be sent Ether. But even though `send` and `transfer` members are not available for plain `address`, the `call` is. And `call` can be invoked upon a plain `address` type to send Ether to the address.
For instance, the `someone` (`address` type) can be sent Ether by invoking `sendSomeone()` method in the following `Dummy` contract:
```
contract Dummy {
address someone = 0xAb8...cb2;
function balanceOf(address addr) public view returns (uint) {
return addr.balance;
}
function sendToSomeone() public payable returns (bool) {
(bool sent, ) = someone.call{value: msg.value}("");
return sent;
}
}
```
At this point of the documentation a new Solidity learner will not understand this line without further explanation:
if (!payable(msg.sender).send(amount)) {
It should explain how msg.sender is of type "address" and not "address payable" so it cannot send or receive Ether. Therefore it must be explicitly converted to payable.
I'm learning Solidity by reading these docs and found this statement confusing. I'm fairly certain that the correct description here is that the *callee* changes get reverted, but the caller is able to react to the failures.
I tested this with the following snippet in Remix, which resulted in a successful transaction when deployed:
```
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.7;
contract A {
uint public value;
function a(uint newValue, bool shouldRevert) external {
value = newValue;
if (shouldRevert) {
revert();
}
}
}
contract B {
function b() external {
A a = new A();
try a.a(50, false) {
assert(a.value() == 50);
} catch {
assert(false);
}
a = new A();
try a.a(50, true) {
assert(false);
} catch {
assert(a.value() == 0);
}
}
}
```
Added the specificity that bytes1[] and bytes differ because of padding only in memory data location. Added extra sentence that they are similar when used in storage data location.
