When talking about smart contracts, it’s important to describe what happens, how it works, and what is affected. You may not always know who performs the action, or it might not even matter. Passive voice and relative clauses help you focus on results and structure your explanation clearly.
Let’s explore two key grammar tools for describing smart contract behavior in technical and professional language.
🧱 What is passive voice?
Passive voice is used when the focus is on the action or result, not on who is doing it.
Structure: be + past participle
Examples:
The contract was deployed successfully.
Tokens are transferred when the condition is met.
The function will be executed after approval.
Passive voice is useful because it emphasizes what happens rather than who causes it. This is common in professional writing and speaking.
Let’s compare the following:
Active voice: Developers deployed the contract.
Passive voice: The contract is deployed.
In the active sentence, “Developers deployed the contract”, the subject (developers) performs the action. In the passive version, “The contract is deployed”, the focus shifts to the object (the contract), which receives the action. If the contract being deployed is often more important than who deployed it, use the passive voice.
🔧 Passive voice in Web3 and smart contracts
Here are common passive constructions:
“The tokens were locked until the timer expired.”
“The proposal was rejected due to a formatting error.”
“A new contract will be deployed after the upgrade.”
“Gas costs were reduced by optimizing the function.”
These sentences focus on what happened, not who did it. That’s ideal when discussing automation, smart contract behavior, or technical outcomes.
🛠️ Useful verbs in passive constructions:
deploy → was deployed
execute → is executed
verify → has been verified
trigger → will be triggered
lock → was locked
transfer → is transferred
❓ What is a relative clause?
A relative clause gives more information about a noun. It often answers “Which one?” or “What kind?”
Relative clauses begin with who, which, that, or where.
Examples:
A contract that supports multiple tokens
A user who submits a vote
A condition which must be met
A protocol where validators are chosen randomly
These clauses help you explain things more clearly and precisely. They’re very useful in technical definitions, explanations, and feature descriptions.
🧩 Using relative clauses in smart contract descriptions
There are two main types of relative clauses:
Defining relative clauses (essential information), no commas:
A DAO that uses on-chain voting
A function that handles reentrancy protection
A wallet that supports multisig approval
Non-defining relative clauses (extra information), use commas:
The contract, which was developed last year, is now deprecated.
The token, which is used in staking, also gives voting rights.
🧪 Tip: Use “that” for defining clauses and “which” for non-defining clauses. Use “who” for people and “where” for locations or platforms.
🔗 Combining passive voice with relative clauses
Many technical descriptions use both structures to describe what something is and what happens to it.
Examples:
A bug that was discovered during the audit has been fixed.
The module, which was deployed last week, handles user authentication.
A wallet that is protected by a multisig setup cannot be drained by one signer.
The logic, which is triggered automatically, reduces gas usage.
These sentences are clear, formal, and can be used in smart contract documentation and reports. They show both structure and behavior.
🗣️ Tip for Fluency
Use passive voice and relative clauses when you want to describe systems and processes in a clear, formal, and precise way. This helps build credibility and clarity in your communication, especially when writing about code behavior or design decisions.
🔧 Smart Contract Walkthrough: How It Works, Why It Matters
In this section, a smart contract that manages employee bonuses is presented and explained. Each part of the contract is examined to show how its components are connected and why they are used. As you follow along, pay close attention to the explanations: many of the descriptions use passive forms (e.g., “is allocated,” “is stored”) and relative clauses (e.g., “that tracks bonus amounts,” “which prevents errors”).
Try this:
Can you find at least three passive structures and three relative clauses in the walkthrough dialogue?
Then, write two of your own sentences using a similar structure to describe another smart contract or dApp feature you’ve seen or built.
Sarah Chen, Blockchain Developer: Good morning, everyone. Today I'll walk you through a simple smart contract that demonstrates the key concepts we discussed. This contract, which manages employee bonus allocations, shows how the components work together in practice.
Sample smart contract code
NOTE: This code is for demonstration of the language point only and is not to be used.
Contract explanation
Sarah: Let me explain how this contract works, starting with the basic structure. The contract that I've shown you manages employee bonuses in a transparent and automated way. Each component that we discussed earlier is demonstrated here in a practical context.
Constructor analysis
Sarah: The constructor function is called when the contract is first deployed to the blockchain. In our example, constructor(uint256 _initialPool) sets up three important things: it establishes who the owner is, it defines how much money is available for bonuses, and it activates the bonus system.
The owner that is set during construction becomes the only person who can add employees or allocate bonuses. This security feature that prevents unauthorized access is established permanently when the contract is deployed. The initial bonus pool that is specified cannot be changed later without going through the proper allocation process.
State variables breakdown
Sarah: The state variables that are defined at the top store the contract's permanent data. address public owner stores the blockchain address of the person who deployed the contract. The public keyword means that anyone can read this value, providing transparency about who controls the system.
uint256 public totalBonusPool tracks how much money is available for distribution. This number that represents available funds decreases each time bonuses are allocated. bool public bonusesActive is a simple true/false flag that could be used to pause the system if needed.
Mappings in action
Sarah: The mappings that we use here create relationships between employee addresses and their data. mapping(address => uint256) public employeeBonuses links each employee's blockchain address to their bonus amount. This structure that connects addresses to numbers allows us to track individual allocations.
mapping(address => bool) public isEmployee determines whether a particular address belongs to a registered employee. The boolean values that are stored here prevent unauthorized people from receiving bonuses. These mappings that maintain employee records can be updated as staff changes occur.
Function logic
Sarah: The functions that handle the contract's operations each serve specific purposes. addEmployee() includes a require statement that ensures only the owner can register new employees. The validation logic that protects this function prevents unauthorized access to the employee registry.
allocateBonus() demonstrates multiple validation checks that protect the contract's integrity. The function that processes bonus allocation verifies three conditions: the caller must be the owner, the recipient must be a registered employee, and sufficient funds must be available in the bonus pool.
The getMyBonus() function that employees use to check their allocation is marked as view, which means it only reads data without making changes. Functions that don't modify state variables are free to execute and don't require transaction fees.
Q&A session
David Rodriguez, Operations Head: How does this improve our current bonus process?
Sarah: The transparency that this system provides eliminates questions about fairness in bonus distribution. Employees can verify their allocations independently, and the immutable record that is created shows exactly when and how bonuses were assigned. The automated validation that prevents errors also reduces administrative overhead.
Maria Santos, Finance Director: What about the costs of implementing this?
Sarah: The contract that I've shown requires minimal gas fees for deployment and operation. Each bonus allocation that is processed costs approximately $2-5 in transaction fees, which is negligible compared to the administrative costs that are eliminated. The permanent record that is maintained also provides audit trail benefits that traditional systems cannot match.
James Liu, IT Security: How do we ensure the contract works correctly?
Sarah: The require statements that are built into each function prevent invalid operations before they can cause problems. The logic that validates employee status and available funds protects against common errors. Additionally, the state variables that track the bonus pool ensure that more money cannot be allocated than is actually available.
Sarah: The smart contract that we've reviewed demonstrates how blockchain technology can automate business processes while maintaining complete transparency. The components that we've discussed - constructors, state variables, mappings, and functions - work together to create a system that is both secure and efficient.
Are there any questions about how these smart contract elements that we've covered would apply to other business processes?
✅ Key takeaways
Passive voice helps shift focus from the actor to the action or result, useful when the performer is unknown or less important.
Relative clauses (e.g., “that manages employee bonuses”) add precision and context, helping define or add information about nouns.
These structures are common in smart contract documentation, technical presentations, and professional Web3 communication.
To build fluency, practice noticing and using these forms when describing your own projects or reading technical content.
📝 Take the quiz
Check your understanding of passive voice and relative clauses in Web3 by answering a few quick questions.
📚 Further reading & resources
Cyfrin Glossary – Smart Contracts
A clear explanation of smart contracts, their components, and how they interact. https://www.cyfrin.io/glossary/smart-contract
