How the Authorization Layer Works When people talk about a blockchain transaction, they usually picture the moment the money moves from one wallet to another. But that moment is only one part of the process. A lot has to happen behind the scenes before a transaction is allowed to go through. In traditional finance, entire teams check every payment for legal problems, fraud, and security risks before it clears. Crypto has mostly left those checks off the blockchain, where they're applied unevenly and are hard to confirm. If blockchain is going to go mainstream, moving money can't be the only thing we get right. The checks that decide whether a transaction should happen at all need to live on the blockchain too, and work safely at scale. That missing piece is the problem Newton was built to solve. Why rule-checking needs its own system Today, if you wanted to enforce those kinds of checks on the blockchain in a way anyone could confirm, you'd have to build them into your app's blockchain code and hook up outside data sources yourself. That code isn't built for this. Complex checks run slowly and expensive. Every change means relaunching the code. And each addition creates new openings for attackers. Newton is built from the ground up to do one thing: check transactions against rules, then approve or block them. That focus is what makes the rest possible. Rules are written in Rego Newton's rules, called policies, are written in a language called Rego, for two main reasons. First, Rego is widely used outside blockchain. IT teams at large companies already use it to enforce their internal rules, so there are plenty of tools and guides for it. Second, it's much more flexible and easier to work with than the languages blockchain apps are usually written in, like Solidity. With Rego you can write detailed rules covering all sorts of conditions on a transaction, and Newton is built to make full use of that. How a transaction gets approved, step by step Newton is run by a network of independent, neutral participants, called operators, who check transactions against these rules and sign off on the result. Here's how a single transaction moves through the system: The request. Someone wants to make a transaction on a blockchain. That could be sending money from one wallet to another, or a fund manager deciding where a crypto investment fund puts its money. Newton works with Ethereum and Base today, with more blockchains on the way. The check. Each operator receives the transaction along with the rules it needs to pass. The rules can pull in information from outside sources, so each operator fetches the latest data at the moment of checking. Newton works with data companies such as Chainalysis, RedStone, vaults.fyi, and Webacy. A rule might look at how much a fund has paid out over time, a risk rating from an outside company, or how much prices have swung in the last 24 hours. Together, those signals show which transactions are safe and which are riskier. If the built-in sources don't cover what you need, you can add your own. The code that connects to your data source is packaged as a small, sealed-off program that every operator can run safely. Agreement. No single operator decides the outcome. Once Newton is out of its testing phase, many operators check the same transaction separately, and the network only gives approval once enough of them agree. What keeps them honest is money: every operator puts down a deposit (Newton runs on EigenLayer, a system where operators lock up ETH as that deposit). If an operator approves something it shouldn't, anyone can challenge it within a set time and prove the mistake mathematically. An operator caught this way loses part of its deposit. Cheating costs far more than it could ever earn. The approval. Once enough operators agree the transaction passes, their individual approvals are combined into a single compact digital stamp that means "most of the network checked this and got the same answer." It confirms that this specific transaction, checked against these specific rules, is allowed to go ahead. The simplest way to picture it: Newton gives each transaction a green light or a red light. The final gate. That stamp travels with the transaction back to the blockchain where it's meant to happen. A small piece of code in your app checks the stamp and acts as the final gate. Newton's green light or red light is what actually lets the transaction through or stops it. Anyone can check it, and private data stays private What really makes this work is the Newton Explorer, a public record of every task. A task is a transaction together with the rules it was checked against. Anyone can look up what was checked and why. That openness matters. This isn't a hidden system that asks you to take its word for it. Newton handles sensitive data inside secure, sealed-off hardware, so the data stays private even while it's being checked. The result: anyone can confirm the rules were applied correctly, while the private details behind them stay private. You get both openness and privacy in one system. This is especially useful for meeting legal requirements. As anti-money-laundering and identity-check rules tighten in the US and around the world, many projects try to block bad actors at the website level. Newton enforces those rules on the blockchain itself, inside your app's code, without revealing anyone's identity. As a developer, that lets you say with confidence that you're following the rules, and back it up with a public record in the Newton Explorer that shows exactly how. Getting started Newton has teamed up with data companies on a ready-made set of rules called the policy stack. You can open the Newton dashboard, pick the pieces your app needs, and adjust them as you like. https://vaultkit.newton.xyz