BTC S

Giving an AI agent control of a private key feels like crossing a line. It's one thing to let software execute trades faster than any human could; it's another to trust it with decisions that can move real money. The biggest risk isn't a coding mistake. Bugs get fixed. What worries people is whether an AI can handle the unexpected—the moments when markets stop behaving according to the textbook.
Markets are driven by stories as much as statistics. A surprise comment from a central banker, a rumor spreading across social media, or growing doubts about a stablecoin can change sentiment within minutes. Humans often rely on experience and intuition in these situations. AI, on the other hand, works within the boundaries of data and predefined rules. It reacts quickly, but that doesn't necessarily mean it understands the bigger picture.
That's what makes @NewtonProtocol interesting. Instead of trying to build the smartest AI agent in crypto, it focuses on something far more practical: making AI decisions verifiable. For institutions, that may matter more than squeezing out another percentage point of trading performance. Banks, asset managers, and regulated firms care about accountability just as much as efficiency.
Newton combines Trusted Execution Environments (TEEs) with Zero-Knowledge proofs to create a system where AI agents can execute strategies while proving they stayed within predefined limits. Position sizes, approved counterparties, or compliance rules can all be verified without revealing the proprietary logic behind the strategy itself. That balance between privacy and accountability is one of the protocol's strongest ideas.
Its policy engine follows the same philosophy. Rather than detecting problems after a transaction settles, it attempts to prevent risky actions before they happen. Integrations such as Webacy demonstrate this approach by allowing transactions to be blocked automatically if a stablecoin falls outside predefined safety thresholds. It's a proactive way of managing risk instead of simply reacting after losses occur.
The biggest opportunity for Newton isn't retail trading—it's institutional finance. Quantitative funds and regulated asset managers want the efficiency of automation, but they also need systems that can survive audits and satisfy compliance requirements. Newton offers a way to prove that rules were followed without forcing firms to expose the models that give them a competitive edge.
That doesn't mean the protocol is without challenges. Validator transparency remains an open question, and relying on Trusted Execution Environments introduces hardware-related risks that software alone cannot eliminate. The token allocation also deserves attention, as significant insider ownership naturally raises concerns about long-term incentives and governance concentration.
Perhaps the greatest challenge is adoption itself. Enterprise infrastructure moves slowly. Financial institutions rarely replace existing workflows unless the benefits clearly outweigh the costs. Newton is betting that demand for verifiable AI governance will eventually become strong enough to justify that transition.
Ultimately, Newton Protocol isn't trying to convince the market that AI can make perfect decisions. It's trying to prove those decisions can be trusted. Whether that becomes a competitive advantage will depend less on the technology itself and more on how institutions, regulators, and the broader crypto ecosystem evolve over the coming years.
#newt $NEWT

機関がブロックチェーンを実験しているのを見ているほど、これまで私たちがずっと別の問いをしてきたのではないかと疑問に思います。銀行や金融機関をオンチェーンにすることが話題になりますが、その多くはいまだに「なぜ多くの企業が慎重なのか」を立ち止まって問い直そうとしません。
最初は答えは規制だと思いました。次に、それが技術そのものなのかもしれないとも考えました。そして今は、もうそうとも言い切れません。
ためらいの大きな部分は、もっとずっと単純なことに起因していると思います。伝統的な金融では、プライバシーは特別な機能として扱われていません。プライバシーはシステムの仕組みの一部にすぎないのです。顧客は自分の金融情報が非公開に保たれることを期待しています。企業は、競合他社にすべての資金移動や取引の判断を見られたくありません。規制当局は必要なときに情報にアクセスできますが、それは世界中の人がそれを見ていいという意味ではありません。

The more I think about onchain vaults, the more I realize the hardest problem isn't security. It's trust. Not trust in the blockchain itself, but trust in the people running the system.
That's always felt like an uncomfortable contradiction to me. We talk about transparent finance, yet many important decisions still happen behind the scenes. Someone decides whether a transaction fits the rules. Someone signs approvals. Someone interprets risk limits when markets become volatile. Even in systems built on smart contracts, people often remain the final layer of enforcement.
That works until it doesn't.
As more traditional financial firms start paying attention to digital assets, I don't think they're asking whether DeFi is fast enough or efficient enough anymore. They're asking a simpler question: can this operate in a way that's predictable? If a fund has strict investment policies or regulatory obligations, those rules can't depend on someone remembering a checklist during a stressful market event.
That's why VaultKit caught my attention. Not because it's another vault product, but because it seems to approach trust from a different angle. Instead of assuming people will always enforce policies correctly, it asks whether some of those responsibilities should be built directly into the infrastructure.
I actually think that's a more practical way to look at governance.
Most organizations already know what their policies are. They know how much risk they're willing to take, which assets they can hold, and what approvals are required. The difficult part has never been writing those rules. It's making sure they're applied consistently every single time, especially when markets are moving quickly and pressure is high.
I've seen enough systems over the years to know that failures usually don't begin with dramatic hacks. More often, they start with small exceptions. Someone skips a step because they're in a hurry. A manual review gets delayed. A decision that was supposed to follow a process ends up relying on judgment instead. Those little compromises don't always matter, but sometimes they're exactly where bigger problems begin.
That's where programmable policy starts to make sense. Not because code is perfect, but because software doesn't get tired, distracted, or tempted to ignore a process for convenience. Of course, people still decide what the policies should be, and bad governance can still produce bad outcomes. No technology changes that.
What changes is the way those decisions are enforced. Instead of asking everyone to trust the operators, the rules themselves become visible and easier to verify before assets move. To me, that's a much stronger form of transparency than simply seeing transactions after they've already happened.
I also think the market sometimes overlooks infrastructure because it isn't exciting. New trading strategies and higher yields usually attract attention first. The systems that quietly reduce operational risk rarely become the center of the conversation, even though they're often the reason larger pools of capital feel comfortable participating in the first place.
None of this guarantees adoption. Building more rules into software also creates trade-offs. Markets change, regulations evolve, and governance can't become so rigid that every unusual situation turns into a lengthy upgrade process. Finding the right balance between flexibility and consistency is probably the real challenge.
My view is that VaultKit doesn't need to replace human judgment to be valuable. It only needs to reduce the number of situations where trust depends entirely on individuals making the right decision under pressure. If it can do that without making the system unnecessarily complex, I can see why institutions, professional asset managers, and regulated DeFi products would find it useful. If it can't, then it risks becoming another technically impressive solution looking for a problem. That's the balance I'll be watching.
#newt $NEWT @NewtonProtocol

Lately, I've been thinking less about what AI can do and more about what people are actually willing to trust.
Those aren't the same conversation.
Every week there's another headline about AI becoming faster, smarter, or more capable. It's impressive, no doubt. But finance has always had a way of bringing big ideas back to earth. The moment real money is involved, the questions become surprisingly ordinary.
Who made this decision?
Can anyone check it?
If something goes wrong, who's responsible?
I don't think those questions disappear just because AI enters the picture. If anything, they become even more important.
That's why Newton Protocol made me stop for a while. Not because it's mixing AI with blockchain—that's almost expected these days—but because it seems to start from a problem that feels real. If AI is going to make decisions that affect money, then maybe those decisions shouldn't be accepted just because a model is intelligent. Maybe they need to be verifiable.
The more I sit with that idea, the more reasonable it sounds.
We've spent years making AI more capable. Maybe the next step isn't making it even smarter. Maybe it's making it easier to trust.
And trust is a strange thing.
You can't code it into existence.
You can't announce it on launch day.
People trust financial systems because they've watched them work over time. They've seen them handle busy days, bad days, unexpected problems, and changing markets. Confidence builds slowly, almost quietly.
Technology doesn't work that way. Technology moves fast. Sometimes too fast.
That's probably why I don't think the biggest challenge for Newton Protocol is technical.
It's human.
Most people don't really care what's happening underneath the app they're using. They aren't reading technical papers before making a payment or placing an investment. They just want to know that the system works, that their money is safe, and that someone has thought about the risks before they had to.
Businesses aren't much different.
A bank doesn't replace infrastructure because something new looks interesting. It changes when the new system is clearly worth the cost, the effort, and the risk of switching. That's a high bar, and honestly, it should be.
Finance isn't an industry where moving first always wins.
Sometimes moving carefully is the smarter decision.
That's why I think adoption will depend on much more than the technology itself. Developers have to build useful products. Institutions have to see practical value. Regulators have to feel comfortable with how it fits into existing rules. None of those things happen because a white paper says they should.
They happen little by little.
There's another part of this that I don't think gets enough attention.
AI is becoming more capable at exactly the moment people are becoming more skeptical of systems they can't fully understand. That's an interesting contradiction. We want more automation, but we also want more transparency. We want smarter software, but we don't like feeling as though important decisions are happening inside a box we can't open.
Maybe that's where projects like Newton Protocol have an opportunity.
Not because they'll remove uncertainty. I don't think that's possible.
Markets will always surprise us. AI will still make mistakes. Regulations will keep changing.
But if a system can make those decisions easier to verify, easier to audit, and easier to explain, that's a meaningful improvement. It doesn't solve everything, but it solves something people genuinely worry about.
Whether that's enough, I honestly don't know.
Good ideas don't always become successful products. Sometimes the market isn't ready. Sometimes existing systems are simply too difficult to replace. Sometimes people stick with what they know because familiarity feels safer than improvement.
That has happened before, and it'll happen again.
Still, I think Newton Protocol is asking one of the more practical questions in AI finance. Instead of asking how much more intelligence we can build, it's asking how that intelligence can fit into a financial system that still depends on trust, accountability, and clear evidence.
To me, that's a much more grounded place to start.
If Newton Protocol eventually succeeds, I don't think it'll be because everyone suddenly became fascinated by verifiable AI. It'll be because, over time, enough developers, businesses, and institutions decided it made their work a little easier and their risks a little smaller.
And if it doesn't, I doubt the technology will be the whole story. More likely, it'll be another reminder that in finance, people don't adopt new systems simply because they're clever.
They adopt them when they feel comfortable enough to depend on them.
In the end, that has always been the hardest part. Technology can move quickly. Trust almost never does.
#newt $NEWT @NewtonProtocol

Lately, I've been thinking less about how smart AI is becoming and more about what happens after we start trusting it with things that actually matter.
It's easy to get excited about AI making faster decisions or spotting opportunities humans might miss. But the moment an AI starts handling real money, the conversation changes. Suddenly, speed isn't the most important thing anymore. Trust is.
I think that's where a lot of discussions around AI and crypto miss the point.
The question isn't whether an AI can execute a trade in milliseconds. The real question is what happens when that trade goes wrong. Who explains it? Who takes responsibility? How do you prove the AI acted within the rules it was given?
Those questions aren't new. Banks, payment companies, and financial institutions have dealt with them for years. The difference is that now we're asking software to make decisions that people used to make themselves.
That changes everything.
When I came across Newton Protocol, I didn't see it as another project trying to make AI smarter. There are already plenty of teams working on that. What stood out to me was a different idea: maybe AI doesn't just need better models. Maybe it needs better foundations.
That feels like a more practical problem to solve.
The best infrastructure is usually invisible. We don't think about the systems behind online payments or the technology that keeps the internet running. We only notice them when they stop working.
Maybe AI will be the same.
If autonomous systems become a normal part of finance, people probably won't care what model is making decisions. They'll care that the system is reliable, transparent, and predictable when something unexpected happens.
Of course, building that isn't easy.
People don't always behave the way technology expects them to. Users ignore warnings. Companies take shortcuts when they're under pressure. Regulations change. Different countries have different rules. Real life is messy, and good infrastructure has to survive in that mess.
That's why I'm naturally cautious whenever a project claims technology alone can solve trust.
Trust isn't something you code once and forget about. It's something that's earned over time.
I also think there's a tendency in crypto to believe that if the technology is good enough, adoption will simply happen. History tells a different story. Plenty of great technologies never became mainstream because they were too complicated, too expensive, or didn't fit the way people already worked.
Sometimes "good enough" wins because it's easier.
So I think Newton Protocol has a challenge that goes far beyond engineering. It has to make developers want to build on it, businesses feel comfortable using it, and institutions believe it can fit into a world full of compliance requirements and legal responsibilities.
That's a difficult balance to achieve.
I don't know if Newton Protocol will succeed. Honestly, nobody does. Infrastructure projects usually take years before anyone can judge them fairly.
But I do think it's asking a better question than many projects are.
Instead of asking, "How can AI become more powerful?" it seems to be asking, "How can AI become more trustworthy?"
To me, that's a much more interesting conversation.
If Newton Protocol eventually becomes successful, I don't think it'll be because people are talking about it every day. It'll be because they're using applications built on top of it without even realizing what's happening underneath.
And if it struggles, I doubt it'll be because the technology wasn't clever enough. It'll probably be because human trust is slow to earn, regulations are complicated, and changing the way people interact with financial systems has never been as simple as writing better code.
In the end, that's what keeps me interested. Not whether AI can replace human decisions, but whether we can build systems that people are genuinely comfortable relying on when those decisions start carrying real consequences.
#newt $NEWT @NewtonProtocol

One thing I've realized over the last few years is that crypto doesn't really have a technology problem anymore. Faster chains, cheaper transactions, better smart contracts, AI-powered agents—we've made incredible progress on all of those fronts. Yet whenever serious money, institutions, or businesses enter the picture, everything suddenly becomes more cautious.
Not because the technology stops working, but because people stop asking, "Can this be automated?" and start asking, "Can we trust this to operate within the right boundaries?"
I think that's the question that matters most.
We spend a lot of time talking about autonomous finance, but autonomy alone isn't particularly valuable. An AI agent can execute trades, move assets between protocols, or manage strategies twenty-four hours a day. That's impressive, but it also raises a much more practical question: who decides what the AI is allowed to do in the first place?
In traditional finance, that answer is surprisingly straightforward. Every automated system operates inside a framework of rules. There are spending limits, approval processes, compliance checks, investment mandates, and audit requirements. These aren't there because someone enjoys bureaucracy. They're there because people have learned—sometimes the hard way—that automation without guardrails eventually creates problems.
Crypto has often approached things differently. The goal has been to remove friction, eliminate intermediaries, and let code execute exactly as written. That's a powerful idea, but as the industry has matured, something interesting has happened. Many projects have quietly started rebuilding the same controls they originally tried to remove. Multi-signature wallets, governance approvals, emergency pause mechanisms, permission systems, and manual reviews have become increasingly common.
To me, that's a sign that the need for policy never disappeared. It simply moved outside the protocol.
That's why Newton Protocol feels different from many other AI-focused projects. What caught my attention isn't the promise of smarter automation. It's the idea that the rules surrounding automation can become part of the infrastructure itself instead of being handled separately through documents, internal procedures, or human intervention.
That may not sound revolutionary at first, but I think it's a meaningful shift.
If an AI is managing capital, it shouldn't just know how to execute a transaction. It should also know the conditions under which that transaction is allowed to happen. Maybe there's a spending limit. Maybe certain assets are off-limits. Maybe larger transactions require additional approval. Maybe specific jurisdictions require different rules. These kinds of boundaries already exist in the real world. The challenge has always been making them enforceable without slowing everything down.
That's where programmable policy starts to make sense.
Instead of treating compliance and governance as something that happens after an action, the rules become part of the action itself. The system isn't just asking whether something can happen; it's checking whether it should happen according to the policies that were defined beforehand.
That feels much closer to how mature financial infrastructure actually works.
Something else that often gets overlooked is the cost of trust. Moving money isn't always the expensive part. Proving that it was moved correctly is. Banks, investment firms, and payment companies spend enormous amounts of time and money on audits, approvals, reconciliation, reporting, and compliance. Those processes exist because accountability matters whenever financial decisions are automated.
If infrastructure can make those rules programmable instead of procedural, it could remove a surprising amount of operational friction. Not by eliminating regulation, but by making compliance more consistent and easier to verify.
Of course, I don't think software can replace human judgment entirely. Real life is messy. Regulations change, businesses evolve, and no written policy can anticipate every possible situation. That's why I'm naturally skeptical whenever I hear people describe autonomous finance as if it can eventually run without oversight.
History usually teaches the opposite lesson.
Financial systems rarely fail because they weren't automated enough. They fail because someone assumed automation no longer needed supervision.
That's why I see Newton Protocol less as an AI project and more as an attempt to build better infrastructure for responsible automation. Whether it succeeds won't depend only on technical performance. It will depend on whether developers actually find it useful, whether institutions are comfortable building on it, and whether its policy framework can adapt as laws and business requirements inevitably change.
Those are difficult challenges, but they're also the ones that matter.
I don't think the first users of this kind of infrastructure will be everyday crypto traders looking for the next opportunity. They'll probably be developers building autonomous applications, fintech companies experimenting with AI, digital asset managers, and organizations that already operate under strict governance requirements. Those users aren't looking for unlimited freedom. They're looking for automation they can trust, explain, and defend.
In the end, that's why Newton Protocol stands out to me. It's trying to solve a quieter problem—one that doesn't generate the same excitement as faster blockchains or more advanced AI, but becomes impossible to ignore as crypto matures. If programmable policy can become as fundamental as programmable money, projects like Newton could play an important role in connecting decentralized technology with the realities of regulation, business, and human decision-making.
Whether it succeeds is still an open question, and I think it's healthy to remain skeptical. But if crypto is ever going to support truly autonomous systems at scale, trust won't come from automation alone. It will come from the rules that quietly shape how that automation behaves.
#newt $NEWT @NewtonProtocol

Lately, I've been wondering if we've been asking the wrong question in DeFi all along.
For years, we've focused on one thing: proving that the owner of a wallet approved a transaction. That was a massive step forward for blockchain, and it's still essential. But as the ecosystem has evolved, I'm starting to think that ownership isn't the part we're struggle with anymore.
The real challenge is deciding what someone—or something—should actually be allowed to do after they're authenticated.
That distinction feels small at first, but I don't think it is.
In everyday life, trust is rarely unlimited. At work, people are given access based on their responsibilities, not because they're trusted with everything. Banks, businesses, and even the apps on our phones work this way. Permissions exist for a reason.
Crypto took a different path.
If a wallet holds the key, it often holds all the power. That was fine when most activity involved simple token transfers, but today's onchain world looks nothing like it did a few years ago.
We're talking about AI agents executing trades, protocols managing billions in liquidity, DAOs controlling community treasuries, and companies trying to bring real financial operations onchain.
In that environment, unlimited access starts to feel outdated.
What's interesting is that we've already recognized this problem—we just keep solving it in pieces.
We use multisigs to spread responsibility. We rely on token approvals to avoid signing every action. Smart wallets introduce custom rules because basic wallets aren't flexible enough.
Each solution helps, but they're all addressing the same gap from different directions.
That's what made Newton Protocol stand out to me.
Not because it's promising another revolutionary DeFi product, but because it treats authorization as shared infrastructure instead of leaving every protocol to build its own version.
That idea feels more important than it first appears.
Instead of asking whether a transaction was signed correctly, it asks whether the transaction should have been permitted at all.
To me, that's a much more practical question.
A signature proves identity. It doesn't automatically prove intent or define limits.
If I allow software to manage part of my portfolio, I'm not giving it permission to do absolutely anything. If an organization gives someone authority to execute payments, that shouldn't automatically include access to every asset under management.
Those boundaries are what make systems trustworthy.
AI makes this conversation even more relevant.
There's a lot of excitement around autonomous agents handling financial tasks, but complete freedom isn't always the goal. Constantly asking for approval defeats the purpose of automation, while unlimited authority creates obvious risks.
What most people actually need sits somewhere between those extremes.
That's why the idea of an authorization layer makes sense to me. It separates identity from permission instead of treating them as the same thing.
Of course, adding another infrastructure layer doesn't magically remove complexity.
Poorly designed permission rules can become their own source of problems, just like poorly written smart contracts. More control usually comes with more responsibility.
So I don't see this as a perfect solution.
I see it as an attempt to solve a problem we've been quietly working around for years.
And maybe that's enough.
When people discuss blockchain efficiency, they usually focus on gas costs. But organizations often care about different kinds of costs—approval bottlenecks, operational mistakes, internal controls, compliance requirements, and the time spent fixing preventable errors.
Those costs don't always show up onchain, but they're real.
Reducing that kind of friction could end up being just as valuable as making transactions cheaper.
Most users probably won't ever think about authorization layers, and that's completely fine. The best infrastructure usually fades into the background.
The people who will care are developers building automated systems, teams managing shared assets, and institutions that need stronger safeguards before committing larger amounts of capital onchain.
Whether Newton Protocol becomes part of that future depends on adoption more than technology. Infrastructure only matters when other builders decide it's worth relying on.
Still, I think it's highlighting an important shift.
For a long time, blockchain has been built around answering one question:
Who approved this transaction?
As the ecosystem becomes more automated, I think another question is becoming just as important:
Was this transaction actually supposed to happen?
If we can answer both, onchain finance starts looking a lot more practical for the world that's being built—not the one we started with.
#newt @NewtonProtocol $NEWT

先日、自分のウォレットの設定をにらみながら、このニュートンのバイオメトリクス2FAってやつについて考え込んでいました。なぜ追加のセキュリティがあっても、結局は一歩進んで半歩下がるように感じてしまうのか、不思議で。たとえば、そこそこ大きな取引をする前に確認ボタンを押す直前の間とか、AIのトレーディングスクリプトに権限を手渡す瞬間ってありますよね。すでにパスワードのハードルは越えて、コード用にスマホをちらっと見たとしても、心の奥で静かに疑ってしまうんです。本当に万全なのか、それとも期待しているだけなんじゃないのか、と。電話を一台失うこと、うまくいかないフィッシングの一発ででも起きれば、積み上げたポジションや委任した戦略が一気に危うくなる。机上の空論じゃありません。だから、周りに自動化のもっと深いところまで踏み込むべき人たちが、手作業で小さく留めたがる理由もあるし、機関側がぐるっと回るけれども本格的には踏み込まない理由もそこにあります。—あらゆるものに、規制の「もしも」が引っかかり過ぎているんです。

You catch yourself at odd hours, staring at a screen where a transfer should have cleared by now but instead some compliance flag has everything paused again. Or you watch what was supposed to be a smooth automated rebalance sit idle because another approval layer kicked in. It’s these small, grinding moments that make you pause and think: why does moving money or running a strategy still feel this cumbersome when the underlying tech promises so much efficiency? I’ve sat through enough of those nights, talking with builders, traders, and compliance folks, and the frustration is rarely about lacking rules. It’s how the infrastructure forces everything into awkward boxes.
Finance, at its core, has always juggled the need to show your work for accountability with the practical reality that full exposure can kill strategy, invite attacks, or simply make daily operations exhausting. Onchain, that tension gets sharper. Transparent chains make perfect sense for some settlement finality, but they turn every position and timing decision into something visible to anyone paying attention. So people improvise. They lean on custodians that quietly centralize risk, or tools that feel like they wave bright red flags at regulators, or closed systems that lose the openness that drew folks here in the first place. None of these feel like mature solutions. They’re patches that carry their own costs in time, legal overhead, or eroded trust.
I’ve seen the pattern play out before in different systems. Good intentions around auditability run into human and institutional realities: institutions hold back because leaking their book means losing edge; builders pour energy into privacy add-ons that become too clunky for real-world frequency; regular users just find workarounds that sometimes create bigger problems later. Privacy ends up treated as an exception—something you request case by case, justify with extra paperwork, or bury in special arrangements. The result is slower settlement, higher friction, and a quiet sense that the whole setup doesn’t quite match how people actually behave or how capital needs to flow.
That’s the kind of backdrop where Newton Protocol feels like a thoughtful attempt at infrastructure rather than another flashy layer. It’s centered on a specialized rollup for handling permissions and verifiable policies, especially around AI strategies and automated trading. The shape that sticks with me is the ability to set clear, revocable boundaries for what an agent or model can do—without handing over full control or exposing everything publicly. It lets compliance checks happen in the flow, backed by cryptographic proofs, so you can verify rules were followed without broadcasting the entire picture. For developers putting models into a marketplace, it offers a way for users to engage with some confidence that execution stays within agreed limits.
When I think about actual day-to-day use, it hits familiar pain points. Cross-chain moves or ongoing automation often break down on constant approval fatigue or the worry that your positions become visible at exactly the wrong time. Settlement works best when it’s final and trusted, but not when every detail becomes permanent public record. From the regulatory side, the need isn’t usually for exhaustive raw data but for reliable evidence that policies were respected. Keeping costs reasonable for frequent activity matters too—general chains can get expensive fast for this kind of granular work. And on the human side, I’ve noticed folks are more comfortable delegating when they know they can pull back easily and that limits are enforced hard, not just promised.
Still, I hold plenty of skepticism. Too many times I’ve watched promising setups falter when real pressure hits—security assumptions tested, integrations with legacy processes proving messier than expected, or incentives drifting in ways that undermine the original design. Questions linger: will the keystore approach stay robust across different scenarios? How well does it bridge to the patchwork of jurisdictional rules? Cryptographic attestations sound right in theory, but earning routine acceptance from auditors and regulators is a longer road than it appears.
#newt $NEWT @NewtonProtocol