Understanding The Newton Protocol: The Missing Policy Layer In Web3

In the past few years, there has been a rapid evolution of blockchain-based infrastructure. Blockchains enable decentralized execution environments; decentralized autonomous organizations (DAOs) handle governance while smart contracts automate processes. Combined, these systems enable protocols to operate absent centralized control.

Notwithstanding this tremendous progress, the Web3 ecosystem misses a crucial piece of infrastructure: the majority of networks/protocols lack an agile, shared system for enforcing and defining operational policy(ies) across protocols.

Currently, the rules applied to decentralized systems are enforced through governance frameworks or are baked into smart contract code (code is law). While this is ideal for deterministic execution, its lack of flexibility, especially when systems need to respond to unforeseen events or coordinate across protocols, makes decentralized protocols vulnerable to various risks, including regulatory and security risks.

Enter Newton Protocol!

Newton Protocol endeavors to remedy the aforementioned problem via the concept of shared policy infrastructure: a universal system enabling protocols to utilize a common network for business rules, security, and compliance. By decoupling smart contract code from policy logic, Newton Protocol envisions a Web 3 ecosystem that is easier to operate, safer to manage, and flexible as the sector evolves.

How Does Governance Work Today?

To appreciate Newton’s contribution to the Web3 industry, an understanding of how rules are enforced in decentralized protocols is necessary. Indeed, most on-chain organizations rely on governance frameworks and protocol rules ( code)for enforcement.

Generally, developers embed protocol rules in code. For instance, the developers of a lending app may memorialize parameters like upgrade authority, interest rate calculations, and liquidation thresholds directly into smart contract code, ensuring enforcement whenever users access the system.

Governance frameworks provide an additional layer of control. Compound, Yearn Finance, and Aave are examples of protocols that allow holders of their respective governance tokens to propose and vote on smart contract upgrades, revisions on protocol parameters, financial decisions, etc. [1]

Governance decentralizes the control of a protocol’s resources, functions, and updates. Protocol constituents vote with their token holdings, enabling collective decision-making and stronger communities.

Unfortunately, not all governance participants are well-intentioned. For example, on May 20, 2023, a malicious actor surreptitiously slipped in a malicious proposal that led to the capture of the Tornado Cash protocol. [10] The malicious proposal contained similar logic as an earlier, legit proposal that had passed earlier on. However, it implemented self-destruct logic, allowing the actor to deploy malicious code, costing the protocol over $2.1 million.

The SELFDESTRUCT opcode halts a smart contract’s execution and transfers the entirety of its funds to a particular address. It also deletes its storage and code from state. The opcode was deprecated via EIP-6049( this did not alter its functionality). Following the Cancun hardfork, the SELFDESTRUCT opcode can only be used to transfer ETH balances and stop execution. This change in functionality was made possible by EIP-6780. [28]

For avoidance of doubt, contracts can still self destruct, what EIP-6780 does is to ensure they do so within their own creation transactions. Effectively, this limits who can interact with a contract while maintaining data integrity, and security.[26][27]

Proposals play a crucial role in governance frameworks. Why? Networks/protocols operate as arbitrary executioners (i.e., they are capable of calling and executing any function on any smart contract system). This ability is not without risks, as it involves trade-offs in scalability, decentralization, and security.

Furthermore, there is an issue of expressing intent. For example, in code-first governance, a token holder may have difficulty understanding why a particular upgrade matters, the risks that the proposal seeks to address, the assumptions the technical teams have, etc. Does the calldata align with the preferences of the protocol’s members or the protocol’s interests? Indeed, networks/protocols have inconsistent call data structures and application binary interfaces (ABIs), which are also difficult to decipher, a problem solved by governance proposals. [2] [22]

Consider the following raw calldata from an ERC20 transfer function:

0xa9059cbb00000000000000000000000012ab34cd56ef789012ab34cd56ef7890abcdef5600000000000000000000000000000000000000000000000000000000000003e8

For most people, this makes zero sense. However, a proposal would present the same as:

Proposal Mandate: Transfer 1,000 tokens from the DAO treasury to address (0x12ab34cd56ef789012ab34cd56ef7890abcdef56 ) for sanctioned protocol-wide development expenses.

Proposals provide human-parsable descriptions, making it easy for decentralized organizations to execute arbitrary code safely and for non-technical participants to engage in well-informed governance. Once participants consider the contents of a proposal, they vote for or against it per the protocol’s rules. Other solutions like the exeDAO protocol help on-chain organizations execute arbitrary code securely. [2][3][4]

Undoubtedly, governance frameworks play a pivotal role in ensuring decentralized protocols operate as public goods rather than a public menace. [5] Many governance processes within the blockchain ecosystem are complicated and not well documented. This is partly because there are no formal models (akin to traditional governance systems), and there is no duty to make them easy to communicate or even understandable.

While governance proposals help to advance decentralization, they reduce on-chain activities to cumbersome bureaucracies. It is clear that the average governance token holder possesses little influence and has no incentive to care or understand what a governance proposal provides. [6] Voter apathy leads to protocol capture, leading to value leakages and extraction. Worse, minority governance token holders face similar challenges to minority stockholders in TradFi. For instance, they also lack the legal protections enjoyed by shareholders in TradFi.

In the Tornado Cash governance attack, users failed to notice the proposal’s malicious functionality and voted for its implementation. [10] Governance proposals are highly ineffective in a rapidly evolving ecosystem characterized by black swan events and changing business needs. Changing protocol rules often demands contract upgrades, voting, and complex parameter updates.

A major challenge in the governance of protocols is the fact that voting and enforcement are approached exclusively. DAO constituents can vote to set risk parameters, upgrade protocols, or outline operational mandates, but ensuring their wishes are executed to the letter involves multi-sigs, manual processes, admin actions, etc. Consequently, a governance gap emerges.

The execution of approved proposals relies on fragmented control systems and trusted operators. As time lapses, enforcement may depart from its original mandate due to various reasons, including the application of unconstrained discretionary power, human error, or changing circumstances. [**19**] The ramifications of weak on-chain governance systems are deadly and irreversible. The Tornado Cash governance failure attests to this.

Governance ought to be approached pragmatically. Crucially, on-chain organizations require an agile system for defining and enforcing policy without relying on trusted operators and fragmented control systems. For instance, if DAO constituents sanction a mandate that forbids the treasury from interacting with a particular on-chain organization, that mandate can be converted into policy logic, ensuring it is enforced at the infrastructure level.

Newton’s policy engine plays an important role in linking governance activities to downstream enforcement. It establishes enforceable constraints, ensuring autonomous agents and human participants uphold the collective decision(s) made through voting.

The Issue: Smart Contracts != Policy Engines

A smart contract is a piece of enforceable bytecode on a specific blockchain address. Smart contracts execute deterministic logic once deployed (e.g., the transfer of assets). While smart contracts are powerful tools capable of eliminating various forms of friction, including duplication of effort, counterparty risks, and intermediation, they are far from being flexible policy management systems.

DeFi’s modularity (composability) entrenches interdependencies, which may cause systemic risk. A flaw in one protocol may cascade across the industry. The recent KelpDAO exploit is instructive. The exploit’s blast radius extended beyond the initial target, causing systemic contagion and solvency issues within major DeFi protocols. So severe was the attack that it necessitated an industry-wide intervention (DeFi United) to bail out the affected parties. [7] [8]

Why was Aave’s risk model unable to spot the KelpDAO exploit early? Aave’s pre-exploit risk models are optimized to detect/assess smart contract vulnerabilities and asset volatility. The system was not designed to detect infrastructure-level failures stemming from external dependencies.

Policies (on-chain and off-chain) are dynamic. Protocols constantly need to respond to novel risk parameters, regulatory changes, market sentiment, and governance provisions while coordinating with various platforms. Encoding all these into smart contract code leads to complexity, which expands attack surfaces and increases rigidity. For instance, it may cause logic flaws that may lead to endogenous risks, and misalignment with protocol rules/values. Additionally, smart contract size limits (24kb) and deployment costs must be considered.[24]

This challenge is not unique to blockchain-based systems. Developers of traditional distributed computational protocols have identified the challenges that flow from combining policy rules and application logic in a single system. Doing so often leads to operational fragility and complexity, masking critical points of failure.

Modern protocol architecture emphasizes separation of concerns: the decoupling of policy rules from business logic. By separating these concerns, projects can endorse and evaluate policy without altering the protocol’s core code.

This approach to protocol architecture is referred to as policy-as-code.

Policy Infrastructure: What Is It?

Policy-as-code enables projects to define and evaluate rules programmatically. The rules are encoded as software logic using Rego. [9] Instead of baking policy rules directly into protocol code, devs write policy rules separately and use specialized engines to evaluate the same. Open Policy Agent (OPA) is a common example of a policy engine utilized in cloud-native infrastructure. The engine allows protocols to, among other things, define and implement policies that govern access control, system behavior, and operational constraints. [9]

Decoupling policy from app logic has several advantages, including but not limited to:

• Protocols can update policies without touching core code (business logic).
• Policies can be reused across multiple projects.
• Protocols become more transparent and safe.
• Streamlining governance management.

Policy engines are a common and essential part of traditional software infrastructure. Can a similar concept be implemented in DeFi? YES!

Introducing The Newton Protocol

Newton Protocol aspires to provide the Web 3 ecosystem with a shared policy infrastructure. The protocol’s decentralized policy engine sits between users’ intention to interact with protocols and the execution of their transaction on blockchains. Fundamentally, Newton is an Actively Validated Service (AVS) deployed on the EigenLayer protocol, providing a universal compliance and security layer that any protocol can plug into.[14][11]

The following technical framework enables Newton to implement its infrastructure:

• Policy-as-code:
• Utilization of real-time off-chain data
• Enforcement through policy clients
• Decentralized verification network

By externalizing smart contracts from policy logic, Newton enables blockchain-based applications to, among other things, enforce operational rules without needing to upgrade smart contract code. Consequently, this ensures greater flexibility and upholds the deterministic execution of transactions promised by decentralized applications. [11]

This approach enables Newton to provide modular and chain-agnostic safety based on universal infrastructure. Currently, the Newton protocol is live on Base and Ethereum.

How Does The Newton Protocol Work?

While the underlying tech often constitutes complex architecture, Newton’s core idea can be broken down into a simple process:

First, the devs define a policy rule. The definition entails conditions like under what circumstances a certain transaction may be permitted or even sanctioned.

Secondly, the rule(s) are registered within Newton’s infrastructure. This ensures the rule(s) form part of Newton’s rule set. [25]

After doing this, once an on-chain activity occurs, Newton’s policy engine consults the attendant policy rules to ensure the activity complies with the set conditions. If the activity is compliant, on-chain execution proceeds. However, if the transaction/action violates the set rules, it is rejected entirely.

To uphold privacy, Newton Protocol utilizes Zero Knowledge proofs (ZK proofs) and Trusted Execution Environments (TEEs) to ensure, among other things, selective disclosures, safety, compliance, and auditability. [11]

Privacy has been a major concern in DeFi; the transparent nature of networks/protocols exposes participants to toxic MEV, front-running, targeted attacks, etc. This has made mass adoption difficult, as few people want their financial details broadcasted to the world. For instance, institutions require selective disclosure to maintain a competitive edge.

This approach enables users to verify and execute policy without revealing sensitive information publicly. As agentic commerce and institutions move into DeFi, privacy-first protocols and policy infrastructure become crucial for broad adoption. [18]

This system enables dynamic enforcement of policy rules without tampering with the underlying protocol code.

What Is Shared Policy Infrastructure?

One of crypto’s recurring challenges is how protocols react to adverse events, like hacks and exploits. Typically, projects react by implementing upgrades to patch buggy code, emergency governance votes, and treasury interventions, among other remedial steps. While these measures are critical, they are inherently reactive.

Newton’s shared policy infrastructure provides a proactive solution to this challenge. Instead of counting on governance solely to address issues post hoc, compliance with policy rules should be assessed prior to transaction execution. This enables on-chain organizations to employ guardrails around sensitive actions like interactions with autonomous agents, protocol upgrades, governance changes, etc. As such, if the performance of an action breaches predefined policy rules, a protocol should be able to block it before matters escalate. [11]

Needless to say, Newton’s shared policy infrastructure is not an alternative to secure smart contract development. Buggy code should be addressed via sound engineering practices (unit testing, formal verification, auditing, etc.). For instance, if a protocol fails to take measures that protect it from reentrancy attacks, like using OpenZeppelin’s ReentrancyGuard and implementing the Checks Effects and Interactions pattern (CEI), the policy engine cannot make the vulnerability disappear magically. [12][13]

The shared policy infrastructure provides an extra protection layer, which helps on-chain organizations avoid certain classes of authorization, operational, and governance failures. Effectively, Newton’s decentralized policy engine shifts DeFi’s security strategy from a reactive approach to proactive policy enforcement. Smart contracts define what is technically possible while the policy layer declares what is allowed.

The Newton Protocol provides a decentralized policy engine that utilizes off chain data and cryptographic proofs to enforce complex business rules. By separating application logic from policymaking, developers can embed various forms of guardrails directly into transaction execution. This approach introduces flexibility while upholding the deterministic execution affordances blockchains provide.

The shared infrastructure enables real-time enforcement of policy rules during transaction execution. For instance, if a user wishes to interact with a protocol, the policy engine evaluates whether the interaction is allowed. If allowed, an attestation (cryptographic proof) is issued. Crucially, the infrastructure is chain agnostic; as such, the rules apply no matter the network/protocol a user is interacting with. [23]

Shared policy infrastructure provides networks/protocols with a universal authorization system for compliance, security, and business logic. Rather than on-chain organizations building individual guardrails, Newton Protocol allows them to plug into a decentralized policy engine. Its standardized rules are predictable, precise, and human- and machine-parsable. [11] Verification of on-chain activity is conducted by operators (a decentralized network of independent workers).

A shared policy infrastructure inures to the benefit of decentralized protocols in several ways:

• It ensures consistent rule enforcement across on-chain organizations;
• It provides teams with safer operational control;
• It streamlines governance management; and
• It facilitates better coordination among decentralized protocols.

Critically, Newton’s solution introduces a programmable rule layer that exists alongside governance mechanisms and smart contract execution. The infrastructure could be employed in the governance of autonomous agents (AI agents). [11]

As AI agents increasingly continue to interact with protocols/networks, policy engines could ensure that they operate within set boundaries, ensuring deployers of AI-driven systems are insulated from legal and security risks. Newton provides infrastructure dedicated to secure agentic commerce, which also helps developers create and monetize their AI agents (the Newton Model registry).

Newton’s programmable policy layer is a tremendous contribution to the evolution of blockchain systems. It helps the ecosystem transcend beyond simple smart contract execution to a more specialized decentralized system infrastructure. Its verifiable and layered design makes it possible to automate on-chain activity, enabling decentralized ecosystems to benefit from complex, AI-driven automation.

Why Does Policy Infrastructure Matter For Web3’s Future?

Newton’s solution (shared policy infrastructure) opens the industry to a wide range of applications. For instance, decentralized organizations face a serious governance challenge. This is partly because they do not operate like traditional corporations with a centralized authority to promulgate and enforce rules.

The shared policy infrastructure solution allows technical teams to memorialize rules once and apply them system-wide. This approach cures some of the most pressing challenges decentralized systems face. For example, a programmable policy stack could streamline DAO governance enforcement and management. Policy rules could automatically guarantee the proper execution of governance decisions or even help ensure actions that go contrary to agreed-upon rules are restricted.

Although it is not advisable to delegate compliance obligations to tools, financial protocols could utilize Newton’s policy engine to aid their compliance activities. For instance, they could define certain rules that can be invoked to curb operations that exceed their respective risk thresholds.

This is crucial, especially when protocols interact with the off-chain world. Projects can use this to enhance or enforce operational constraints, which are crucial when engaging institutions. Effectively, a programmable policy layer could help bridge the gap between institutional systems and protocol ecosystems, which are still largely experimental, requiring robust operational control.

AI capabilities have improved dramatically over the past few years. As such, it is imperative that we consider how AI agents, for example, may improve or undermine protocol security. Bad actors utilize AI agents to find vulnerabilities in protocols and exploit them. A capable AI agent is capable of exploiting smart contract vulnerabilities. The immutable nature of blockchains and AI’s predisposition to runaway behavior compounds this problem. [16]

Capability absent proper constraints establishes risk. For instance, consider a scenario where an agent decides to bridge all your assets to a new protocol to maximize yield. The move might technically make sense to the agent but may be disastrous to the deployer.

A predetermined policy could ensure, among other things:

• New protocols should have existed for a specified period, say six months;
• The protocol ought to have been formally verified and is listed on approved platforms; or
• The protocol must have a TVL exceeding a certain amount.

Jurisdictions across the globe are working towards AI regulation. However, they are faced with a major challenge: how do you regulate an entity(ies) that lacks intention? Both criminal and civil law turn on intention, but AI agents can not be described as responsible actors. So where does legal obligation lie? [20][21]

AI agents, similar to their human counterparts, work for a principal (a natural or juridical person). Principals are vicariously liable for the actions of their agents under certain circumstances. [15] Since AI agents have the capacity to cause injury, it is proper to hold those who deploy them to objective standards of behavior. [17] As such, deployers of AI-driven systems must consider the harms their creations may cause and act accordingly. This can be solved by implementing governance systems that oversee implementation, training, and design.

The Newton protocol provides deployers of AI agents a viable solution to this challenge. Deployers of AI agents that operate on-chain can utilize Newton’s policy engine to ensure their systems operate within policy parameters and that execution is conducted in a transparent and verifiable manner.

Newton’s shared policy infrastructure ensures deployers can:

• Define what the agent is allowed to do;
• Define actions the agent cannot undertake; and
• What activities may require additional approval, etc.

In Sum: Critical Infrastructure For Decentralized Organizations

Web3 currently operates within robust foundational components: decentralized governance for decision-making and protocols for transaction execution.

Newton Protocol presents Web 3 with a third component: a programmable policy layer.

Newton’s solution enables technical teams to externalize policy logic from smart contract execution, establishing a novel approach for governing on-chain organizations. Newton’s approach could enhance protocols’ security and make them easier to manage and coordinate as they continue to evolve. Undoubtedly, when the Newton protocol acquires escape velocity, it will become a mission-critical component of future decentralized projects.

The governance of AI agents is one of the best use cases for Newton’s shared policy layer. As AI agents’ interactions with on-chain organizations increase, it is important to address what they can and cannot do and bake that into policy logic. The Newton protocol allows developers to design and enforce appropriate boundaries for AI agents via its programmable policy layer.

References

1. Colony: What is a governance token?
2. Aragon: Beyond Proposals Pt. I: Automation and the Art of Not Governing
3. Hacken: What Are Smart Contracts? Everything You Need To Know
4. exeDAO: Secure Arbitrary Execution on Ethereum Smart Contracts
5. Vlad Zamfir: Against on-chain governance
6. Token-Based Voting: Nakaguma, Marcos and Botelho, Tiago C., Token-Based Voting (December 09, 2024).
7. CoinDesk: Industry Leaders are pouring hundreds of millions into a rescue plan for Aave users after a massive crypto hack.
8. Chainalysis: Inside the KelpDAO Bridge Exploit
9. Open Policy Agent Documentation
10. Halborn: The Tornado Cash Hack (May 2023)
11. Newton Protocol Whitepaper
12. OpenZepplin: Smart contract security utilities and implementations
13. Solidity programming: The Checks-Effects-Interactions Pattern
14. ChainLink: What are Actively Validated Services?
15. Cornel Law: Vicarious Liability
16. OpenAI : EVMbench: Evaluating AI Agents on Smart Contract Security
17. LSD.law: Definition of objective standard
18. Havard technology review: Privacy in Decentralized Finance: Should We Be Concerned?
19. DAO Governance: Voting Power, Participation, and Controversy — A Review and an Empirical Analysis
20. The Law of AI is the Law of Risky Agents Without Intentions
21. Futurism: Argentina Moves to Legalize “Non-Human Corporations” Run by AI
22. LearnEVM: Working with calldata
23. Newton: The missing layer in crypto
24. ARXIV: Systemic Risk in DeFi: A Network-Based Fragility Analysis of TVL Dynamics
25. Writing Rego Policies
26. EIP-6049: Deprecate SELFDESTRUCT
27. EIP-6780: SELFDESTRUCT only in same transaction
28. Chain: A Complete Guide to Ethereum’s Dencun Upgrade