Mir Zad Bibi

Family runs a small trading business, and the account needs any two of three signatures for anything above a certain amount, my father and two uncles are the authorized signatories. Bank cashier once held up a payment for a whole afternoon because one uncle's signature had drifted slightly from the specimen card on file, wanted it re-verified before releasing the funds. Two completely different checks happening there, does the ink actually match this person, and separately, is this person even on the approved list.
I assumed Newton's policy engine only handled the second part, the rules about who's allowed to sign, and left the actual signature matching to some separate cryptographic layer sitting outside Rego entirely, same split as my bank.
That's not how section seven describes it.
Newton extends standard OPA Rego with its own newton dot crypto namespace, kept cleanly separate so regular Rego tooling still works, but inside that namespace a policy can recover an actual signer straight from a raw signature. The multisig example makes this concrete, a policy requiring two of three approvals calls ecdsa recover signer on each submitted signature, pulls out the real Ethereum address behind it, checks that address against the authorized signer list, and only allows the transaction once two genuine matches are counted. One file doing what my bank splits across a cashier's eye and a separate signatory lookup.
The delegation chain example is where it actually got interesting for me. Alice delegates signing authority to Bob, Bob signs the actual transaction intent. The policy recovers two different signers in one pass, who signed the intent itself, and separately who issued the delegation document. It checks the delegator is an authorized principal, checks the delegation actually names Bob as the delegate and not someone else, and checks it hasn't expired. That's basically a power of attorney check done in code, verifying the agent's real signature and separately verifying the document granting them authority hasn't lapsed, in one evaluation instead of two separate desks.
What sold me on this being more than a whiteboard example is that Rego stays a pure functional language even with these additions, same inputs and same policy always produce the same result, which is exactly what let Newton's zero knowledge layer make any of this provable later without touching the policy logic itself.
What I haven't worked out is how signatory changes actually happen in practice. The authorized signer list lives in external policy data, not hardcoded into the Rego file itself, based on how the examples reference it. That would suggest swapping a signatory, my uncle stepping back and a cousin taking over, say, might just be a data update rather than republishing the whole policy under a new IPFS hash. The paper doesn't spell out that operational detail directly, so I'm inferring it rather than quoting it.
The real test for $NEWT isn't whether the multisig and delegation examples read cleanly on paper, it's whether swapping out a real signatory stays that lightweight once actual businesses are running policies day to day.
Anyone dealt with updating authorized signatories on a joint or business account? Curious how much paperwork it actually took on your end.
@NewtonProtocol #Newt $NEWT
$LAB $VANRY

Building a small house on family land outside the city for the last year and a half. Ground floor's done, we're actually living in it. Second floor has the columns up and the steel showing, contractor keeps saying give it one more season. Then there's the rooftop solar setup that comes up at every family dinner, something everyone wants, nobody's paid a rupee toward yet, no date attached, just "later, once things settle."
Three completely different stages of the same house, and everyone in the family already knows which is which. Nobody's confused into thinking the solar panels are already up there.
I went into Newton's privacy section expecting the whitepaper to talk about "privacy" the same flat way most projects do, like it's one single thing that's either there or not. Section six actually splits itself into stages the same way my house did, and reading it that way is what made it click.
Layer one is the ground floor, actually lived in right now. Every sensitive input, identity data, financial records, gets encrypted client side using HPKE, the same RFC 9180 standard, X25519 for the key exchange, ChaCha20-Poly1305 doing the actual encryption. Clients just call one contract to get the system's combined public key, no coordination needed on their end. During evaluation, operators pull together enough threshold shares to reconstruct the plaintext, run the policy against it, then sign. Reconstruct is the word that matters here, operators genuinely do see the data for that window, dual signatures from both user and app are required just to get that far. Nothing hidden about that limitation, it's stated plainly.
Layer two is the columns and steel, visibly underway. This is MPC, operators computing jointly over secret-shared data without any single one of them ever reconstructing the plaintext at all. What convinced me this isn't just a nice diagram is a cited benchmark, honest-majority three-party MPC hitting over a billion gates per second in LAN conditions, which is actually fast enough for policy evaluation at the latency Newton needs. Same operators who sign BLS attestations today become the compute parties here, same EigenLayer stake backing it. Structurally ready, not fully deployed.
Layer three is the rooftop solar, the one that comes up at dinner with no date attached. Fully homomorphic evaluation, computing directly over encrypted data with no decryption at any stage, tracing back to Gentry's 2009 bootstrapping proof. The paper's own number stopped me, FHE currently runs somewhere between a thousand and a million times slower than plaintext computation depending on the circuit. Called a multi-year research effort in the paper's own words, not a roadmap item with a quarter attached.
What actually impressed me is the paper says a future FHE swap would be transparent to clients, same encrypted inputs, same Rego policies, same BLS-attested outputs, only what happens on the operator's side would change underneath. Whether that holds up when it's actually attempted years from now isn't something anyone can promise today.
What's missing for me is any real timeline on layer two specifically. "Active development" could mean two quarters or two years, and the difference actually matters if you're deciding how much to trust the privacy story right now versus later.
The real test for $NEWT isn't whether three tiers sound honest on paper, it's whether layer two actually ships on a timeline someone's willing to commit to, instead of sitting in "active development" the way my solar panels sit in "once things settle."
Anyone else got a phased project at home where stage two's been "almost there" for way longer than promised?
@NewtonProtocol #Newt $NEWT
$HMSTR $LAB

Spent parts of two different weeks last year running my cousin's degree attestation for a Gulf job offer. University issues the original. Then it goes to HEC. Then the Ministry of Foreign Affairs. Then the target country's embassy. Four separate offices, four separate stamps, and at every single one of them, someone actually opens the folder and reads the paper inside.
I figured digital identity credentials in something like Newton would basically be a faster version of that, every checkpoint still opening the file and reading what's inside, just done through an API instead of a counter window.
Reading section six properly, the three roles don't work that way at all.
Issuers are the university equivalent here, the entity that actually attests to something about you. A KYC provider, a government agency, a bank, even an onchain analyzer that's watched your wallet's history over time. They sign a credential and hand it over, done. Holder is you, and this is where it splits from the folder my cousin carried between offices. Your credential sits encrypted in your own wallet, and you choose when and to whom you show it, and you can prove one specific fact off it, say your jurisdiction is permitted, without ever revealing the actual country or address underneath.
Verifier is the part that actually changed how I think about this. Newton's identity oracle checks the proof inside a TEE enclave, and what comes out the other side is basically a yes or a no, not the underlying data itself. The embassy clerk who checked my cousin's papers saw his full name, his university, his transcript. Newton's verifier structurally can't see any of that, the result just folds straight into the policy check.
The credential categories table is what made this concrete instead of abstract. KYC and KYB run through issuer signature plus TEE. Sanctions and watchlist status get a real time feed plus attestation, so it refreshes instead of sitting static like a stamped page from years back. Financial credentials, credit score or income, run through issuer signature plus a zero knowledge proof, meaning a lender confirms you clear a threshold without ever learning your actual number. Onchain behavior gets checked through onchain analysis plus attestation. Jurisdiction pairs issuer signature with selective disclosure. Accreditation is just an issuer signature on its own, the simplest of the seven. Travel Rule attribution needs issuer signature plus the credential itself, tied to the specific compliance transfer it's covering.
What I haven't worked out yet is portability in practice. The paper says a KYC credential verified once for one application can get reused elsewhere without repeating the process, which sounds a lot like what attestation offices already claim, that once HEC signs off, nobody downstream should need to recheck from scratch. In practice everyone downstream still rechecks anyway. Not clear to me yet if Newton's verifiers actually trust each other's prior attestations the way that's described, or if every new application ends up demanding its own fresh proof regardless of what already got verified.
The real test for $NEWT isn't the three roles looking clean on a diagram, it's whether a credential verified once by one application actually gets accepted downstream without a second full recheck, the exact promise attestation offices already make and don't really keep.
Anyone here gone through degree or document attestation for a job abroad? Curious how many separate offices ended up touching your paperwork before it finally counted as done.
@NewtonProtocol #Newt $NEWT
$VELVET $LAB

Got stopped near a toll plaza on the motorway two weeks back, token tax paid and receipt in hand from an Islamabad office barely two months old. The guy checking couldn't pull it up on his end. Ended up standing there almost twenty minutes while he rang someone to confirm the payment was real before waving me through.
I walked away thinking that's just how it works, you pay once at the source, but every single checkpoint down the line has to independently trust it, and if their system's not synced, you're stuck till a phone call sorts it out.
That memory sat with me while I got into Newton's cross-chain section this week, because operators face almost the exact same problem, just at a much bigger scale and with real money attached.
My first read, I figured cross-chain just meant an operator signs up separately on every chain Newton runs on, register on Arbitrum, register again on Base, same paperwork four or five times. Or worse, some third party sitting in the middle relaying operator info between chains, basically the crypto version of that phone call at the toll booth, a trusted go-between everyone has to wait on.
Neither is actually what's happening.
Newton splits this into a source chain and a set of destination chains, and it's a real split, not just naming. Ethereum is the source, that's where an operator actually registers, stakes restaked ETH through EigenLayer, and where slashing happens if they misbehave. Arbitrum, Optimism, Polygon, Base, these are destination chains, they're where the actual policy evaluation and transaction authorization runs. An operator never re-registers on any of them.
Here's the part that clicked for me. Whenever something changes on the source chain, new operator joins, someone gets slashed, stake gets updated, the operators themselves collectively produce a BLS-signed Merkle root of the current operator table. Not a company, not a designated bridge, the operator set signs its own updated record. That signed root then gets carried to each destination chain by relayers, and the paper's specific that these relayers are permissionless, anyone can run one. The destination chain just checks the aggregate signature against the operator set it already knows, and updates itself. No phone call, no waiting on a trusted middleman, the proof carries its own trust.
That's also why it lines up with EigenLayer's ELIP-008 multi-chain verification spec instead of Newton inventing something from scratch, which honestly made me trust the design a bit more.
Practical result is a policy written once runs the same everywhere Newton operates, same operators, same stake backing it, same slashing rules, regardless of which chain the transaction actually lands on.
Where I'm stuck is the relayer side. Permissionless is great in theory, but somebody still has to actually run one and bother carrying that signed root over. The paper doesn't say what happens in the gap if no relayer picks it up for a while, or what incentive keeps them showing up consistently. Might just be sitting in the technical whitepaper and I haven't gotten to it yet.
The real test for $NEWT isn't the source and destination chain split looking clean on paper, it's whether that sync actually stays fast enough once operator sets start changing often across five or six chains at once, not just this simple two chain example.
Anyone dealt with a paid registration or tax record not showing up yet at a different office or checkpoint? Curious how long yours took to actually sync up.
@NewtonProtocol #Newt $NEWT
$TAIKO $VELVET

Me and three friends had a small bet running last weekend on where BTC would close Sunday night. Nothing big, just bragging rights and a round of chai on the loser. When the moment came to actually check, we all pulled out our phones at once. Mine showed one number, my friend's Binance app was a few dollars off because his had lagged for a second, and a third guy was looking at a completely different exchange. We spent almost ten minutes arguing about whose number counted before somebody just said screw it, we'll all refresh together and use that one.
That memory came right back to me reading Newton's Prepare/Evaluate section this week.
My first assumption was the obvious one, more operators independently checking a sanctions list or a price feed sounds like extra safety, more eyes catching more problems. Turns out that's only half the story, and the part I missed is actually the harder engineering problem. If every operator fetches live data on its own, through its own network path, at its own moment, they will almost never get the exact same number back. Prices tick constantly. A feed updates mid request. That's just what independent fetching looks like in practice, my little bet proved that with four phones in the same room.
Here's where it gets serious though. Newton's attestations rely on BLS signature aggregation, and that only works if every signer is signing the literal same message. Not a similar message, not a close enough number, the identical bytes. So if five operators each evaluated a policy against their own slightly different price or sanctions snapshot, you'd get five different results and five signatures that can never combine into one valid attestation. The whole system would just stall out.
Once that clicked, the two phase split stopped looking like extra complexity and started looking like the only way this could actually work.
Prepare phase is where the independence happens. Every operator runs its own sandboxed data fetch, on its own path, no one waiting on the slowest node, streaming answers back as they finish. Then the Gateway takes all those independent numbers and runs a median across them, producing one canonical dataset. Evaluate phase is where agreement happens. That single canonical dataset goes back out, operators pull the actual Rego policy off IPFS by its content hash so they're all running the exact same rule file, evaluate against the exact same data, and only then sign. Same policy plus same data equals identical digest, and that's what makes the signatures aggregate cleanly. The aggregator doesn't even wait for everyone, it stops the moment enough stake weighted operators clear quorum.
Small detail I liked, not every transaction needs the full two step dance. If the policy data is already fixed or cached, Newton skips straight to evaluation in one round trip instead of two.
Where I'm still a bit stuck is who I'd trust to compute that median honestly. The Gateway is the one producing the canonical number in between the two phases, and the paper is clear the Gateway can't forge a signature or alter a result without operators catching it, since each one already attested to what it personally observed in the Prepare phase. What I couldn't find spelled out is whether operators actually cross check that median against those original attestations before signing in Evaluate, or whether they just trust what gets republished to them. Maybe that's in the technical whitepaper and I just haven't gone through it properly yet.
The real test for NEWT isn't whether the two phase design works on a whiteboard, it's whether that median step stays honest and fast enough once the data being fetched moves in milliseconds, not something you can settle with a chai bet and a reload.
Anyone else had a group argument over whose app had the "real" price before settling something? Curious how you all ended up picking one number.
@NewtonProtocol #Newt $NEWT
$SYN
$LAB

Three different apps asked me for the same KYC documents this month. Same selfie, same ID, same address proof, uploaded three separate times for three platforms that have nothing to do with each other. By the third one I was just annoyed, not because the process is hard, but because none of them remember me from the last one.
That frustration is basically why I kept rereading the "Three Pillars" section of Newton's whitepaper instead of skimming past it like I usually do with architecture sections.
My first read, I treated Verifiable Credentials, programmable policies, and cross-chain operators like three separate features you'd list on a comparison chart. Pick the one you need. Identity verification, that's pillar one. Rule writing, pillar two. Multi-chain support, pillar three. Three checkboxes.
Second read changed that completely.
None of these three actually do anything on their own. A verifiable credential sitting in your wallet proving you're KYC'd and not sanctioned is just data, it doesn't stop a transaction or approve one. It needs something to check it against. A Rego policy that says block sanctioned addresses, cap daily transfers, require accredited status is just a rulebook with nothing to evaluate, it needs identity data feeding into it before it means anything. And operators running consensus across Ethereum and chains like Arbitrum or Base are just validators with no job if there's no policy to evaluate and no credential to verify in the first place.
Pull any one leg out and the other two are dead weight.
The whitepaper's own walkthrough makes this obvious once you actually trace it. A $50k USDC transfer gets submitted, operators don't just check one thing, they pull the sender's jurisdiction and sanctions status from their credentials, run that data through the composed policy stack, sanctions check, velocity limit, source of funds, and only then sign off, BLS-aggregate the signatures, and hand back one attestation the smart contract can verify. That's not three products stacked on top of each other. That's one motion where credentials feed the policy and operators are the ones actually running it, across whichever chain the transaction happens to land on.
There's a neutrality piece that makes this click even harder. A bank running strict accredited-investor checks and a DeFi protocol that barely gates anyone can run on the exact same operator network, same credential system, same policy engine, just configured completely differently. That only works because the three pieces aren't bundled into one fixed product, they're more like three slots that get filled differently depending on who's plugging in. Same engine, different policy plugged in, different credential requirements checked, still one mechanism underneath both.
Where I land now is that the "three pillars" framing undersells it a bit. It's less like three pillars holding up a roof and more like one mechanism with three moving parts, take one out and the other two seize up.
What I'm still not sure about is the portability promise in practice. Verified once, reused everywhere sounds great on a whitepaper page, but getting competing platforms to actually accept someone else's verification instead of running their own is a business problem as much as a technical one. The crypto exchanges I deal with for my KYC headaches each have their own reasons to want my documents in their own system. Whether Newton's neutrality pitch is enough to get them trust a shared credential instead of hoarding their own data, that's the part the architecture diagram can't answer for me.
The real test for NEWT isn't whether the three pillars work together on paper, it's whether enough platforms actually plug into the same operator network instead of each building their own walled version of it.
Anyone else dealt with the repeat-KYC grind across multiple platforms this month? Curious if this kind of shared verification model would actually get adopted or if everyone just keeps hoarding their own user data anyway
@NewtonProtocol #Newt $NEWT
$VELVET
$RE