V2VrZWxpamtzIFdlYjMtb25kZXJ6b2VrIHwgRGUgbWFya3Qgc2Nob21tZWxkZSBsaWNodA==

<p><img src="https://gimg2.gateimg.com/image/article/1739503365weeklyweb3research.webp" alt=""></p>
<h2 id="h2-Wekelijks20Trendoverzicht866084"><a name="Wekelijks Trendoverzicht" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wekelijks Trendoverzicht</h2><p>Het totale <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a> De markt toonde deze week een relatief duidelijke volatiliteit. Beïnvloed door de voortdurende daling van de Amerikaanse aandelen vorige week, is er geen duidelijk opwaarts signaal voor de markt, maar over het algemeen is deze ontsnapt aan de algemene daling en is een nieuwe volatiele cyclus ingegaan. Snelle intraday ups en downs domineerden de markt, en de trend van mainstream munten bleef binnen een klein bereik voortdurende schommelingen vertonen. De markt neigt zich te concentreren in hetzelfde prijsbereik, en de huidige mainstream markttrend zal waarschijnlijk op korte termijn blijven.</p>
<p>De prijzen van de meeste belangrijkste cryptocurrencies veerden afgelopen weekend op, en daalden aanzienlijk na de opening van deze week. De markttrend is op korte termijn nog steeds onduidelijk en wordt voornamelijk gekenmerkt door kortetermijn intraday schommelingen.</p>
<p>Deze week schommelde de prijs van BTC tussen $95.000 en $99.000 gedurende het grootste deel van de tijd, met een aanzienlijke daling tijdens de openingsperiode. Het dieptepunt van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">BTC prijs</a> zakte onder de sleutelprijs van $95.000, en bleef vervolgens boven $95.000 en bleef fluctueren. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">ETH prijs</a> veranderingen zijn vergelijkbaar. De meeste belangrijke mainstream munten blijven binnen een kleine marge stijgen en dalen. Het huidige marktsentiment is opgewarmd tot ongeveer 40. De algehele marktwaarde van de cryptomarkt is niet significant veranderd en bedraagt ongeveer $3,16 biljoen, een daling van 0,75% in 24 uur.</p>
<p>De cryptomarkt is deze week een nieuwe schommelingscyclus ingegaan, met meerdere rondes van kleine ups en downs in een week, en er is een trend van verdere daling. De huidige prijs van BTC ligt rond $95.618. De prijstrend van ETH is vergelijkbaar en de huidige prijs blijft rond $2.624.</p>
<p>De algehele cryptomarkt is deze week voornamelijk gestegen en gedaald, en er is geen verdere trend van grootschalige stijging en daling. De huidige prijzen van veel belangrijke munten liggen in hetzelfde bereik als de openingsprijs. De topmunt met de grootste stijging deze week is CAKE, die in een week met ongeveer 90% is gestegen.</p>
<p>De algehele cryptomarkt bleef dit weekend volatiel, met korte-termijn schommelingen als de belangrijkste trend. Op korte termijn zal de huidige marktcyclus nog enige tijd aanhouden.</p>
<h2 id="h2-Crypto20Markt779856"><a name="Crypto Markt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Markt</h2><p>🔥Volgens Fox Business-verslaggever Eleanor Terrett toonden de Republikeinse leden van de Federal Reserve Board, Michelle Bowman en Christopher Waller, een meer open houding ten opzichte van de crypto-industrie in hun toespraken op 7 februari, wat een verschuiving markeert in de houding van de Fed ten opzichte van de regulering van digitale activa.</p>
<p>🔥Volgens Bloomberg zijn Wall Street-giganten zoals Morgan Stanley, Bank of America en Royal Bank of Canada (RBC) actief betrokken bij de cryptobranche, en wordt verwacht dat het pro-crypto beleid van de regering-Trump zal leiden tot een toename in beursintroducties, aandelenuitgiften en converteerbare obligatietransacties.</p>
<p>🔥President Mohamed Muizzu van de Maldiven plaatste op het X-platform dat de $MLDVS-token zal worden gelanceerd op de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> netwerk dat tot doel heeft digitale cultuur te gebruiken om mensen te verenigen en de Malediven naar de wereldwijde cryptomarkt te brengen.</p>
<p>🔥Mempool.space-gegevens tonen aan dat de huidige transactiekosten (gasvergoeding) van de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> het netwerk is gedaald naar 1 satoshi/byte, ongeveer $0.14. Etherscan-gegevens tonen aan dat de mediane prijs van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> gasvergoeding is momenteel ongeveer 0.9 gwei, ongeveer $0.05.</p>
<p>Het Japanse effectenconcern SBI Group heeft aangekondigd dat zijn cryptobedrijf een recordkwartaalwinst heeft behaald. SBI heeft ook samengewerkt met de Amerikaanse USDC-operator Circle om de lancering van USDC-handelsparen in Japan te bevorderen.</p>
<p>🔥Volgens PR Newswire, het aan de Nasdaq genoteerde bedrijf en leverancier van holografische technologiediensten MicroCloud Hologram Inc. (NASDAQ: <a href="/price/holo-hot" rel="nofollow noopener noreferrer" target="_blank">HOLO</a>) kondigde aan dat het van plan is om tot $200 miljoen op te halen om <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> of andere digitale valuta’s en hun gerelateerde effecten derivaten aan te schaffen, en deze activa op te nemen in haar kapitaalreserve-strategie.</p>
<p>🔥Volgens Blockworks onthulde PitchBook in een nieuw rapport dat de uitgaven voor durfkapitaal in crypto traag zullen blijven tot het einde van 2024. Specifieke gegevens toonden aan dat de transactiewaarde in het vierde kwartaal van 2024 steeg naar $2,4 miljard, een stijging van 13,6% ten opzichte van het derde kwartaal, maar het aantal transacties daalde van 411 naar 351.</p>
<p>Volgens de monitoring van Lookonchain heeft het cryptoproject World Liberty Financial (WLFI voor het gemak) van de Trump-familie 156.667 USDC uitgegeven om nog eens 273.937 MOVEs te kopen.</p>
<p>🔥Volgens Cryptoslate heeft <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Core-ontwikkelaar Luke Dashjr bezorgdheid geuit over de definitiviteit van Bitcoin-transacties, waarbij hij zegt dat de algemeen aanvaarde regel van zes bevestigingsblokken niet langer van toepassing is.</p>
<p>🔥Volgens officieel nieuws heeft de <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Foundation aangekondigd dat zij een subsidie van $200.000 zal verstrekken ter ondersteuning van de Pectra-ecosysteemupgrade en de aanmeldingsdatum eindigt op 23 februari.</p>
<p>🔥Volgens CoinDesk heeft een woordvoerder van Invest Hong Kong bevestigd dat cryptocurrencies, waaronder Bitcoin en Ethereum, kunnen worden gebruikt als bewijs van activa bij het aanvragen van een visum onder het Capital Investment Entrant Scheme.</p>
<p>Volgens Cointelegraph toont data aan dat Bitcoin tekenen vertoont van een klassiek lokaal dieptepunt nu miners te maken krijgen met een nieuwe fase van ‘capitulatie’.</p>
<p>Volgens TheBlock hebben de Meme- en AI-tokensectoren volgens gegevens van de GMCI-index de zwaarste dalingen geleden in de recente marktaanpassing, waarbij de GMMEME- en GMAI-indices respectievelijk met 60% en 56% zijn gedaald ten opzichte van hun hoogtepunten in december 2024.</p>
<p>🔥Volgens CoinDesk heeft de Wall Street-bank JPMorgan Chase (JPM) in een onderzoeksrapport dat op dinsdag is vrijgegeven, gewezen op gegevens van TradingView, waaruit blijkt dat de groei van het cryptosysteem in januari vertraagde, waarbij de totale handelsvolume met 24% daalde.</p>
<p>🔥Volgens officieel nieuws, <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> heeft aangekondigd dat het een strategische investering heeft afgerond in de zelfbewaar-cryptoportemonnee ZengoWallet. <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> zei dat deze investering de toewijding van <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> aan het ontwikkelen van veilige zelfbewaaroplossingen en het bevorderen van de wereldwijde populariteit van stablecoins aantoont.</p>
<p>🔥Volgens officieel nieuws kondigde het cryptoproject World Liberty Financial (WLFI voor kort) van de familie Trump en Ondo Finance een strategisch partnerschap aan om de adoptie van getokeniseerde echte wereld activa (RWA) te bevorderen en traditionele financiën op de keten te brengen.</p>
<p>🔥Michael Saylor, oprichter van Strategy (voorheen MicroStrategy), plaatste op het X-platform: “Tot nu toe hebben de financiële operaties van Strategy 18.527 bitcoins opgeleverd, wat equivalent is aan ongeveer $1,8 miljard aan bitcoinwaarde voor $MSTR-aandeelhouders.”</p>
<p>🔥Volgens CoinDesk heeft KULR Technology, genoteerd aan de New York Stock Exchange, zijn Bitcoin-posities verhoogd tot 610.3.</p>
<p>🔥Volgens Beincrypto heeft Bitwise Asset Management gemeld dat individuele houders het grootste deel van de totale voorraad Bitcoin controleren. Van de 21 miljoen Bitcoins in omloop behoort 69,4% toe aan particuliere investeerders. Gezien deze concentratie van Bitcoin-bezit onder individuen, kunnen grote instellingen en overheden uitdagingen ondervinden bij het verwerven van Bitcoin.</p>
<p>Volgens Sunil, een vertegenwoordiger van de schuldeisers van FTX, als SBF niet failliet was gegaan, zou de waardering van zijn activa meer dan $65 miljard hebben kunnen bedragen.</p>
<p>🔥Fox Business-reporter Eleanor Terrett tweette dat nu digitale activa een regelgevende focus worden, de U.S. Securities and Exchange Commission (SEC) en de Commodity Futures Trading Commission (CFTC) manieren onderzoeken om de samenwerking in cryptoregulering te versterken.</p>
<p>🔥Volgens The Block heeft Robinhood zijn financieel rapport voor het vierde kwartaal vrijgegeven, waaruit blijkt dat het handelsvolume van crypto met 400% is gestegen op jaarbasis naar $70 miljard. Eerder daalde het handelsvolume in 2024, met respectievelijk $36 miljard, $21,5 miljard en $14,4 miljard in de eerste drie kwartalen.</p>
<p>🔥Franklin Templeton heeft op het X-platform aangekondigd dat zijn on-chain Amerikaanse schatkistgeldfonds ‘BENJI’ nu live is op <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a>. Franklin Templeton zei dat <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> een snel, veilig en censuurbestendig Layer 1 blockchain is die wereldwijde adoptie aanmoedigt via zijn open infrastructuur.</p>
<p>🔥Volgens de gegevens van Cointelegraph bereikte de bevestigingstijd van Bitcoin in 2025 een recordhoogte, met een gemiddelde van 19 minuten per transactie. Netwerkcongestie, blokgroottebeperkingen en transactiekosten zijn de belangrijkste factoren die vertragingen veroorzaken.</p>
<p>🔥Fox Business News verslaggever Eleanor Terrett schreef op het X-platform dat volgens deze zeer nuttige tabel verstrekt door Bloomberg ETF-analisten James Seyffart en Eric Balchunas, we kunnen zien dat als de U.S. Securities and Exchange Commission (SEC) ervoor kiest om te erkennen, het mogelijk Grayscale’s zal erkennen. <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> spot ETF-aanvraag mogelijk al vanaf donderdag (13 februari).</p>
<p>Volgens Cointelegraph handelt Bitcoin sinds 4 februari onder het belangrijke prijsniveau van $100.000, omdat zorgen over de wereldwijde handelsoorlog op het sentiment van beleggers drukten na de aankondiging van nieuwe invoertarieven door de Verenigde Staten en China.</p>
<p>Volgens Cointelegraph heeft de blockchain-platform van de Amerikaanse president Donald Trump een strategisch reservefonds gelanceerd om de groei van enkele van de grootste cryptocurrencies te ondersteunen.</p>
<h2 id="h2-Regelgevende20amp20Macrobeleid260997"><a name="Regelgevende &amp; Macrobeleid" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Regelgevende &amp; Macrobeleid</h2><p>Volgens CNBC beschuldigden Amerikaanse federale aanklagers de bekende advocaat van het Hooggerechtshof, Tom Goldstein, ervan twee cryptowallets te verbergen die meer dan $8 miljoen aan fondsen hebben ontvangen en $6 miljoen hebben overgemaakt in de afgelopen week in strijd met gerechtelijke bevelen, en hij werd opnieuw gearresteerd.</p>
<p>🔥Volgens CoinDesk heeft de Digitale Activacommissie van het Huis van Afgevaardigden van de V.S. op 11 februari een hoorzitting gehouden om de toekomstige ontwikkeling van de crypto-industrie in de Verenigde Staten te verkennen en wetgeving te bevorderen om regelgevende duidelijkheid te bieden.</p>
<p>Volgens The Block zei voorzitter van de Federal Reserve Jerome Powell dat gezien de kritiek dat de cryptobranche is uitgesloten van bankdiensten, het tijd is om het vraagstuk van de-banking ‘opnieuw te onderzoeken’. Tijdens een hoorzitting van de Senaatscommissie Bankwezen op dinsdag vroeg de voorzitter van de commissie, de Republikeinse senator Tim Scott van South Carolina, aan Powell of hij met hem zou samenwerken om ervoor te zorgen dat financiële regels ‘niet meer lasten opleggen dan noodzakelijk’.</p>
<p>Volgens Cointelegraph zei Hester Peirce, een lid van de Amerikaanse Securities and Exchange Commission (SEC), dat de instantie mogelijk wacht op de bevestiging van de nieuwe voorzitter door de Senaat voordat ze besluit over de regelgevingsagenda voor cryptocurrencies.</p>
<p>Volgens Cointelegraph heeft de Amerikaanse president Trump voormalig hoofd juridische zaken van Bitfury, Jonathan Gould, genomineerd als directeur van het Bureau van de Controller van de Munteenheid (OCC) van de VS, verantwoordelijk voor het toezicht op het nationale banksysteem. De nominatie werd op 11 februari aan de Senaat voorgelegd voor een termijn van vijf jaar.</p>
<p>🔥Volgens Coinpost stelde Yukiyuki Aruba, directeur van het Planning and Market Bureau van de Financiële Diensten Autoriteit van Japan, vandaag een uitgebreid institutioneel hervormingsplan voor crypto-activa en stablecoins voor op basis van de discussie van de werkgroep van de Financiële Beoordelingsraad van vorige maand.</p>
<h2 id="h2-Crypto20Markt20Highlights308844"><a name="Crypto Markt Highlights" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Markt Highlights</h2><p>⭐️ Afgelopen week was de algehele trend van de cryptomarkt nog steeds in een staat van honger na de externe nieuwsfactoren van vorige week, en korte termijn ups en downs zijn de hoofdstroommarkt trend. Hoewel de algehele waarde van de markt weinig is veranderd, is de markt als geheel nog niet opgedoken uit de recente trage markttoestand nu het weekend nadert en de waarschijnlijkheid van het handhaven van een klein bereik van ups en downs in de toekomst is hoog.</p>
<p>⭐️ Deze week stond CAKE op de eerste plaats in de stijging van de cryptomarkt onder de belangrijkste munten, voornamelijk als gevolg van de invloed van de eigen acties van het AMM-platform, die een grote hoeveelheid geld uit de DeFi-track aantrokken, waardoor de prijs van CAKE binnen een week aanzienlijk steeg. De munt steeg in een week met ongeveer 90%, en de huidige prijs bleef rond de $2,66, met een zekere neerwaartse trend in de prijs.<br><img src="https://gimg2.gateimg.com/image/article/17395035701.jpeg" alt=""></p>
<h2 id="h2-BTC20amp20ETH20Wekelijkse20Prestaties516504"><a name="BTC &amp; ETH Wekelijkse Prestaties" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC &amp; ETH Wekelijkse Prestaties</h2><h3 id="h3-Bitcoin20BTC379651"><a name="Bitcoin (BTC)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin (BTC)</h3><p><img src="https://gimg2.gateimg.com/image/article/17395035922.jpeg" alt=""><br>(Data met dank aan TradingView)</p>
<p>Deze week is de prijs van BTC voornamelijk in korte termijn schommelingen geweest sinds de opening, maar het heeft ook een relatief duidelijke daling ingeluid. Het herstelde zich in de daaropvolgende periode, maar er was een voortdurende daling in de midweek periode. De prijs van BTC daalde in korte tijd onder $95.000, en vervolgens was er nog een ronde van ups en downs. De huidige prijs van BTC blijft in het bereik van $95.000-$96.000. De algehele prijs mist grote ups en downs signalen binnen een week en bevindt zich in hetzelfde bereik als de openingsprijs.</p>
<h3 id="h3-Ethereum20ETH50844"><a name="Ethereum (ETH)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ethereum (ETH)</h3><p><img src="https://gimg2.gateimg.com/image/article/17395036163.jpeg" alt=""><br>(Data met dank aan TradingView)</p>
<p>De prijswijzigingen van ETH tijdens deze week handhaafden een vergelijkbare trend als BTC, maar de prijsschommelingen waren kleiner tijdens de mid-week periode. Na de opening onderging de prijs van ETH een reeks pieken, en de korte termijn prijs daalde eens tot ongeveer $2,520. De prijs herstelde zich vervolgens en ETH naderde eens het niveau van $2,800. Het bevindt zich momenteel in een continu dalingsbereik, waarbij de prijzen zich in het bereik van $2,600-$2,700 bevinden. ETH’s wekelijkse hoogtepunt nadert $2,800, en het wordt verwacht dat het weekend de mainstream trend van de week zal handhaven, met kleine prijsschommelingen als de belangrijkste trend.</p>
<h2 id="h2-Web320Project20Trend158888"><a name="Web3 Project Trend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Web3 Project Trend</h2><p>De totale marktwaarde van de zeven soorten projecten is deze week hersteld, maar het grootste deel van de totale marktwaarde bleef op ongeveer hetzelfde niveau als vorige week. De algehele markt werd voornamelijk beïnvloed door de recente marktomstandigheden, en kleine kortetermijnstijgingen en -dalingen waren de hoofdtrend. Hoewel de stijging van individuele munten duidelijker was, was de algehele trend nog steeds voornamelijk kleine veranderingen.</p>
<table>
<thead>
<tr>
<th>Projectcategorie</th>
<th>7d Verandering</th>
<th>Top 3 Stijgers</th>
<th>Opmerking</th>
</tr>
</thead>
<tbody>
<tr>
<td>Laag 1</td>
<td>0.0%</td>
<td>LLD, TARA, HMND</td>
<td>De totale marktwaarde van de Layer 1-track bleef onveranderd, waarbij de topmunten in een relatief gelijkmatig tempo toenamen, voornamelijk mainstreammunten, en binnen een gematigd bereik bleven.</td>
</tr>
<tr>
<td>Laag 2</td>
<td>-1.0%</td>
<td>DG,ZKF,BVM</td>
<td>De markttrend van de Layer 2-sector is vergelijkbaar met die van de L1-track. De stijgende amplitude van de topmunten blijft matig, en er is over het algemeen een gebrek aan grootschalige ups en downs.</td>
</tr>
<tr>
<td>DeFi</td>
<td>-0.5%</td>
<td>BOR,TIME,TUNE</td>
<td>De totale marktwaarde van de DeFi-sector veranderde weinig en de algehele stijging en daling was ongelijk verdeeld, geconcentreerd in de BOR-munt.</td>
</tr>
<tr>
<td>NFT</td>
<td>2.1%</td>
<td>XED,STARS,MOON</td>
<td>De totale waarde van de NFT-markt is licht gestegen, met de top stijgende munten geconcentreerd in individuele munten, en de algehele verdeling varieert aanzienlijk.</td>
</tr>
<tr>
<td>MEME</td>
<td>-0.1%</td>
<td>RUNES•X•BITCOIN,ZYGO,CATME</td>
<td>De totale kapitaalschaal van het MEME-muntspoor veranderde weinig, maar de meeste munten daalden en de winsten waren geconcentreerd in de topmunten.</td>
</tr>
<tr>
<td>Vloeibaar staken</td>
<td>-4.5%</td>
<td>BRG,AFSUI,URO</td>
<td>Deze sector heeft een meer voor de hand liggende neerwaartse trend. De groeipercentages van de topmunten zijn relatief gelijkmatig verdeeld, en de kleine daling is voornamelijk te wijten aan de trend van mainstreammunten.</td>
</tr>
<tr>
<td>AI</td>
<td>3.4%</td>
<td>KAAI,NFTXBT,BAD</td>
<td>De AI-track heeft enig herstel gezien. Na de algehele impact van DeepSeek op de AI-industrie te hebben verminderd, heeft de track een langzaam herstel laten zien.</td>
</tr>
</tbody>
</table>
<div class="blog-details-info"><br><div>Auteur:<strong>Charles T.</strong>, Gate.io onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen beleggingsadvies. Alle investeringen brengen inherente risico's met zich mee; verstandig besluitvorming is essentieel.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>