This second course of the Blockchain specialization will help you design, code, deploy and execute a smart contract – the computational element of the blockchain technology. Smart contracts allow for implementing user-defined operations of arbitrary complexity that are not possible through plain cryptocurrency protocols. They allow users to implement conditions, rules and policies of the domain applications. Smart contracts are a powerful feature that, when properly designed and coded, can result in autonomous, efficient and transparent systems. You will design and program smart contracts in Solidity language, test and deploy them in the Remix development environment, and invoke them from a simple web interface that Remix provides. This course features best practices for designing solutions with smart contracts using Solidity and Remix IDE. Main concepts are delivered through videos, demos and hands-on exercises.
Access Modifiers & Applications
Loading...
Do curso por University at Buffalo
Smart Contracts
209 classificações
Na lição
Solidity
Our goal is to master the basics of Solidity, a high-level language that is a combination of Javascript, Java and C++. It is specially designed to write smart contracts and to target the Ethereum Virtual Machine. Learners will be able to follow demonstrations and practice using Solidity.
Conheça os instrutores
Bina RamamurthyTeaching Professor
Computer Science and Engineering Department
Module two, lesson five: access modifiers and application-specific validation.
On completion of this lesson,
you will be able to explain usage of function modifiers,
explain the use of require clause for input validation,
illustrate the assert declaration for post-condition checking,
discuss reverting a transaction and revert function.
The main intent of smart contractor transaction is to execute a function.
However, smart contracts often require control over who or what can execute the function,
at what time a function needs to be executed and what
are the precondition to be met before getting access to the function.
It's a good practice to validate input values to
the function to avoid unnecessary execution and waste of gas.
If there are any errors found during the input validation,
these have to be handled appropriately.
At the end of the function execution,
you may want to assert that certain conditions are met
to ensure the integrity of the smart contract.
Let's begin with an important feature of solidity: modifiers.
They can address some of the concerns just mentioned.
Modifiers can change the behavior of a function,
that's why this feature is referred to as a modifier.
It is also known as a function modifier since it is specified at
the entry to a function and executed before the execution of the function begins.
You can think of a modifier as a gatekeeper protecting a function.
A modifier typically checks a condition using require.
And if the condition failed,
the transaction that called the function can be reverted and using the revert function.
This will completely reject the transaction and revert all its state changes.
There'll be no recording on the block chain.
Let's understand the modifier and require
clauses using the ballot smart contract functions.
We'll add a modifier only by chairperson to the register function.
We'll do that by these steps.
Define modifier for the clause only by chairperson,
adding a special notation,
underscore semicolon, to the modifier definition that includes the function,
using the modifier clause in the function header.
Step one is a definition of the modifier only by.
They allow only the chairperson who created
the smart contract ballot to register any new orders.
Step two shows how to make the modifier include a placeholder for any function.
Step three, use the modifier clause in the header of the function definition.
Now, let's change the existing if statement of the ballot smart
contract so that it reverse the transaction on input validation failure.
We don't need to waste block chain resources for a failed transaction.
Now, we'll illustrate assert using a function payoff that computes and pays off bits.
It is preferable that the assert not fail and that
requires checking the balance after every payoff in the above case.
We are making sure bank has the reserves of $10,000 after all the payoffs.
Under normal circumstance, assets should not fail.
This is more for handling an anomalous,
faulty, or malicious condition.
In this case, the exceptional condition is that,
bank balance somehow dipped below into reserves.
The picture summarizes all the features we discussed: modifiers and error handlers,
and where they are typically used.
The rules, laws, policies,
and governance conditions are coded as modifiers.
You can use the modifiers as gatekeepers for the functions.
If your transaction to invoke the function
does not meet the conditions specified at the header of the function,
your transaction will be reverted,
will not be recorded on the block chain.
Modifiers can be used to validate rules outside
the function such as described in
the opening of the lesson: who has access to the function,
at what time, and what condition?
Et cetera. Once these screening conditions are satisfied,
input validation can be carried out inside
the function using require declarative statement,
and in this case also,
the transaction will be reverted on failed validation.
This is done before the execution of the function.
There are anomalous, faulty,
malicious code that may result in unexpected situations or exception.
These can be caught usually at the end of
the function or sometimes within the function using
assert declarative statement and
the entire transaction including
the function execution and the state change will be reverted.
Here is an example of an online digital media bazaar.
Input condition as specified by a modifier is at least five sellers.
This enforces the condition that there should be at least five sellers with
their products before a buyer initiates a buy message through a transaction.
This is a global condition for all buyers.
So, it is appropriate to install it using a modifier declarative statement.
Once there are enough sellers, a buyer can buy.
Inside the function, revalidate if the buyer has
enough money to buy the specific item requested.
If not, the transaction is reverted.
When the validation is satisfied,
money is transferred to the seller,
item is transferred to the buyer.
We have a simple assert declaration at
the end that the bought item should have been transferred.
After all, it's a digital item.
This can be reached only if the item has not been
transferred and could not be transferred due to exception reason.
This provides a simple example of concept learned in this lesson.
In summary, function modifiers along with state reverting functions of revert,
require, and assert, collectively support
a robust error-handling approach for a smart contract.
These declarative features can be used to perform formal verification and
static analysis of a smart contract to make
sure it implements the intent of a smart contract.
Explore nosso catálogo
Registre-se gratuitamente e obtenha recomendações, atualizações e ofertas personalizadas.
O Coursera proporciona acesso universal à melhor educação do mundo fazendo parcerias com as melhores universidades e organizações para oferecer cursos on-line.
© 2018 Coursera Inc. Todos os direitos reservados.
