V2F0IGlzIGhldCBOZXd0b24gUHJvdG9jb2w/IEVlbiB1aXRnZWJyZWlkZSBhbmFseXNlIHZhbiBkZSBwcmlqcyB0cmVuZHMgdmFuIGRlIE5FV1QtdG9rZW4=

2025-06-30, 10:08

<p><img src="https://gimg2.gateimg.com/image/newton202506301806058831723633.png" alt="">
</p><p>In <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> In het veld pakt het Newton Protocol, als een gedecentraliseerd economisch protocol, de vertrouwensproblemen van blockchainautomatisering aan door middel van technologische innovatie. Het project wordt gezamenlijk gebouwd door het Magic-team en de Magic Newton Foundation, met als kern doel het gebruik van Zero-Knowledge Proofs (ZKP) en Trusted Execution Environment (TEE) technologie om de veilige geautomatiseerde uitvoering van gebruikers taken in een cross-chain omgeving te bereiken, waarbij elke stap van de operatie cryptografisch kan worden geverifieerd en getraceerd.</p>
<h2 id="h2-Kernwaarden20en20technische20architectuur20van20het20Newton20Protocol335292"><a name="Kernwaarden en technische architectuur van het Newton Protocol" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kernwaarden en technische architectuur van het Newton Protocol</h2><p>Huidig <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> gebruikers staan voor gefragmenteerde operaties en hoge risico’s van handmatige uitvoering, vooral in scenario’s zoals cross-chain transacties en stakingbeheer. Het Newton Protocol stelt drie belangrijke ontwerprincipes voor die direct inspelen op de pijnpunten:</p>
<ol>
<li>Scoped Autonomy: Gebruikers stellen de financieringslimieten, gedragsomvang en operationele voorwaarden van agenten in via zkPermissions, waarbij het systeem de voorkoming van machtsmisbruik afdwingt.</li><li>Verifiable Integrity: Alle agentoperaties genereren ZKP-bewijzen, wat ervoor zorgt dat acties overeenkomen met autorisaties en veiligheid garandeert bij betrokkenheid van AI of transacties van hoge waarde.</li><li>Earned Reputation: Agenten verdienen reputatiepunten, en overtredingen zullen economische straffen met zich meebrengen, waardoor een ecosysteem ontstaat dat prikkels en beperkingen in balans houdt.</li></ol>
<p>Het operationele proces omvat ontwikkelaarsmodellering, indiening van gebruikersintenties, off-chain uitvoering door de operator (genereren van TEE/ZKP-bewijzen), on-chain verificatie en reputatie-updates, wat een gesloten-loop verifieerbaar automatiseringssysteem vormt.</p>
<h2 id="h2-NEWT20Token20Economie20en20Functies162209"><a name="NEWT Token Economie en Functies" class="reference-link"></a><span class="header-link octicon octicon-link"></span>NEWT Token Economie en Functies</h2><p>Als de inheemse token van het protocol is NEWT de kern van de ecologische werking, en het economische model is als volgt ontworpen:</p>
<ul>
<li>Totale voorraad: 1 miljard munten, initiële circulerende voorraad van 215 miljoen munten (21,5%).</li><li>Distributiestructuur:<ul>
<li>60% voor ontwikkeling van de ecologische gemeenschap (48 maanden lineaire ontgrendeling).</li><li>40% toegewezen aan kernbijdragers, vroege supporters en Magic Labs (12 maanden lock-up gevolgd door 36 maanden lineaire release).</li></ul>
</li><li>Token gebruik:<ul>
<li>Staking en netwerkbeveiliging: gebruikt voor gedelegeerd bewijs van deelname (dPoS) consensusmechanisme.</li><li>Betaling van vergoedingen: gebruikers betalen gaskosten bij het initiëren van proxytransacties.</li><li>Ontwikkelaarsprikkels: betalen modelregistratiekosten en ontvangen gebruiksdeling.</li><li>Deelname aan governance: stemmen over voorstellen voor protocolupgrades, fondsengebruik, enz.<h2 id="h2-NEWT20prijsbeweging20en20marktanalyse766456"><a name="NEWT prijsbeweging en marktanalyse" class="reference-link"></a><span class="header-link octicon octicon-link"></span>NEWT prijsbeweging en marktanalyse</h2>NEWT zal op 24 juni 2025 op beurzen zoals Gate worden genoteerd, met ernstige schommelingen:</li></ul>
</li><li>Vroeg noteren: openingsprijs $0,49, stijging van 67% naar $0,82 binnen enkele uren.</li><li>Winstneming: geconcentreerde cash-out door airdrop-ontvangers leidde tot een prijsdaling van 44%, met een laag van $0,46.</li><li>Huidige gegevens (30 juni 2025): prijs $0,4, marktkapitalisatie $88 miljoen, 24-uurs handelsvolume $6,5 miljoen.</li></ul>
<table>
<thead>
<tr>
<th>Bron</th>
<th>2025 gemiddelde prijsvoorspelling</th>
<th>20230 Gemiddeld <a href="/price-prediction" rel="nofollow noopener noreferrer" target="_blank">Prijsvoorspelling</a></th>
<th>Voorspelde piek in 2035</th>
</tr>
</thead>
<tbody>
<tr>
<td>Groot Model</td>
<td>1,44 USD</td>
<td>8,86 USD</td>
<td>14,69 USD</td>
</tr>
<tr>
<td>Cryptoticker</td>
<td>1.0806 USD</td>
<td>6,0235 USD</td>
<td>Niet opgegeven</td>
</tr>
</tbody>
</table>
<p>Het grote model voorspelt een gemiddelde prijs van $1,44 in 2025, terwijl de verwachting van Cryptoticker voor 2025 slechts $1,0806 is. Het verschil komt voort uit verschillende oordelen over de snelheid van technologische implementatie en marktadaptatie.</p>
<h2 id="h2-Samenvatting20Risicos20en20Potentieel20Coxistentie451134"><a name="Samenvatting: Risico’s en Potentieel Coëxistentie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting: Risico’s en Potentieel Coëxistentie</h2><p>Newton Protocol vult de vertrouwenskloven in <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> op door verifieerbare automatisering, en biedt de infrastructuur voor de integratie van AI-agenten en de on-chain economie. Hoewel NEWT in de korte termijn te maken heeft met aanzienlijke volatiliteit door verkoopdruk van airdrops, hangt de langetermijnwaarde af van de adoptiegraad van het protocol en de voortgang van de ecosystemexpansie. Investeerders moeten letten op:</p>
<ol>
<li>Technische Vooruitgang: Stabiliteit en kostenoptimalisatie van ZKP/TEE in praktische toepassingen.</li><li>Token Ontgrendeling: Marktdruk die kan ontstaan door de vrijgave van teamaandelen die in 2026 begint.</li><li>Ecosysteem Groei: Het activiteitsniveau van de ontwikkelaarsgemeenschap en de diversiteit van agentmodellen.</li></ol>
<p>Voor Web3-deelnemers met een hoge risicotolerantie vertegenwoordigt Newton een inzet op een geautomatiseerde toekomst; voor conservatieve investeerders blijft het nauwlettend volgen van de technologische mijlpalen en on-chain gegevens een rationele keuze.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Blogteam</strong><br><div class="info-tips"><em>De inhoud hiervan vormt geen aanbod, sollicitatie of aanbeveling. U dient altijd onafhankelijk professioneel advies in te winnen voordat u investeringsbeslissingen neemt.<br><div></div>Houd er rekening mee dat Gate het gebruik van alle of een deel van de Diensten vanuit Beperkte Locaties kan beperken of verbieden. Voor meer informatie kunt u de Gebruikersovereenkomst lezen via <a href="https://www.gate.com/legal/user-agreement" data-index="4">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>