CBDE BTA Certified Blockchain Developer - Ethereum Questions and Answers

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.

To Protect the Public Keys by being cryptographically significant.

To Sign Transactions And To Derive an Address From.

To Generate An Address which can sign transactions.

can never become a mining node.

can always become a mining node.

can become a mining node, depending if the implementation has the functionality implemented.

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 automatically a 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.

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.

working with either // or ///

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

not possible, all comments must be multi-line.

works across all compilers and platforms the same way.

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

to move all existing logic to the blockchain, so everything runs on the same system. This way it might be more complex, but easier to maintain.

to move only those parts to the blockchain that really need the blockchain. This way smart contracts can be easier to read, easier to test and are not so complex.

to move those parts to the blockchain that deal with Ether transfers. All other parts can remain in traditional database systems. This way only the value-transfer is on the blockchain.

is a must for every developer, because Web3.js changes so often.

is a convenient way because Web3.js is currently still in beta and truffle-contract can handle transactions with JavaScript-promises.

they are both completely different things. Truffle-Contract is a framework while Web3.js is a library.

it’s good to use a push over a pull method.

it’s good to use a push and a pull method to ensure that participants can get their money no matter the contract state. In addition to and pushing it should contain a withdraw method.

it ' s good to use only pull and no push method.

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.

to bytecode that can ' t be understood by humans.

to bytecodes which are essentially opcodes running instruction by instruction.

is determined by the Ethereum Committee every fortnight to reflect the average amount of transaction and it cannot be influenced by the network itself.

increases when the time between mined blocks is below 10 seconds, while it decreases when the time is above 20 seconds.

increases when the time between mined blocks is below 20 seconds, while it decreases when the time is above 60 seconds.

.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.

Wei, Finney, Szabo, Ether, Tether.

Finney, Szabo, Mether, Gwei.

Gwei, Szabo, Finney, Ether.

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.

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

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

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.

by the miner nodes which make sure that a transaction is valid.

by every single node in the blockchain network executing the same transaction.

by a cryptographic secure signature algorithm called ECDSA which makes sure that cheating is impossible.

are changing their address every time a Transaction is sent because of the nonce.

are keeping their address, but on the blockchain a nonce is increased every time they send a transaction to avoid replay attacks.

it would be best to start from scratch, just looking at the required interface.

it is beneficial to copy and paste the already existing code from the Ethereum wiki and modify this until you like it.

best is to start with an audited implementation, for example from OpenZeppelin, in order to reuse already existing code.

can help to engage the community in testing your smart contracts and therefore help to find bugs early.

might be a burden as it is an administrative overhead mainly.

is completely useless. Who wants to test beta-ware software? It’s better to start with the bug-bounty program after the contract is released on the main-net.

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.

the amount of gas your contract deployment and transactions, against your contract, will need. This way you can essentially lower the gas costs over traditional web3.js dApps.

different Networks to deploy your contracts to. This way you can easily deploy to a local blockchain, the main-net or the Ropsten/Rinkeby Test-Net with only one parameter.

you can manage your secret API keys to the Ethereum Network. This way you can get access to several different Ethereum nodes at the same time without the need to switch your keyfiles.

always having the same signature.

having a different signature because of the nonce which changes upon every transaction.

can be destroyed using the selfdestruct keyword. This way all remaining ether will be sent to the receiver address, regardless if they have a fallback function or not.

are bound to a private key which is necessary to sign transactions outgoing from that account.

are logical opcodes running on the ethereum blockchain very similar to smart contracts.

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.