Engineering is the practice of containing complexity.

A well-designed system does not require every component to understand every other component. It defines interfaces, keeps responsibilities clear, and lets each module focus on a specific job.

That is how bridges, electronics, software, and financial systems are built. Components can be reused because they expose predictable properties. A chip can be tested before it is placed into a finished product. A material can be used in a bridge because its properties are understood. A software module can be used by another system because its interface is stable.

Good interfaces make complex systems easier to build, test, and extend.

When Abstractions Leak

Interfaces do not remove the need to understand risk.

As components become more complex, their internal design can matter. Software engineers call this a leaky abstraction. A number may look simple, but in a system like Solidity it still depends on memory limits, overflow behavior, and execution rules.

Financial infrastructure has the same problem.

Traditional markets use identifiers, messaging standards, and protocols to coordinate between exchanges, brokers, custodians, and other financial systems. In theory, standards make everything easier to connect. In practice, every provider has its own variations, field meanings, and integration requirements. The result is a system that appears standardized from a distance but still requires bespoke work at every connection point.

DeFi has a chance to do better.

Smart contracts make interfaces public, inspectable, and executable. If the interfaces are well designed, financial systems can become more composable without turning every integration into a custom project.

Smart Contracts as Modules

Onchain systems are modular by default.

A smart contract has its own storage and can interact with other contracts only through the interfaces those contracts expose. That boundary is not about secrecy. Blockchain state is public. The boundary exists because contracts should not be able to reach directly into one another’s internals.

In DeFi, this allows larger systems to be built from smaller contracts with clear responsibilities.

A lending system does not need to be one monolithic contract. It can be built from vaults, connectors, hooks, oracles, account logic, and interfaces that coordinate with one another. Each component can be tested, audited, reused, and integrated by other systems.

This is the basis for safer and more flexible credit infrastructure.

Containing Defects

Modularity also helps contain failures.

In a monolithic system, a defect in one component can affect the entire trusted code base. In a modular system, sensitive logic can be kept small, while external components are treated as untrusted unless they satisfy specific checks.

Euler’s design work has increasingly moved in this direction: keep the core trust boundary minimal, isolate external logic where possible, and require components to prove that the account or vault remains valid after an action.

That does not eliminate risk. It makes the boundaries clearer.

A swap handler, a hook, an operator, or a vault should only be able to do what the surrounding system explicitly permits. If it fails to meet the required checks, the transaction can revert before invalid state is accepted.

Standards Make Composability Work

The reason Ethereum composability works is that standards reduce the number of custom integrations every contract needs to support.

ERC-20 became powerful because every token exposes a common interface. ERC-4626 extends that idea to tokenized vaults. A vault can represent a position, expose accounting logic, and remain compatible with the broader ERC-20 ecosystem.

Euler V2 builds on this standard.

The Euler Vault Kit lets builders create configurable ERC-4626 lending vaults. The Ethereum Vault Connector lets selected vaults recognize one another as collateral, coordinate account checks, support sub-accounts, delegate operator permissions, and batch multi-step actions.

Together, EVK and EVC create a modular framework for credit markets.

Vaults can define their own assets, oracle inputs, caps, interest rate models, liquidation parameters, governors, curators, and hooks. EVC defines how selected vaults and accounts can interact. Hooks and external logic can add checks or restrictions where a product requires them.

Why This Matters for Lending

Lending markets are not one-size-fits-all.

A stablecoin market, a tokenized asset market, a long-tail collateral market, an institutional market, and an Earn vault may all need different parameters, different governors, different liquidity paths, and different risk controls.

A monolithic lending system forces those designs into one shared structure. Fully isolated markets can reduce shared risk, but they can also limit collateral relationships and fragment liquidity.

Modular credit infrastructure gives builders another path.

Markets can stay scoped at the vault level while still connecting through defined collateral relationships. Curators can launch and operate markets with explicit roles. Integrators can build lending flows across selected vaults. Agents can read market state and execute scoped workflows through account infrastructure.

That is the role of Euler V2: modular lending infrastructure for creating, connecting, and operating onchain credit markets.