Solidity Inheritance: Virtual & Override Keywords Explained

The C3 Linearization Algorithm is Python's default method for determining Method Resolution Order (MRO) in multiple inheritance, which solves the classic diamond problem by following two key rules: local precedence order (the order of parent classes in the class definition) and monotonicity (if a class precedes another in a parent's MRO, it must also precede it in all subclasses' MRO). The algorithm works by iteratively selecting the first element from the list of superclasses' linearizations as a 'head' only if it is not present in the tail of any other list, then removing that head from all lists and repeating until the complete MRO is constructed.

The C3 linearization algorithm is a proof-based solution for resolving method resolution order in multiple inheritance scenarios, particularly diamond diagrams where the same methods appear on both sides of the inheritance chain. It takes an amorphous blob of classes and puts them in a straight line (linearizes them) so that method calls can be resolved deterministically. This algorithm is considered optimal and best for solving multiple inheritance problems.

MRO (Method Resolution Order) determines which method to call in multiple inheritance. Python uses the C3 linearization algorithm, which builds a list of ancestors sorted by distance from the class and searches breadth-first. This solves the diamond inheritance problem where a class inherits from two classes that both inherit from a common ancestor. Multiple inheritance is rarely used in practice and can be dangerous; composition is often preferred. When using multiple inheritance, understanding MRO is crucial to avoid conflicts and ensure correct method resolution.

This comprehensive section covers polymorphism in Solidity, where child contracts can redefine parent contract functions to change behavior. The video addresses the diamond problem in multiple inheritance, where conflicting inheritance paths cause linearization errors. The linter reports 'linearization of inheritance graph impossible' when contracts inherit from multiple contracts sharing a common ancestor. The solution is to ensure parent contracts in the inheritance list do not have common ancestors among themselves. The section demonstrates polymorphism through a practical example with four contracts (parent, kid1, kid2, mycontract), showing how function resolution follows the most derived contract in the inheritance chain.

Method Resolution Order (MRO) determines the order in which Python searches for methods and attributes in a class hierarchy. For single inheritance, Python searches the instance's __dict__, then the class's __dict__, then parent classes. For multiple inheritance, Python uses the C3 linearization algorithm to produce a consistent MRO. The super() function is used to call methods from parent classes, taking two arguments: the class and the instance (self). When called without arguments, super() automatically determines the class and instance from the calling context. Mixins are classes designed to be combined with other classes through multiple inheritance, typically placed first in the inheritance list to ensure their methods are found first.

The 'super' keyword allows child contracts to call parent contract functions. This is useful when you want to extend parent functionality rather than completely replace it. When a child contract inherits from a parent contract with a constructor, the child contract must also define its own constructor. The child constructor can call the parent constructor using the super keyword. When a contract inherits from multiple parents that both define functions with the same name, you must explicitly specify which parent's function to call using super and the parent contract name.

The 'super' keyword is used to call methods from the parent class when they are overridden in the child class. To invoke a parent class method from within a child class method, use 'super.methodName()'. This allows the child class to execute parent class functionality before or after its own implementation.

In Solidity, the super keyword is used to call parent contract functions within a derived contract, ensuring that both parent and child contract logic executes when calling a child function. Unlike direct calling which explicitly specifies the contract name, super searches for the function from right to left through the inheritance hierarchy and triggers the first matching function found. This mechanism is essential for maintaining proper inheritance chains in smart contracts, particularly when working with multiple inheritance scenarios where the order of base contracts matters.

The 'super' keyword can be used within a subclass method to call the parent class's version of the same method. This is done by writing 'super.methodName()' inside the overridden method. This allows you to execute the parent's implementation before or after your own code, enabling you to extend functionality while preserving the parent's behavior. This pattern is commonly used when you want to add additional functionality to an existing method without completely replacing it.

Within an overridden method, the 'super' keyword can be used to call the parent class's version of the same method. This is useful when you want to execute both the parent and child implementations. The syntax is 'super.methodName()'. This allows for extending parent behavior rather than completely replacing it, combining the functionality of both parent and child classes.

Two primary design patterns enable upgradable contracts: Proxy and Factory. The Proxy pattern uses an intermediary contract that forwards calls to the implementation, allowing the implementation to change while the proxy address remains constant. The Factory pattern creates and manages multiple contract versions, handling state transfer and version coordination. Both patterns require careful consideration of interface compatibility, state preservation, and authorization mechanisms. The choice between them depends on specific requirements for flexibility, security, and decentralization in the application architecture.

The factory implementation involves creating a factory class with a static create method that accepts a type string and returns an interface. All concrete notification classes implement this interface with a 'send' method. This enables polymorphism where any object returned from the factory can be treated uniformly through the interface contract. Clients only need to know about the interface method signatures, not specific implementations, enabling flexible and decoupled code design.

Smart contract design requires fundamentally different approaches than traditional software engineering due to decentralization constraints eliminating centralized backends. Two primary metrics frame all design decisions: upgradability (how protocols evolve over time) and composability (how easily others can build upon protocols). Protocols achieving limited reasonable upgradability with maximal composability become critical infrastructure. Proxy contracts enable state-preserving upgrades through delegate calls but require deep understanding of Ethereum's storage model—both proxy and implementation share slots, creating hazards where naive implementations risk permanently losing upgrade control. EIP-1967 resolves this through keccak-derived constants. Authorization patterns range from simple roles-based systems to sophisticated DSAuth governance. Safe ownership transfer demands careful pattern selection between unchecked receive and checked receive mechanisms. Modular architecture separates system components into distinct modules—some as immutable gatekeepers enforcing core invariants, others as swappable implementations. The invoker pattern provides flexible execution through registered modules, while delegate call-based governance introduces complexity from shared storage.

Multiple Factory implementations can follow the same interface. For example, 'RandomEnemyFactory' returns enemies randomly, while 'RandomDifficultEnemyFactory' returns only powerful enemies. All factories inherit from an abstract Factory class that defines the 'createEnemy' method. This polymorphic approach allows the game to use different enemy creation strategies by simply passing different Factory instances.

This video explains five major smart contract upgradeability patterns: Eternal Storage (separating data and logic contracts), Transparent Proxies (using delegate call with an admin-controlled upgrade mechanism), Universally Upgradeable Proxies (UUPS) where upgrade logic lives in the implementation, Beacon Proxies (coordinating multiple proxies through a central beacon), and the Diamond Standard (mapping function selectors to different implementation contracts for fine-grained upgrades).