RGFnZWxpamtzIG5pZXV3cyB8IEJpdGNvaW4gTWluaW5nIE1vZWlsaWpraGVpZCBlbiBEZUZpIFByb3RvY29sIFRWTCB2ZXN0aWdlbiBlZW4gbmlldXcgcmVjb3JkOyBEZSBhZG9wdGllZ3JhYWQgdmFuIEJyYXppbGlhYW5zZSBVU0RUIGlzIGV4cGxvc2llZiBnZXN0ZWdlbiBlbiB2ZXJ0ZWdlbndvb3JkaWd0IDgwJSB2YW4gaGV0IGhhbmR

2023-10-31, 04:35

<p><img src="https://gimg2.gateimg.com/image/article/16987309701031.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Het20Bitcoin20Witboek20is20al201520jaar20uitgebracht20De20adoptiegraad20van20Braziliaanse20USDT20vertegenwoordigt208020van20het20transactievolume397355"><a name="Crypto Dagelijkse Samenvatting: Het Bitcoin Witboek is al 15 jaar uitgebracht; De adoptiegraad van Braziliaanse USDT vertegenwoordigt 80% van het transactievolume." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Het <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Witboek is al 15 jaar uitgebracht; De adoptiegraad van Braziliaanse USDT vertegenwoordigt 80% van het transactievolume.</h2><p>Op 31 oktober vierde Satoshi Nakamoto de 15e verjaardag van de publicatie van de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> witboek ‘Bitcoin: Een peer-to-peer elektronisch geldsysteem’ op de website van de P2P-stichting. Het Bitcoin-netwerk werd officieel gelanceerd op 3 januari 2009, met een initiële transactieprijs van $0.0008 voor Bitcoin.</p>
<p>Tegenwoordig is Bitcoin sinds de lancering geleidelijk met meer dan 43 miljoen keer in waarde gestegen. Volgens marktgegevens is de huidige prijs van Bitcoin $34429.09, met een totale marktwaarde van $672.9 miljard.</p>
<p>Volgens gegevens van de Braziliaanse belastingdienst is het gebruik van cryptocurrency in Brazilië aanzienlijk toegenomen. Als we alleen naar enkele gegevens uit 2023 kijken, is 80% van de gerapporteerde cryptocurrency-transacties gerelateerd aan USDT. Sinds 2021 neemt het handelsvolume van USDT in Brazilië toe en heeft het in juli 2022 voor het eerst Bitcoin overtroffen.</p>
<p>Volgens Mempool-gegevens werd de moeilijkheidsgraad van Bitcoin-mining aangepast om 11:53 uur op 30 oktober (blokhoogte 814.464), met een stijging van 2,35% naar 62,46T, waarmee een nieuw historisch hoogtepunt werd bereikt. De huidige hash-snelheid is 449 EH/s.</p>
<p>Volgens CoinDesk is volgens de gegevens van DefiLlama, na twee weken geleden het laagste punt te hebben bereikt sinds februari 2021, de totale waarde van alle activa die zijn vergrendeld door de DeFi-overeenkomst gestegen naar een drie maanden hoogtepunt van $42 miljard.</p>
<p>Het herstel van de DeFi-markt is gebaseerd op twee factoren: stijgende activaprijzen en nieuwe kapitaalinstroom van deelnemers die gericht zijn op het genereren van rendement door middel van investeringen en leningen. Bovendien bereikte het handelsvolume van elk DeFi-akkoord zijn hoogste punt sinds maart, met een totaal van $4,4 miljard op 24 oktober.</p>
<p>Na de release van Marinade (de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ecosysteem uitleenprotocol), is de TVL deze maand met 120% gestegen, met een geannualiseerd rendement van 8,15% en aanvulling van de liquiditeitsonderpandrente van 7,7%. Concurrent Jito protocol van Marinade zag gedurende dezelfde periode een stijging van 190% in TVL, wat $168 miljoen bereikte. Ondertussen, op <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, de fondsen van Enzyme Finance, Spark en Stader zijn allemaal met 37% tot 55% gestegen, wat de stijging in activaprijzen overtreft en wijst op nieuwe instroom van geldmiddelen.</p>
<p>Sui en <a href="/price/aptos-apt" rel="nofollow noopener noreferrer" target="_blank">Aptos</a> <a href="/price/aptos-apt" target="_blank" class="blog_inner_link">Aptos</a> is deze maand ook positief gegroeid, met een TVL op Sui die steeg van $34 miljoen naar $75 miljoen. Aptos werd gestimuleerd door een toename van de activiteit op het uitleenplatform Thala, met een totale TVL van $75 miljoen deze maand.</p>
<p>Volgens de wekelijkse rapportgegevens van CoinShares bedroeg de nettostroom van fondsen uit digitale activa-investeringsproducten vorige week $326 miljoen, de grootste wekelijkse instroom sinds juli 2022. Bitcoin was goed voor $296 miljoen aan kapitaalinstroom, hoewel recente prijsstijgingen ook $15 miljoen hebben aangewakkerd. <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a> in short selling Bitcoin beleggingsproducten.</p>
<p>De verbetering in <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> heeft ook geleid tot een aanzienlijke instroom van $24 miljoen in Solana, terwijl andere Altcoins ook instroom hebben gezien. En Ethereum-investeringsproducten stroomden vorige week uit met $6 miljoen.</p>
<h2 id="h2-Belangrijkste20trends20van20vandaag20in20tokens249410"><a name="Belangrijkste trends van vandaag in tokens" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijkste trends van vandaag in tokens</h2><h3 id="h3-BTC509271"><a name="BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC</h3><p><img src="https://gimg2.gateimg.com/image/article/1698731003BTC.png" alt=""><br>De korte termijn hoogte bereikt nog steeds de $36.000 mark. Op korte termijn lijkt het op een fasepiek, dus wees voorzichtig met de mogelijkheid van een high-level pinactie, wat betekent een snelle stijging naar $36.000 en vervolgens een snelle daling naar de $32.700 mark. Het wordt aanbevolen om standvastig te blijven op $32.500 en $30.800 als ondersteuningsniveaus voor de middellange termijn.</p>
<h3 id="h3-ETH815714"><a name="ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ETH</h3><p><img src="https://gimg2.gateimg.com/image/article/1698731038ETH.png" alt=""><br>Het hoogtepunt van deze maand bereikte de $1.857 markering, en er is een bearish structuur gevormd op de korte termijn. Het wordt aanbevolen om standvastig te blijven op $1.754, en als het daaronder zakt, worden er verdere dalingen verwacht, tot $1.726 en $1.694. Het totale handelsvolume zal bearish blijven.</p>
<h3 id="h3-ARK71243"><a name="ARK" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ARK</h3><p><img src="https://gimg2.gateimg.com/image/article/1698731058ARK.png" alt=""><br>Begin deze maand werd de positionering gedaan in een laag bereik van $0,4250 tot $0,4750. Convergentie is bijna een maand aan de gang geweest en is uiteindelijk tot een einde gekomen met een opwaartse trend. Het hoogste punt dat gisteren werd bereikt was $1,0875, meer dan verdubbeling van de waarde. Op korte termijn is het raadzaam om standvastig te blijven op $0,8395, en verdere winst wordt verwacht te bereiken $1,2180 en $1,70.</p>
<h2 id="h2-Macro20Federal20Reserve20News20Agency20heeft20een20vroegtijdige20waarschuwing20uitgegeven20renteverhogingen20zijn20beindigd20en20renteverlagingen20zullen20komen505714"><a name="Macro: “Federal Reserve News Agency” heeft een vroegtijdige waarschuwing uitgegeven, renteverhogingen zijn beëindigd en renteverlagingen zullen komen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: “Federal Reserve News Agency” heeft een vroegtijdige waarschuwing uitgegeven, renteverhogingen zijn beëindigd en renteverlagingen zullen komen</h2><p>Het afdekeffect van spotgoud verzwakte, zakte onder het niveau van $2.000 en sloot 0,49% lager op $1.996,26 per ounce; Spotzilver steeg met 0,95% en sloot op $23,32 per ounce. De drie belangrijkste Amerikaanse aandelenindices stegen allemaal met meer dan 1%, wat hun beste dagelijkse prestatie sinds 2 juni markeerde. De Dow steeg met 1,58%, de Nasdaq steeg met 1,16% en de S&amp;P 500-index steeg met 1,16%.</p>
<p>Nick Timiraos, een Wall Street Journal journalist die bekend staat als de “kopstuk” van de Federal Reserve en het “Nieuwe Federal Reserve Nieuwsagentschap,” schreef maandag dat hogere obligatierendementen het historische renteverhogingscyclus van de Fed kunnen beëindigen.</p>
<p>Al meer dan een jaar lang hebben functionarissen van de Federal Reserve gezegd dat ze hoge rentetarieven langer kunnen handhaven dan de verwachtingen van beleggers om inflatie te bestrijden. Het rendement op Amerikaanse langlopende staatsobligaties steeg snel van 4% begin augustus tot ongeveer 5%, wat aangeeft dat Wall Street het hier nu mee eens is.</p>
<p>Het resultaat is dat de leenkosten van Amerikaanse bedrijven en huishoudens voortdurend stijgen, wat ertoe kan leiden dat de Federal Reserve haar historische renteverhogingsproces opschort.</p>
<p>Dus heeft het spreekbuis van de Federal Reserve van tevoren informatie in de markt geïnfiltreerd, en er is misschien geen mogelijkheid om de rente in november te verhogen.</p>
<p>Waar de huidige markt enthousiast over is, is de verwachting van een einde aan renteverhogingen. Nadat de verwachting van renteverhogingen voorbij is, kijkt de markt uit naar renteverlagingen. Volgend jaar zal de golf van renteverlagingen komen, en de markt zal opnieuw koken. Op dat moment zal ook de cryptobranche zeer levendig zijn.</p>
<p>De berenmarkt, die al twee jaar aanhoudt, komt eindelijk ten einde. Als de afgelopen twee jaar moeilijk en pijnlijk zijn geweest, zullen de komende twee jaar zo gelukkig en vreugdevol zijn. Na het oversteken van de lange berenmarkt is de dageraad begonnen aan te breken. Gefeliciteerd aan iedereen die heeft volgehouden.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Byron B.</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 enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>