Files can be imported:

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.

Importing from GitHub:

is generally possible, but currently works only in Remix, but doesn't work in Truffle.

works across all compilers and platforms the same way.

is generally possible, but currently works only in Remix, but doesn't work in Truffle.

Single line comments in Solidity are:

working with /* comment */ or /** @.. natspec style */

not possible, all comments must be multi-line.

Multi-Line Comments in Solidity are:

working with /* comment */ or /** @.. natspec style */

not possible, all comments must be single-line.

The following are value types in Solidity.

Integer, Boolean, Enum and Addresses.

Integer, Boolean, Struct, Mapping and Enum.

Integer, Boolean, Enum and Addresses.

Integer, Boolean, Structs and Fixed Point Numbers.

To compare a String in Solidity you use:

you can't directly compare two strings, but one method would be to hash both strings and compare the hashes.

the internal function "str_compare(str1,str2)"

you can't directly compare two strings, but one method would be to hash both strings and compare the hashes.

bytes32(string1) == bytes32(string2)

If we divide two integers:5/2, the result is:

2, because the decimal is truncated.

3, because it's always rounded.

2.5, because it's automatically converted into a float.

AStruct is a great way:

to define a new datatype in Solidity, so you don't need to use objects of another contract.

to hold instances of other contracts.

to implement pointers to other contracts that can hold new datatypes.

A Mapping consists of keys and value.

the value can be anything, but the key cannot be another mapping, struct, enum or dynamically sized array.

the Keys can be anything, but the value can't be another mapping or struct.

the Value can be anything, but the key cannot be another mapping, struct, integer or Boolean.

the value can be anything, but the key cannot be another mapping, struct, enum or dynamically sized array.

To Iterate through a mapping, you:

you need an external helper variable.

can use the length parameter of the mapping.

you need an external helper variable.

you cannot iterate any mapping to make the overall language design more safe.

Function and Variable Visibility:

a function that is marked as internal cannot be called by other contracts, unless the function is used by a derived contract. Private Functions cannot be called by any other outside contract and public variables are generating automaticallya getter function.

a function that is marked as external can never be called internally. Private functions can also be called by derived contracts using inheritance. Private variables are accessible also in derived contracts.

View and Pure Functions:

a view function can access state variables, but not write to them. A Pure function cannot modify or read from state.

a function marked as pure can change the state, while a view function can only return static calls.

a function marked as view can never access state variables, while pure functions are here to return only one value.

a view function can access state variables, but not write to them. A Pure function cannot modify or read from state.

View and Pure Functions:

can be accessed during transactions and calls.

can only be accessed during calls.

can be accessed during transactions and calls.

The Fallback function:

can contain as much logic as you want, but it’s better to keep it short and not exceed the gas stipend of 2300 gas.

cannot receive Ether, not even by adding the payable modifier.

can contain as much logic as you want, but it’s better to keep it short and not exceed the gas stipend of 2300 gas.

can be used to avoid receiving ether.

are dangerous when used with data structures that grow, such as arrays or mapping, because it is hard to estimate the gas requirements.

are a great way to circumvent gas requirements, because a loop will only consume gas once.

are dangerous when used with data structures that grow, such as arrays or mapping, because it is hard to estimate the gas requirements.

should be avoided where possible, because of unknown side-effects on the gas requirements.

are stored in something like a side-chain and cannot be accessed by contracts.

are stored on chain and are a great way to get a return value when a contract calls another contract.

are stored in something like a side-chain and cannot be accessed by contracts.

are used primarily for debugging exceptions in solidity.

According to the official Style Guide:

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.

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 version pragma is a great way to make it clear:

for which compiler version a smart contract was developed for. It helps to avoid breaking changes.

for which blockchain a smart contract was developed for. It helps to avoid confusion with beta-customers.

for which blockchain node a smart contract was developed for. It helps to avoid mixing up different versions of go-ethereum.

Variables of the type address store:

a 20 characters long hex number

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

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

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

Address.call.value():

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

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.

Address.send() and address.transfer() are considered:

dangerous because they send all gas along, it's better to use address.call.value()().

safe against reentrancy because of the small gas stipend of 2300 gas.

dangerous because they send all gas along, it's better to use address.call.value()().

When defining a new datatype:

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

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.

What's the difference between Ethereum Request for Comments (ERC) and Ethereum Improvement Proposals (EIP)?

ERC are here to define standards for the usage of Ethereum. EIP are here to improve the Ethereum Protocol itself.

ERC are here to propose new distributed applications on top of the Ethereum layer, while EIP are here to improve existing mining software.

ERC are an open platform to discuss continuous forking of the Ethereum platform. Successful forks are then incorporated in the EIP for further voting by the Ethereum Consortium.

What is the difference between ERC20 and ERC721 Tokens in simple terms?

The tokens of a certain ERC20 symbol are all the same, the tokens of an ERC721 symbol are all different. So, ERC20 tokens are fungible, while ERC721 tokens are non-fungible.

The tokens of a certain ERC20 symbol are all different, the tokens of an ERC721 symbol are all the same. So, ERC20 tokens are non-fungible while ERC721 tokens are fungible.

In order to implement an ERC20 token contract, you'd need at least to implement the following functions and events in order to fulfill the interface requirements:

totalSupply(), balanceOf(address), allowance(address,address), transfer(address,uint256), approve(address,uint256), transferFrom(address,address,uint256). Events: Transfer(address,address,uint256), Approval(address,address,uint256)

name(), symbol(), totalSupply(), balanceOf(address), ownerOf(uint26),approve(address,uint256), takeOwnership(uint256),transfer(address,uint256),Events: Transfer(address,address,uint256), Approval(address,address,uint256)

Why is it important to follow the same Interfaces?

Websites that try to interface with the Token would have to know the exact ABI. It is upfront clear how the interaction has to be with the standard Interfaces.

The Ethereum Foundation can easily validate the Tokens and approve any audits by following the standard interface.

If contract MyContractA is derived from Contract MyContractB, then this would be the right syntax:

contract MyContractA is MyContractB { … }

contract MyContractA inherit (MyContractB) {…}

contract MyContractA extends MyContractB {…}

contract MyContractB derives MyContractA {…}

Inheritance is useful, because a contract that is derived from another contract can make use of:

all public state variables and properties, public and internal functions and modifiers.

all public and private state variables, public, internal and external functions, but not modifiers

all public state variables and properties, public functions and modifiers, but not internal, external or private ones.

Finish the sentence: TheLibrary Web3.js is …:

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.

When solidity is compiled then also Metadata is generated:

the Metadata contains the ABI Array, which defines the Interface to interact with the Smart Contract. Metadata can also contain the address of the smart contract when it gets deployed.

metadata contains the address, and the size of the smart contract. The ABI Array is generated externally upon deploying the smart contract.

the ABI array and the Metadata are not generated when solidity is compiled to bytecode, its generated by a migration software which deploys the smart contract on the blockchain.

The difference between address.send() and address.transfer() is:

.send returns a Boolean and .transfer throws an exception on error. Both just forward the gasstipend of 2300 gas and are considered safe against re-entrancy.

.send throws an exception and .transfer returns a Boolean on error. Both just forward the gasstipend of 2300 gas and considered safe against re-entrancy

.send returns a Boolean and .transfer throws an exception on error. .send is considered dangerous, because it sends all gas along, while .transfer only sends the gas stipend of 2300 gas along

.send and .transfer are both considered low-level functions which are dangerous, because they send all gas along. It's better to use address.call.value()() to control the gas-amount.

All low-level functions on the address, so address.send(), address.call.valueQQ, address.callcode and address.delegatecall:

returning Booleans to indicate an error during execution.

are interrupting execution on error, because they throw an exception.

continuing execution on error silently, which is the reason why they are so dangerous.

returning Booleans to indicate an error during execution.

.send() throws an exception, while the other functions are returning Booleans during execution to indicate an error.

To send ether to a contract without a function call:

a fallback function must be declared and it must be made payable. If there is no fallback function or the fallback function is not payable it will throw an exception.

either a fallback function which is payable exists, or no fallback function at all exists.

you cannot send ether to a contract without explicitly calling a function. The fallback function can never receive ether.

Using selfdestruct(beneficiary) with the beneficiary being a contract without a payable fallback function:

it's impossible to secure a contract against receiving ether, because selfdestruct will always send ether to the address in the argument. This is a design decision of the Ethereum platform.

will throw an exception, because the fallback function is non-payable and thus cannot receive ether.

it's impossible to secure a contract against receiving ether, because selfdestruct will always send ether to the address in the argument. This is a design decision of the Ethereum platform.

selfdestruct doesn't send anything to a contract, it just re-assigns the owner of the contract to a new person. Sending ether must be done outside of selfdestruct.

Blockchain CBDE Practice Test 2 - Free Online Exam Prep & Questions

Question 1 / 40

Solidity files:

can't be split across multiple files, everything should be in one single file.

can be split across multiple files, but every contract must be in a file with the same name as the contract itself.

can be spread across multiple files. To import all contract from a file you can use "import 'myfile.sol'. To import Contract MyContract from myfile.sol you use "import {MyContract as SomeContract} from 'myfile.sol';".

Comment (0)

Blockchain CBDE Practice Test 2

Question

Blockchain CBDE Practice Tests

Practice Tests