# Newton Protocol Docs

Newton Protocol is a decentralized policy engine for onchain transaction authorization, built as an EigenLayer AVS.

- [Overview](/developers/vaults/overview): Use Newton Protocol to add verifiable risk, compliance, and privacy guardrails to DeFi vault operations.
- [Policy Packs](/developers/vaults/policy-packs): Use Newton policy packs to enforce risk, compliance, and oracle checks before vault actions execute.
- [Protocol Concepts](/developers/vaults/protocol/concepts): Core Newton Policy Protocol types and actors used by VaultKit.
- [Attestation Flow](/developers/vaults/protocol/attestation-flow): How a VaultKit manager action becomes a Newton policy attestation and an onchain Shield execution.
- [Guarantees](/developers/vaults/protocol/guarantees): The enforcement guarantees VaultKit relies on when routing vault actions through a Shield.
- [Vaults.fyi Vault Risk Rating](/developers/vaults/policies/vaultsfyi): Use Vaults.fyi data in Newton policies to gate vault actions on APY, TVL, risk score, allocation changes, flags, and corruption status.
- [Chainalysis Address Screening](/developers/vaults/policies/chainalysis): Use Chainalysis data in Newton policies to screen addresses for sanctions and high-risk categories before vault actions execute.
- [RedStone Oracle Divergence](/developers/vaults/policies/redstone): Use RedStone data in Newton policies to stop vault actions when price feeds are stale, divergent, or persistently outside thresholds.
- [Webacy Depeg Risk](/developers/vaults/policies/webacy): Use Webacy data in Newton policies to monitor pegged-token depeg risk before manager actions execute.
- [Arkham Entity-Aware Spending Gate](/developers/vaults/policies/arkham-entity): Use Arkham entity attribution in Newton policies to tier a spending limit by who the destination actually is.
- [Arkham Adaptive Counterparty Gate](/developers/vaults/policies/arkham-counterparty): Use Arkham counterparty history in Newton policies to judge a payment against the sending wallet's own baseline.
- [Arkham Explainable Risk Exposure](/developers/vaults/policies/arkham-risk): Use Arkham exposure paths in Newton policies to deny risk you can trace to a specific transaction route.
- [Pharos Risk-Adjusted Treasury Gate](/developers/vaults/policies/pharos-treasury): Use Pharos stablecoin data in Newton policies to admit an asset only when peg, stress, redemption, and exit capacity are all healthy.
- [Pharos Stablecoin Safe Mode](/developers/vaults/policies/pharos-safe-mode): Use Pharos stress signals in Newton policies to block exposure-increasing actions under stablecoin stress while leaving the exits open.
- [Pharos Redemption-Backed Asset Gate](/developers/vaults/policies/pharos-redemption): Use Pharos redemption data in Newton policies to admit a stablecoin only when it can actually be redeemed at par.
- [Overview](/developers/vaults/sdk/overview): VaultKit 2.1 declares typed policies and routes vault-manager actions through Newton attestations.
- [Integration Guide](/developers/vaults/sdk/integration-guide): Install VaultKit 2.1, declare a Newton policy, and run a typed vault-manager action.
- [Policies](/developers/vaults/sdk/policies): Declare VaultKit policies from published packs, custom oracles, or a bare deployed policy.
- [Custom Oracles](/developers/vaults/sdk/custom-oracles): Author a typed policy-data oracle with @newton-xyz/policy-core and compose it into VaultKit.
- [Examples](/developers/vaults/sdk/examples): VaultKit 2.1 recipes for policies, typed vendor calls, generic calls, verification, and blocked-intent assertions.
- [Reference](/developers/vaults/sdk/reference): API reference for @newton-xyz/vaultkit 2.1.
- [Errors](/developers/vaults/sdk/errors): VaultKit 2.1 error classes, stable codes, diagnostics, and retry guidance.
- [Morpho Guide](/developers/vaults/sdk/morpho): How to gate MetaMorpho curator actions with Newton VaultKit and composite policy packs.
- [Morpho Blue](/developers/vaults/sdk/morpho-blue): Use VaultKit's typed Morpho Blue position module for managed lending sleeves.
- [Euler Guide](/developers/vaults/sdk/euler-vault): How to gate Euler Vault Kit EVault governor actions with Newton VaultKit.
- [Euler Earn Guide](/developers/vaults/sdk/euler): How to gate Euler Earn manager and allocator actions with Newton VaultKit.
- [Superform](/developers/vaults/sdk/superform): Gate Superform SuperVault strategy-manager actions and build typed hook bundles with VaultKit.
- [VaultKit Legal Terms](/developers/vaults/resources/legal-terms): VaultKit supplement to the Magic Developer Terms of Service.
- [What is Newton?](/developers/overview/about): Newton Protocol is a decentralized policy engine for onchain transaction authorization, built as an EigenLayer AVS. Enforce spend limits, sanctions screening, fraud prevention, and compliance rules in smart contracts.
- [Core Concepts](/developers/overview/core-concepts): Understand Newton Protocol's key concepts — policies, intents, tasks, attestations, and the evaluation lifecycle. How onchain policy authorization works end-to-end.
- [Quickstart](/developers/overview/quickstart): Simulate your first Newton Protocol policy evaluation in 5 minutes using the TypeScript SDK. OFAC sanctions screening example with step-by-step setup.
- [Build with an Agent](/developers/overview/agent-quickstart): Use Newton Agent Skills to create, test, and optionally deploy a policy, PolicyClient, and local application from a product brief.
- [Dashboard & API Keys](/developers/overview/dashboard-api-keys): Create and manage Newton Protocol API keys for authenticating with the Newton Gateway. Dashboard setup and key rotation guide.
- [Overview](/developers/verified-credential/overview): Integrate user identity and KYC data into Newton policies using Newton Verifiable Credentials.
- [Integration Guide](/developers/verified-credential/integration-guide): Step-by-step guide for integrating Newton Verifiable Credentials into your application.
- [SDK & Contract Reference](/developers/verified-credential/reference): SDK methods and contract functions for Newton Verifiable Credentials.
- [Identity Policy Reference](/developers/verified-credential/identity-policy-reference): Newton identity Rego built-in functions for writing policies that check user identity data.
- [Integration Guide](/developers/guides/integration-guide): End-to-end guide for adding transaction policies to your smart contracts with Newton Protocol. Deploy Rego policies, build WASM data oracles, and verify attestations on-chain.
- [Writing Data Oracles](/developers/guides/writing-data-oracles): Build WebAssembly data oracles that fetch external data for Newton Protocol policy evaluation. JavaScript, Rust, and Python examples with the WIT component model.
- [Writing Rego Policies](/developers/guides/writing-policies): Write Rego policies for blockchain transaction authorization with Newton Protocol. Examples for spend limits, allowlists, sanctions screening, and fraud prevention rules.
- [Uploading & Accessing Secrets in Oracles](/developers/guides/secrets-in-oracles): Declare, upload, and read API keys inside Newton PolicyData oracles. JSON Schema declaration, HPKE-encrypted upload via SDK or CLI, and the newton:provider/secrets WASM host interface.
- [Chaining Multiple Data Oracles](/developers/guides/chaining-data-oracles): Compose more than one PolicyData oracle under a single Newton policy. How outputs are namespaced and merged, how to write Rego that reads two oracles, and how to simulate a multi-oracle policy end-to-end.
- [Policy Packs](/developers/guides/policy-packs): Newton policy packs are deployed data oracles with typed schemas, Rego templates, npm bindings, and onchain PolicyData addresses.
- [Deploying with CLI](/developers/guides/deploying-with-cli): Build, simulate, and deploy Newton policies with newton-cli, then wire a tested PolicyClient with Foundry and cast
- [Smart Contract Integration](/developers/guides/smart-contract-integration): Add policy-based transaction authorization to your Solidity contracts. Deploy a PolicyClient that validates BLS attestation proofs before executing transactions.
- [Frontend SDK Integration](/developers/guides/frontend-sdk-integration): Build a Next.js frontend that signs Newton intents in the browser, evaluates them on the server, and executes attested transactions
- [Using the Dashboard](/developers/guides/using-the-dashboard): Build, simulate, and deploy Newton policies from the browser — no CLI required. Sign in, generate an API key, add data oracles, configure secrets and params, simulate, and deploy a policy bound to your PolicyClient.
- [Testing Policies & Oracles](/developers/guides/testing-policies): Unit-test Newton Rego policies with opa test, test WASM data oracles locally and via the Gateway, and run end-to-end policy simulations before deploying.
- [Privacy Flows](/developers/guides/privacy-flows): Three modes of privacy-preserving data in Newton Protocol — identity, confidential, and ephemeral — with end-to-end integration examples
- [zkTLS Twitter/X Example](/developers/guides/zktls-twitter): Generate a TLSNotary proof for a Twitter/X follower count and submit it to Newton for policy evaluation.
- [Stablecoins & Payments](/developers/use-cases/stablecoins-and-payments): Use Newton Protocol to enforce compliance policies for stablecoin transfers, payment networks, and tokenized asset transactions. Programmable authorization for VISA-like payment rails on Ethereum.
- [AI Agent Security](/developers/use-cases/agent-security): Enforce transaction guardrails for autonomous AI agents using Newton Protocol. Prevent unauthorized spending, set per-action limits, and maintain human oversight for agent commerce on Ethereum.
- [Institutional DeFi](/developers/use-cases/institutional-defi): Enable institutional crypto adoption with programmable compliance policies. Newton Protocol provides verifiable transaction authorization for DeFi protocols, fund managers, and regulated financial products on Ethereum.
- [Architecture](/developers/concepts/architecture): Newton Protocol system architecture — policy definition, AVS operator evaluation, and on-chain verification layers. How EigenLayer operators evaluate and attest to policy decisions.
- [Privacy Layer](/developers/concepts/privacy-layer): Newton Protocol privacy architecture — HPKE encryption, secure envelopes, and confidential policy evaluation. Private transactions with verifiable compliance for institutional and enterprise use cases.
- [Consensus & Security](/developers/concepts/consensus-security): Newton Protocol consensus mechanisms, BLS aggregation, and economic security model. How EigenLayer restaking secures policy evaluation for blockchain compliance and risk management.
- [Multichain Support](/developers/concepts/multichain): Newton Protocol cross-chain policy verification across Ethereum, L2s, and destination chains. Enforce compliance and authorization rules across multiple blockchain networks.
- [TypeScript SDK Reference](/developers/reference/sdk-reference): Complete API reference for @newton-xyz/sdk. Viem client extensions for policy evaluation, task submission, and attestation verification.
- [RPC API](/developers/reference/rpc-api): Newton Gateway JSON-RPC API reference for policy-based transaction authorization
- [Command Line Tool](/developers/reference/command-line-tool): Newton CLI reference for deploying policies, managing policy data, uploading secrets, and submitting evaluation requests
- [Contract Addresses](/developers/reference/contract-addresses): Deployed Newton Protocol contract addresses across all supported networks
- [Error Reference](/developers/reference/error-reference): Newton Protocol error codes, messages, and resolution steps
- [Glossary](/developers/reference/glossary): Definitions of key Newton Protocol terms and concepts
- [Rego Syntax Guide](/developers/advanced/rego-syntax-guide): Supported Rego syntax, builtins, and Newton extensions (crypto, identity) for policy development
- [Encrypting Secrets](/developers/advanced/encrypting-secrets): Securely store API keys and credentials for Newton Protocol PolicyData oracles
- [Policy Data Oracles](/developers/advanced/policy-data-oracles): With Newton Protocol, you can integrate data from other sources into your policy
- [Writing Data Oracles in Python](/developers/advanced/python-wasm-guide): This guide walks you through building a Python newton-provider WebAssembly data oracle using componentize-py.
- [Writing Data Oracles in JavaScript](/developers/advanced/javascript-wasm-guide): This guide walks you through building a JavaScript newton-provider WebAssembly component using ComponentizeJS (@bytecodealliance/componentize-js). 
- [Writing Data Oracles in Rust](/developers/advanced/rust-wasm-guide): This guide provides step-by-step instructions for building a WASI-compatible WebAssembly component from Rust code using the WebAssembly Interface Types (WIT) format.
- [FAQ & Troubleshooting](/developers/resources/faq): Frequently asked questions and solutions to common issues with Newton Protocol — API keys, policy evaluation, chain support, error codes, and debugging.
- [Testing & Debugging](/developers/resources/testing-debugging): Tools and techniques for testing policies, oracles, and attestations during Newton Protocol development
- [Deployment Checklist](/developers/resources/deployment-checklist): Pre-launch verification checklist for deploying Newton Protocol policies, oracles, and PolicyClient contracts
- [Newton Explorer](/developers/resources/newton-explorer): The Newton Explorer showcases the key information available in the protocol. At its core, there are two components: **tasks** and **policies**. This document provides context on the data fields in the explorer and the various states that are possible. 
- [Developer Terms of Service](/developers/resources/developer-terms-of-service): Developer Terms of Service for accessing and using the Newton Protocol developer platform, APIs, SDKs, dashboards, documentation, and related tools.
- [Agent Skills](/developers/reference/context-file): Install Newton Agent Skills for versioned policy, PolicyClient, and application workflows
- [Technical Whitepaper](/whitepaper/introduction): Technical specification of Newton Protocol — an EigenLayer Actively Validated Service (AVS) for policy-based authorization of blockchain transactions. Covers cryptographic primitives, consensus, and security model.
- [Privacy Architecture](/whitepaper/privacy-architecture): Newton Protocol's layered privacy architecture: HPKE encryption, threshold decryption, MPC evaluation, and the Newton Privacy Envelope.
- [BLS Attestation Protocol](/whitepaper/bls-attestation): BLS signature scheme on BN254, the Two-Digest System, aggregation algorithm, and ECDSA attestations in the Newton Protocol.
- [Streaming Consensus Protocol](/whitepaper/streaming-consensus): Newton's two-phase streaming consensus protocol: distributed WASM data collection, median-based normalization, and NATS messaging architecture.
- [Cross-Chain Interoperability](/whitepaper/cross-chain): Source and destination chain model, operator table synchronization, BLS verification, and cross-chain security model in the Newton Protocol.
- [Slashing and Challenge Mechanism](/whitepaper/slashing-challenge): Economic deterrents, challenge windows, ZK proof generation, and dispute resolution in the Newton Protocol.
- [Policy Engine and Composability](/whitepaper/policy-engine): Newton Rego policy language, cryptographic extensions, WASM-sandboxed data providers, content addressing, and multi-plugin composition.
- [Decentralization Guarantees](/whitepaper/decentralization): Operator set model, BLS quorum requirements, deterministic evaluation, and mechanisms ensuring no single point of failure in the Newton Protocol.
- [Security Properties](/whitepaper/security-properties): Formal threat model, rogue key attack prevention, cryptographic security reductions, post-quantum readiness, and performance characteristics of the Newton Protocol.
- [References and Appendix](/whitepaper/references): Standards, cryptographic primitives, privacy-preserving computation references, and the Newton Privacy Envelope binary wire format specification.
- [Project & Protocol](/protocol/overview/project-and-protocol): Newton Protocol overview — decentralized policy engine for onchain transaction authorization. Enabling compliant DeFi, institutional crypto adoption, and enterprise blockchain applications.
- [Security (Bug Bounty)](/protocol/overview/bug-bounty): Report security vulnerabilities in Newton Protocol through the bug bounty program
- [Structure & Key Contributors](/protocol/foundation/structure-and-key-contributors): Magic Newton Foundation organizational structure and key contributors
- [Conflict of Interest & Code of Conduct](/protocol/foundation/conflict-of-interest-and-code-of-conduct): Foundation conflict of interest policy and code of conduct
- [Characteristics & Utility](/protocol/token/characteristics-and-utility): NEWT token characteristics, utility, and role in the Newton Protocol ecosystem
- [Distribution & Vesting](/protocol/token/distribution-and-vesting): NEWT token distribution allocations and vesting schedules
- [Newton Protocol & NEWT Transparency Reports](/protocol/transparency-reports/reports): Newton Foundation quarterly transparency reports
- [Newton Protocol Governance Model](/protocol/governance/governance-model): Newton Protocol governance model and decision-making framework
- [Balancer Data Checks](/developers/vaults/policies/balancer): Use keyless Balancer data in Newton policies for vault manager-action gates.
- [Blockaid Transaction Screening](/developers/vaults/policies/blockaid): Use Blockaid data in Newton policies to screen transaction and address risk before vault manager actions execute.
- [Guardrail Risk Checks](/developers/vaults/policies/guardrail): Use Guardrail data in Newton policies as an optional risk signal for vault manager actions.
- [Persona Identity Checks](/developers/vaults/policies/persona): Use Persona data in Newton policies for identity or verification-based vault gates.
- [Sumsub Verification Checks](/developers/vaults/policies/sumsub): Use Sumsub data in Newton policies for KYC or verification-aware vault gates.
- [SDK Concepts](/developers/vaults/sdk/concepts): How VaultKit 2.1 models policies, resolved modules, vendor extensions, intents, and verification.
- [Shield Architecture](/developers/vaults/shield/architecture): How Shield contracts are deployed, addressed, initialized, and bounded onchain.
- [Deployment](/developers/vaults/shield/deployment): Deployment and ownership notes for Shield implementations, factories, clones, and upstream Newton addresses.
- [Shield Flows](/developers/vaults/shield/flows): Execution modes and bypass-timelock flows for Newton Shield.
- [Shield Reference](/developers/vaults/shield/reference): Public contract surface for Shield and ShieldFactory.
- [Storage Layout](/developers/vaults/shield/storage-layout): How Shield storage layout is protected for EIP-1167 clones.