Ruoxi 若曦

@NewtonProtocol Чесно кажучи… Коли я вперше приєднався до ончейн-кампанії, я думав, що кожен гаманець уособлює реальну людину. Не знадобилося багато часу, щоб зрозуміти, наскільки я помилився. Один користувач міг створити десятки гаманців, боти могли за лічені хвилини заполонити програми винагород, а спільноти не мали надійного способу відрізнити справжніх учасників від одноразових акаунтів.
Чесно кажучи, це одна з найбільших проблем Web3 досі не повністю вирішив.
Ми часто святкуємо децентралізацію, але децентралізація без довіри створює власні проблеми. Агентии ШІ стають дедалі спроможнішими, DeFi стає більш автоматизованим, а блокчейн-додатки обробляють дедалі більше цінності, ніж будь-коли. Та все ж багато протоколів досі не можуть дати відповідь на одне просте питання: Хто має бути допущений до взаємодії ще до того, як відбудеться транзакція?

@NewtonProtocol Довгий час я думав, що стейблкоїни — це просто «нудна» сторона крипто. Вони не розганяються на 100% за ніч, рідко домінують у заголовках, і більшість людей згадують про них лише тоді, коли ринки починають хитатися.
Тоді я почав уважніше стежити за тим, як саме гроші реально рухаються в ланцюжку.
Саме тоді я зрозумів одну цікаву річ. Справжня інновація вже не в самому стейблкоїні. Вона — в усьому, що відбувається до того, як платіж схвалюють, під час його руху та після того, як він завершується.
І саме тут Newton Protocol привернув мою увагу.

@NewtonProtocol Пробую бути відвертим… Декілька місяців тому, якби хтось запитав мене, чого бракує блокчейн-інфраструктурі, я, ймовірно, говорив би про швидші транзакції, дешевші комісії за газ або кращу масштабованість. Це очевидні відповіді. Але після того, як я витратив час на читання whitepaper і документації для розробників Newton Protocol, я зрозумів, що є інша проблема, якій приділяють недостатньо уваги.
Блокчейни неймовірно добре справляються із виконанням транзакцій.
Вони не дуже добре вміють вирішувати, чи взагалі мають відбуватися такі транзакції.

@NewtonProtocol I’ll Be Honest… A few years ago, if someone told me that a simple Twitter/X follower count could become a cryptographically verified input for a blockchain policy, I’d probably have laughed. Social media numbers felt too easy to fake—screenshots, edited profiles, purchased followers, you name it. But after digging into Newton Protocol’s zkTLS Twitter example, I realized the interesting part isn’t the follower count itself. It’s the way the data gets verified before it ever reaches a smart contract.
That changed how I think about Web3 infrastructure.
Newton Protocol isn’t trying to turn every website into a blockchain. From what I’ve seen in the whitepaper and developer documentation, it’s solving a different problem. Smart contracts are deterministic, but the real world isn’t. Contracts can’t naturally verify whether someone passed KYC, owns a verified social account, or satisfies an off-chain condition. Newton acts as a decentralized authorization layer that evaluates trusted external data before an on-chain action is approved.
The zkTLS Twitter/X example is a surprisingly practical demonstration of this idea.
Instead of trusting a screenshot or a centralized API response, the user opens a browser integrated with a TLSNotary-compatible extension. During the HTTPS session with a TLSNotary proof is generated. What’s clever here is that the proof doesn’t simply say, “Trust me, I have 10,000 followers.” It proves that the response genuinely came from Twitter’s servers while allowing selective disclosure of only the information the policy actually needs. That’s one of the biggest strengths of zkTLS—verifiable data without exposing everything else.
I actually think this is where blockchain starts becoming useful beyond token transfers.
The flow itself is pretty straightforward once you understand the moving parts.
The browser communicates with the TLSNotary extension, which creates an attester session through Newton’s zkTLS sidecar. After retrieving the follower count from Twitter/X, a cryptographic proof is generated instead of a screenshot. That proof is stored, producing a Content Identifier (CID), and Newton receives a task containing the proofCid, policy-specific wasmArgs, and a transaction intent.
The decentralized operator network can then evaluate whether the account satisfies the configured follower threshold before returning the authorization result.
No guessing.
No manual verification.
No trusting whoever submitted the claim.
One implementation detail I genuinely appreciate is the proof integrity verification.
Before accepting any proof, the SDK retrieves the proof bytes using the CID and independently recalculates the multihash. If the bytes don’t reproduce the exact CID, the request fails immediately. The client also performs this verification immediately after storing the proof, ensuring the gateway didn’t substitute different content behind the same reference. Only SHA2-256 multihashes are accepted, reducing ambiguity and preventing unsupported hashing algorithms from entering the workflow.
Honestly, this sounds like a small engineering detail, but it’s exactly these boring safeguards that usually separate production infrastructure from flashy demos.
Another thing I found interesting is that Newton deliberately keeps the proof storage interface stable even though the backend is expected to migrate from IPFS-backed storage toward gateway-managed PostgreSQL persistence. Developers continue interacting with the same store() and retrieve() APIs while the infrastructure evolves underneath.
That’s good protocol design.
Applications don’t need to be rewritten every time backend architecture changes.
The future roadmap also hints at something much bigger than follower verification.
Newton plans to bind zkTLS proofs with encrypted identity records. Instead of submitting only a proof CID, developers could attach encrypted identity references, allowing policies to simultaneously validate proof freshness, identity domains, jurisdiction, and even chain-specific requirements before authorizing execution.
Imagine combining verified identity, jurisdiction rules, sanctions screening, and web proofs into one authorization decision.
That’s no longer just an oracle.
That’s programmable trust.
And AI agents immediately come to mind.
Everyone talks about autonomous AI managing wallets or executing DeFi strategies, but very few discuss authorization. AI making decisions is exciting until it accidentally signs something it shouldn’t.
Newton’s policy engine feels like a guardrail.
Instead of blindly allowing every transaction, policies can ask questions first.
Does this wallet belong to a verified identity?
Does the submitted proof still meet freshness requirements?
Does this action exceed spending limits?
Does this transaction satisfy compliance policies?
Only after every condition passes does the transaction move forward.
For DeFi, that could mean automated vaults enforcing real-world constraints instead of relying entirely on frontend interfaces.
For stablecoins, payment networks, or tokenized assets, it introduces something that traditional finance has relied on for decades—authorization before settlement.
I also like that Newton doesn’t force developers into a single use case.
The Twitter example happens to verify follower counts, but the underlying pattern works almost anywhere trusted web data exists.
Subscription status.
Bank confirmations.
Employment verification.
Age checks.
Identity attributes.
Any HTTPS response that can be proven through zkTLS could theoretically become policy input.
That’s much broader than social verification.
That said, I don’t think this solves every trust problem overnight.
zkTLS still depends on trusted notaries participating in the verification process. The cryptography is powerful, but users still place trust in the verifier infrastructure rather than magically eliminating trust altogether. That’s an important distinction that sometimes gets lost in crypto conversations. Even the TLSNotary team emphasizes that zkTLS is publicly verifiable only within the designated verifier trust model, not completely trustless in the way many people imagine.
And, of course, there’s the practical side.
Running browser extensions, sidecars, gateways, deployed policy clients, API keys, and operator infrastructure isn’t exactly beginner-friendly today.
The developer experience is improving, but I wouldn’t call it plug-and-play yet.
Still, that’s normal.
Most foundational infrastructure starts out looking complicated before becoming invisible.
Looking at Newton Protocol as a whole, I don’t think the real innovation is proving someone’s Twitter followers.
The interesting part is creating a decentralized authorization layer where verifiable web data, AI decision-making, identity systems, and blockchain execution finally speak the same language.
If that vision keeps maturing, we may eventually stop asking whether blockchain can trust off-chain information.
Instead, we’ll start asking what new applications become possible once it can.
#Newt $NEWT
$TAC
$US