CBDE BTA Certified Blockchain Developer - Ethereum Questions and Answers

Address.call() is used for calling other contracts using the scope of the called contract in terms of storage variables. Address.delegatecall() is used for libraries, which uses the storage variables of the contract who called. Libraries are a great way to re-use already existing code and delegatecall can make sure that no storage is used from the library, instead it looks like the code is directly copied into the calling contract.

Address.delegatecall() is used for calling other contracts using the scope of the called contract in terms of storage variables. Address.call() is used for libraries, which uses the storage variables of the contract who called. Libraries are a great way to re-use already existing code and call() can make sure that no storage is used from the library, instead it looks like the code is directly copied into the calling contract.

sends the gas stipend of 2300 gas and returns a false on error.

sends all the gas along and cascades exceptions.

sends all the gas along and returns a false on error.

sends the gas stipend of 2300 gas and cascades exceptions.

using relative and absolute paths, where the "." And the ".." depict that it's a relative path.

only via GitHub using the Repository and Username.

using the special requirefile(...) statement, which looks in a specific library path to import files.

must implement the Ethereum protocol and external access can only be done via the proprietary Ethereum Libraries like Web3.js.

must implement the Ethereum Protocol and a JSON-RPC to talk with clients.

must implement Web3.js to interact with Websites.

its best to use a contract with public storage variables, so it can be used like a class.

it's best to use a struct, which is cheaper than deploying a new contract.

it's not possible to generate new datatypes in Solidity.

both are the same, just implemented in a different language.

with Go-Ethereum you get a real blockchain node where you can create your own local private network, connect to Test-Networks or the Main-Net, while with Ganache you get an in-memory blockchain simulation.

with Ganache you get a real blockchain node where you can connect to the Test-Networks Rinkeby and Ropsten.

useful when developing distributed applications with HTML and JavaScript, because it already implements the abstraction of the JSON-RPC interface of Ethereum Nodes.

necessary when developing distributed applications with HTML and JavaScript, because the proprietary JSON-RPC interface of Ethereum Nodes is a closed source.

with private state variables. This way nobody else other than the smart contract itself can see the information

with external contracts holding those values. This way we can make sure that the information flow is following a clear logic and nobody else can access this information.

You can't hide anything on the blockchain, because the information is public, just the call is private which means only other smart contracts would be limited in accessing that information.

to check internal states that should never happen.

to check input arguments from users.

you should capitalize function names, events and contract names, to avoid confusion with JavaScript. You should use Tabs to indentation and a maximum of 80 characters per line.

contract names should be capitalized, while functions should be mixedCase. You should use 4 spaces as indentation and a maximum of 79 (or 99) characters per line.

contract should be mixedCase, as well as function names. Events should be capitalized. 2 spaces should be used as indentation and a maximum of 120 characters per line.

a 20 bytes value

a 32 bytes value

a string

a 20 characters long hex number

will cascade exceptions and address.transfer() will return a false on error.

will return false on error while address.transfer() will cascade transactions.