Newton Protocol

As more bots and burner accounts flood online platforms, developers need a reliable way to distinguish legitimate users from throwaway accounts and spam before a transaction or task moves forward.
That’s why we partnered with the Neynar team to build the Neynar Farcaster Data Oracle, an open-source implementation compatible with Newton Protocol, enabling developers to verify Farcaster user legitimacy through programmable policies before transactions execute. This gives apps and agents a lightweight way to enforce trust requirements without relying on brittle, app-level checks.
Bringing Farcaster Identity Data into Newton Protocol
The Neynar Data Oracle allows developers to bring Farcaster user metadata (e.g., user score, follower count, verified addresses, account badges) into a Newton Protocol policy, where it enforces pre-transaction decisions. For example, a policy can require a minimum user quality score, at least one verified external wallet address, and a minimum follower count before a task or transaction is allowed to proceed. 
Also, because this logic lives in the policy layer rather than in smart contracts, developers can update these thresholds and rules over time without redeploying contracts or rewriting application code.
What Developers Can Build With This
The Neynar Data Oracle unlocks proof-of-humanity guardrails such as:
Anti-sybil controls: Prevent low-score or unverified accounts from interacting with key flows.Task & reward gating: Only accept submissions from accounts with a minimum Farcaster reputation.Community or governance moderation: Enforce participation criteria (e.g., verified accounts only) without central gatekeeping.
Composable with other Data Oracles

Neynar data is just one input into a Newton Protocol policy. Developers can combine it with any other Newton Protocol data oracle, such as:
Veriff or Persona for address verification Etherscan for gas fee guardrailsVaults.fyi or Massive for market and asset signalsMagic Labs for authentication and wallet security

As AI agents and automated DeFi systems increasingly manage capital onchain, one challenge stands out: ensuring these agents act safely and within defined parameters before executing a transaction.
Today, we’re introducing the Vaults.fyi Data Oracle, an open-source integration built for Newton Protocol that integrates real-time vault performance data to enforce programmable guardrails for AI and DeFi automation.
Bringing Vaults.fyi Data into Newton Protocol
The Vaults.fyi Data Oracle enables developers to incorporate historical vault APY data into a Newton Protocol policy to create programmable guardrails for agentic systems and DeFi automation.
Developers can also integrate additional Vaults.fyi performance and transaction APIs to create policies that:
Allocate funds only to vaults with a 30-day APY above a defined threshold.Restrict interactions to vaults with a specified number of holders and instant withdrawal support.Block reallocations to vaults with low liquidity or poor reputation scores.Enforce diversification caps to prevent overexposure to a single protocol or asset.
By routing Vaults.fyi data through Newton Protocol, developers can ensure that AI trading agents and DeFi automations make decisions only when the policy conditions are met, enabling real-time, trust-minimized compliance before execution.
Together, Vaults.fyi and Newton Protocol enable AI-safe DeFi automation where every agent action is preceded by a verifiable policy check.
Example Use Cases
Integrating Vaults.fyi data through Newton Protocol enables real-time, data-driven decision controls for:
AI trading agents: Evaluate vault performance and risk before executing deposits or swaps, ensuring actions stay within defined yield and risk tolerances.Automated yield optimizers: Use Vaults.fyi data as a signal layer for rebalancing decisions, with Newton Protocol enforcing minimum APY or liquidity requirements.Treasury management bots: Guarantee that automated treasury deposits only occur in vaults with verified assets or sufficient depth.Cross-protocol allocators: Apply consistent policy checks across chains and vault providers without custom integrations.Institutional DeFi platforms: Create pre-trade controls that satisfy internal risk and compliance mandates for AI-driven execution.
Together, Vaults.fyi and Newton Protocol bring programmable safety to AI finance, transforming automation from reactive to verifiably risk-aware.
Why Newton Protocol Is Different
Most automation frameworks operate offchain or embed rigid logic in smart contracts, making them opaque and difficult to update. Newton Protocol separates policy enforcement from execution, creating a programmable layer that is:
Modular: Define once, apply across vaults, chains and agents.Composable: Combine onchain and offchain data for richer logic.Updatable: Adjust thresholds and rules without redeploying contracts.Verifiable: Every evaluation generates an attestation visible on Newton Explorer.Credibly Neutral: Enforcement runs through a decentralized operator network secured by EigenLayer restaking.
Newton Protocol turns automation and compliance controls into code, giving lean teams the efficiency and oversight typically reserved for organizations with full compliance and risk teams.

Polymarket, the world’s largest prediction market, has relied on Magic’s embedded wallet infrastructure since 2020 to provide users a fast, secure and reliable way to trade and manage funds.

Key results with Magic: 
Over $3B in market volume supported during the 2024 election night with zero downtime and peak traffic stability throughout50x hyper-growth in monthly active usersSub-second response times across wallet login and transaction flowsImproved user retention and conversion thanks to faster onboarding and withdrawals
“Election night was one of the biggest stress tests we’ve ever seen,” said Rodrigo, Head of Platform at Polymarket. “Magic’s infrastructure handled it seamlessly.”

The Challenge
In 2024 Polymarket experienced rapid growth with active traders spiking over 80x during the 2024 U.S. election. This growth created several technical challenges:
Performance bottlenecks during new wallet creation and authentication flowsSecurity concerns around high-risk actions like withdrawals and tippingReliability under extreme traffic especially during real-time global events
Polymarket needed a battle-tested, trusted wallet infrastructure that could handle massive concurrent, secure transactions at scale and provide users with a seamless UX.
The Solution
Since 2020, Polymarket has relied on Magic as its sole embedded wallet provider to power onchain access for every user. As the platform grew into one of the largest and most successful onchain apps in the world, that partnership deepened with the two teams working side by side to re-architect Polymarket’s wallet experience for the next stage of scale.
Built on Magic’s API Wallets — a server-side, TEE-secured wallet infrastructure — the new system delivers both enterprise-grade security and highly scalable performance, giving users an experience that feels instant, even during global traffic spikes. Faster performance means: 
Wallet iframe bundle reduced from ~2 MB to ~450 KB, a 4.5x optimization significantly improving load times across all devicesSelected wallet and auth flows deployed through the Vercel Edge Network for sub-second latency worldwideCore authentication pipelines rebuilt to cut response times by more than half:Email link login: 2.5x fasterOAuth initialization: 2.8x faster

To strengthen user protection during withdrawals, Magic and Polymarket jointly developed a step-up 2FA policy engine that adds an extra layer of verification for high-risk actions as defined by Polymarket. Built on Magic’s infrastructure and anchored by Newton Protocol, a verifiable policy layer for programmable onchain security, the engine dynamically evaluates risk conditions (e.g., withdrawal thresholds, device anomalies, session heuristics) off-chain before any wallet signing occurs, then records the signed outcome of the policy evaluation on-chain through Newton Protocol's verifiable and privacy-preserving policy ledger. This creates a secure, fast and verifiable policy for step-up 2FA keeping users' funds safe without disrupting UX.

Why Magic Labs
Since 2018, Magic has provided battle-tested wallet infrastructure and is trusted by over 200,000 developers across 50 million+ wallets. By combining patent-pending TEE-secured key management, server-side APIs, and multi-chain support, Magic enables companies like Polymarket, WalletConnect, Naver, Forbes, Mattel and more to deliver seamless, secure onchain experiences that scale to millions.
“Every millisecond matters when you’re serving users at global scale,” said Magic Labs Cofounder and President, Jaemin Jin. “Polymarket’s growth shows what’s possible when speed and security come together.”

In the fast-moving world of DeFi, blockchain transactions are irreversible by design. Once executed, there's no undo button. This finality is both a strength and a vulnerability - especially when dealing with high-value assets, automated trading, real-world assets (RWAs), stablecoins, and increasingly, autonomous AI agents operating onchain.
Newton Protocol addresses this challenge head-on by introducing a powerful, programmable layer of risk controls that operate before any transaction is finalized on the blockchain.
Here is how Newton helps developers enforce risk controls at the smart contract layer before onchain actions execute.
A Three-Step Process
Step 1: Write a policy

Set policy rules using rego code. Policies can reference any onchain and offchain data.

Step 2: Connect to a smart contract

Add a lightweight code snippet to the smart contract functions you want to protect with Newton Protocol.

Step 3: Enforce automatically

Users interact as usual. Only non-compliant actions are blocked.

Behind the scenes, each transaction intent is evaluated, attestations are generated by operators, and transaction approval or rejection is programmatically enforced.

Why This Matters for the Future of Onchain Finance
Traditional risk controls often rely on offchain components - front-end warnings, centralized backends, or custodial layers - that vanish once a user takes full control of their keys. Newton changes that by moving enforcement onchain and making it programmable, verifiable, and composable.
By combining the security of smart contracts with flexible, data-rich policy enforcement, Newton Protocol paves the way for safer, more institutional-grade decentralized applications without sacrificing decentralization.

As the Digital Asset Market Clarity Act (CLARITY Act) moves through the legislative process, builders face a new reality: regulatory compliance is no longer a "wait and see" game; it’s a core technical requirement. While the draft bill provides the first comprehensive federal framework for digital assets, it also introduces specific operational hurdles for compliance and risk management that traditional smart contracts and frontends aren't equipped to handle on their own.
This article breaks down key proposals of the CLARITY Act that impact crypto developers and institutions, as well as how Newton Protocol serves as the technical "missing link" to enable compliance with these new requirements.
1. Protocols & Tokens: The Decentralization "Graduation"
The bill moves tokens from the strict oversight of the SEC to the more flexible oversight of the CFTC once they reach a certain level of decentralization.
Problem: To "graduate," a protocol must prove it is not under the unilateral authority of its founders. However, most protocols today keep "emergency brake" powers or retroactive risk management tools in the hands of the dev team to prevent hacks or comply with sanctions.Solution: Instead of the founders holding the "keys" to block a transaction, Newton Protocol automatically enforces policies before transactions happen based on preset rules through its decentralized operator network.Result: You can truthfully certify that no single person has the power to alter the system, enabling decentralization while enforcing protections that keep protocols and users safe.
2. RWAs & Stablecoins: The "Equivalence" Standard
If you are tokenizing real-world assets (like bonds or real estate), the bill requires you to prove that the digital version has the exact same legal rights and obligations as the paper version.
Problem: Paper assets can have complex rules: only accredited investors can buy them, they can't be sold in certain countries, and they require tax reporting. If a token can be sent to a random wallet that hasn't met these rules, the "equivalence" is broken, and the issuer may be liable for misrepresentation.Solution: These "paper rules" can be encoded as enforceable logic into custom Newton Policies, without overloading the smart contract with such complexity. For example, you can enforce that the buyer's credentials and the jurisdiction of the trade are checked before the transaction is allowed to settle onchain.Result: You aren't just promising that your token follows the law; you are using Newton Protocol to make it mathematically impossible for the token to move in a way that violates its legal "paper" counterpart.
3. Wallets & Apps: The "Application Layer" Guardrails
The bill identifies a new legal category called the Application Layer (the websites and apps we use to talk to blockchains). These apps may be legally required to screen out sanctioned actors and illicit finance.
Problem: Usually, apps block certain IP addresses or wallet addresses on their website’s frontend, or retroactively freeze accounts and funds manually. However, a user can easily bypass these offchain blocks by using a different website or by directly calling the app’s smart contract execution functions onchain. If the illicit trade happens, the app owner could still be held responsible.Solution: Newton Protocol moves the screening logic enforcement from the website’s frontend into the smart contract’s execution onchain, which cannot be bypassed. This compliance logic is composable and reusable across the broader blockchain ecosystem, so applications will not need to duplicate the implementation effort.Result: No matter which app or wallet a person uses, the transaction won't settle unless it passes the risk checks required by the law. This provides a bulletproof defense for app developers.
4. Banks & Custodians: Institutional "Safety and Soundness”
The bill finally gives banks a clear green light to hold and trade crypto, but it warns that regulators can shut them down if their activities are "unsafe or unsound."
Problem: Banks and custodians need to know whose crypto transactions they are enabling; otherwise, they cannot stop a sanctioned or fraudulent transaction. By default, transactors on permissionless blockchains are anonymous, making crypto inherently "unsafe or unsound" for regulated financial institutions.Solution: Newton Protocol integrates seamlessly with data providers like Veriff, Persona and Range, allowing institutions to build KYC, AML and risk management rules into the smart contract layer so non-compliant transactions are prevented.Result: Banks can manage their risk exposure and satisfy regulatory requirements to prevent "unsafe or unsound" transactions, even on open, liquid blockchains.
How Newton Protocol Can Help
Newton Protocol enables developers and institutions to comply with the standards of the CLARITY Act without overhauling their existing UX or codebase.