RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBkb29yYnJhayAkNzFLLCBhbHRjb2lucyBzdGVnZW4gb3ZlciBoZXQgYWxnZW1lZW47IFNoaWJhcml1bS1vbnR3aWtrZWxhYXJzIHdhYXJzY2h1d2RlbiB0ZWdlbiB2ZXJ2YWxzdGUgVFJFQVRzOyBCbG9ja2NoYWluIEF2YWlsIG9udHZpbmcgJDQzTSBhYW4gU2VyaWUgQS1maW5hbmNpZXJpbmc=

2024-06-05, 03:41

<p><img src="https://gimg2.gateimg.com/image/article/17175629131_4.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20Bitcoin20brak20door207100020geconfronteerd20met20volatiliteit20en20verkoopdruk20Ontwikkelaars20van20Shibarium20gewaarschuwd20voor20vervalste20TREATtokens976010"><a name="Crypto Dagelijks Overzicht: Bitcoin brak door $71.000, geconfronteerd met volatiliteit en verkoopdruk; Ontwikkelaars van Shibarium gewaarschuwd voor vervalste TREAT-tokens" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> brak door $71.000, geconfronteerd met volatiliteit en verkoopdruk; Ontwikkelaars van Shibarium gewaarschuwd voor vervalste TREAT-tokens</h2><p>Eerst zullen we de handelsactiviteiten van onderzoeken. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens gegevens van Farside Investor ontvingen Grayscale Bitcoin spot ETF’s (GBTC) op 4 juni een instroom van $28,2 miljoen aan fondsen. Ondertussen had Fidelity Bitcoin spot ETF (FBTC) een instroom van $378,7 miljoen, Bitwise Bitcoin spot ETF (BITB) had een instroom van $61 miljoen en ARK 21Shares Bitcoin spot ETF (ARKB) had een instroom van $138,7 miljoen.</p>
<p><strong>Bitcoinprijzen bereiken $71,000, met aanstaande volatiliteit en verkopersdruk</strong><br>In de afgelopen 24 uur heeft Bitcoin kort de $71.000-grens doorbroken, wat heeft geleid tot een kort liquidatiebedrag van meer dan $20 miljoen. De huidige handelsprijs van Bitcoin is ongeveer $70.853,01, wat een stijging van meer dan 3% betekent in de afgelopen 24 uur. Het totale bedrag aan geliquideerde Bitcoin-posities bedroeg $27 miljoen, terwijl de bredere cryptomarkt tijdens dezelfde periode meer dan $87 miljoen aan liquidaties heeft ondergaan.</p>
<p>De marktrapport van Glassnode van dinsdag toont aan dat de verkoopdruk van lange termijn Bitcoin-houders (die Bitcoin 3 maanden tot 3 jaar vasthouden) toeneemt. Het rapport suggereert dat als de prijzen stijgen, de motivatie voor deze houders om meer aanbod te verkopen zal toenemen, waardoor hun niet-gerealiseerde winsten zullen toenemen.</p>
<p>Glassnode wees er ook op dat de prijs van Bitcoin in de afgelopen 24 uur is gestegen tot meer dan $68.000, waardoor slechts 0,03% van de langetermijnbezitters verlies lijdt. Analisten zeggen dat de stijgende prijzen de meeste kortetermijnbezitters hebben gedwongen om ongerealiseerde winsten terug te krijgen.</p>
<p>Na een relatief stabiele periode in de afgelopen week wordt verwacht dat de prijsvolatiliteit van Bitcoin zal toenemen.</p>
<p><strong>Ontwikkelaars van Shibarium waarschuwden tegen valse TREAT-tokens</strong><br>Op 2 juni heeft het teamlid en ontwikkelaar Da Vinci van het Shibarium-team een waarschuwing aan de gemeenschap gegeven, waarin staat dat kwaadwillige activiteiten op internet hebben geleid tot de uitgifte van valse TREAT-tokens. DaVinci herinnert investeerders en gemeenschapsleden eraan dat de TREAT-tokens die momenteel op de markt zijn, geen verband houden met de echte tokens die zijn ontwikkeld door het Shibarium-team. Kwaadwillende actoren hebben ook officiële shib.io-adressen gebruikt in hun online berichten om valse tokens meer geloofwaardigheid te geven.</p>
<p>De CoinGecko-pagina waarschuwde ook dat deze token niet gerelateerd is aan <a href="/price/shiba-inu-shib" rel="nofollow noopener noreferrer" target="_blank">Shiba Inu</a> en zijn aankomende Layer 3 blockchain, waarbij beleggers eraan herinnerd worden om een grondig onderzoek te doen voordat ze tokens verhandelen.</p>
<p>De echte TREAT-token moet nog worden uitgegeven. Het is een van de vijf tokens in het Shibarium-ecosysteem, waarvan de andere drie Shiba Inu, BONE, LEASH en SHI-stablecoins zijn. TREAT-tokens worden voornamelijk gebruikt als beloningstokens om beloningen te distribueren vanuit de Shiba Lands-metaverse en de Shiba Eternity-kaartspellen. Ze zullen ook worden gebruikt om te helpen bij het in balans brengen van de zich ontwikkelende SHI-stablecoins. Bovendien zal TREAT ook de privacylaag van Shibarium ondersteunen, waardoor gebruikers op de keten een hogere anonimiteit kunnen verkrijgen.</p>
<p><strong>Modulaire blockchain Avail ontving $43 miljoen aan Series A-financiering, er wordt verwacht dat het mainnet binnenkort gelanceerd zal worden</strong><br>Het modulaire blockchainproject Avail, dat werd afgescheiden van <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> vorig jaar, bouwt een rollup-gecentreerde infrastructuur en heeft $43 miljoen opgehaald in Series A-financiering voordat het wordt uitgebracht op het mainnet.</p>
<p>Op dinsdag verklaarde Avail dat deze financieringsronde gezamenlijk wordt geleid door Peter Thiel’s Founders Fund, Dragonfly en Cyber Fund. Andere investeerders zijn onder andere SevenX Ventures, Figment Capital, Nomad Capital en Chapter One. Veel investeerders, zoals Founders Fund en Dragonfly, zijn langdurige supporters van Avail en hebben hun investering in dit project verhoogd.</p>
<p>Avail’s Series A-financiering werd drie maanden na de oprichting van het bedrijf in februari van $27 miljoen aan zaaikapitaal uitgevoerd. Medeoprichter Anurag Arjun verklaarde in een interview met The Block dat deze financiering het totale financieringsbedrag van Avail op $75 miljoen brengt, inclusief $5 miljoen aan pre-seed-financiering.</p>
<p>Arjun onthulde dat Serie A-financiering een combinatie van SAFE (Simple Agreements for Future Equity) en SAFT (Simple Agreement for Future Tokens) aanneemt en vorige week officieel is afgerond. Hij weigerde echter commentaar te geven op de waardering. Bronnen zeggen dat Avail tijdens zijn financieringsronde in februari een volledig verwaterde waardering van honderden miljoenen dollars had.</p>
<p>Op dit moment bevindt Avail DA zich in de incentive testingnet-fase. Tijdens piekperiodes heeft het naar verluidt 310 validators, maakt het bijna 110.000 accounts aan en verwerkt het 116 miljoen transacties. Arjun verklaarde dat het Avail DA-mainnet naar verwachting samen met AVAIL-tokens zal worden gelanceerd in de komende weken.</p>
<h2 id="h2-Markttrends20BTC20benaderde20zijn20historische20hoogtepunt20Altcoins20stegen20over20het20algemeen429361"><a name="Markttrends: BTC benaderde zijn historische hoogtepunt, Altcoins stegen over het algemeen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC benaderde zijn historische hoogtepunt, Altcoins stegen over het algemeen</h2><p>BTC doorbrak $71.000 en nadert een historisch hoogtepunt. Dit geeft aan dat de vraag naar Bitcoin sterk blijft, mogelijk gedreven door voortdurende nettostromen van Bitcoin spot ETF’s.</p>
<p>ETH brak door $3.800 en toonde sterke opwaartse momentum. De stijging van ETH kan gerelateerd zijn aan de voortdurende uitbreiding van zijn ecosysteem en de vooruitgang van Layer 2-oplossingen.</p>
<p>Altcoins stegen over het algemeen: Dit is meestal een teken van een optimistisch marktsentiment, aangezien beleggers zich tot hoger risico Altcoins wenden na winst te hebben gemaakt met mainstream valuta.</p>
<h3 id="h3-Macroeconomie242121"><a name="Macroeconomie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie</h3><p>De Amerikaanse dollarindex daalde: Een verzwakking van de Amerikaanse dollar komt meestal ten goede aan de cryptomarkt, omdat cryptocurrencies worden gezien als activa om zich te beschermen tegen de waardedaling van de Amerikaanse dollar.</p>
<p>Amerikaanse aandelenmarkt steeg: De stijging van de aandelenmarkt en de verbetering van werkgelegenheidsgegevens hebben de marktverwachtingen voor renteverlagingen verhoogd, wat investeerders verder kan duwen naar de risicovolle activamarkt, inclusief cryptocurrencies.</p>
<h3 id="h3-Markt20hotspots205525"><a name="Markt hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt hotspots:</h3><p>BTC-ecosysteemprojecten zagen over het algemeen een toename: projecten zoals CKB, STX, ORDI en PUPS zijn aanzienlijk toegenomen, wat het marktvertrouwen in het Bitcoin-ecosysteem aantoont. In het bijzonder de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Layer2-project STRK heeft aangekondigd dat het zich zal uitbreiden naar de BTC Layer 2-track, wat mogelijk meer innovatie en toepassingen met zich meebrengt.</p>
<p><a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> en zijn ecosysteemprojecten: <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> brak door $700 en bereikte een historisch hoogtepunt, wat de groei van ecosysteemprojecten zoals CAKE, XVS en BAKE stimuleerde. De sterke stijging van UNI en de aankondiging van zijn officiële account hebben ook veel aandacht van de markt getrokken, wat mogelijk te maken heeft met de schikking met de Amerikaanse SEC, wat een belangrijke positieve ontwikkeling zal zijn.</p>
<p>TON-ecosysteem: De aanzienlijke stijging van TON en NOT heeft gezorgd voor de opkomst van het ecosysteem Meme coin FISH, wat het vertrouwen van investeerders in het TON-ecosysteem aantoont. De marktkapitalisatie van FISH is slechts 1% van NOT, maar de intraday-stijging is meer dan 100%, wat wijst op de hoge risicovoorkeur van de markt voor tokens met een kleine marktkapitalisatie.</p>
<p>De sterke prestaties van de huidige crypto-markt zijn voornamelijk te danken aan de stijgende prijzen van Bitcoin en Ethereum, verbeterde marktliquiditeit en ondersteuning vanuit de macro-economische omgeving. Daarnaast heeft de geconcentreerde uitbraak van markthotspots, zoals de prestaties van BTC ecosysteemprojecten en BNB-keten ecosysteemprojecten, ook meer investeringsmogelijkheden naar de markt gebracht.</p>
<h2 id="h2-Macro20Arbeidsmarktgegevens20zijn20zwak20met20Amerikaanse20aandelen20die20licht20hoger20sloten20Aziatische20aandelenmarkten20stegen20als20gevolg20van20de20verwachtingen20van20renteverlagingen20India20wordt20het20middelpunt833549"><a name="Macro: Arbeidsmarktgegevens zijn zwak, met Amerikaanse aandelen die licht hoger sloten; Aziatische aandelenmarkten stegen als gevolg van de verwachtingen van renteverlagingen; India wordt het middelpunt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Arbeidsmarktgegevens zijn zwak, met Amerikaanse aandelen die licht hoger sloten; Aziatische aandelenmarkten stegen als gevolg van de verwachtingen van renteverlagingen; India wordt het middelpunt</h2><p>Op dinsdag 4 juni meldde Reuters dat de Amerikaanse aandelenmarkt licht daalde. De meest recente gegevens tonen een vertraging in de economische groei van de VS en zwakke arbeidsmarktcijfers, wat de verwachting van de Federal Reserve voor renteverlagingen verder heeft ondersteund.</p>
<p>De gegevens van maandag toonden aan dat de Amerikaanse productieactiviteit in mei voor de tweede opeenvolgende maand vertraagde. De op dinsdag vrijgegeven gegevens toonden aan dat het aantal vacatures in de Verenigde Staten in april daalde naar het laagste niveau in meer dan drie jaar, wat de spanning op de arbeidsmarkt verlichtte en de verwachting van renteverlagingen van de Federal Reserve dit jaar ondersteunde. Na de publicatie van het rapport daalde het rendement van Amerikaanse schatkistobligaties. De gegevens over de werkgelegenheid buiten de landbouw voor mei worden vrijdag bekendgemaakt.</p>
<p>Technologieaandelen vertegenwoordigd door bedrijven als Amazon, Alphabet, Nvidia en Microsoft sloten hoger na een daling in de vroege handelssessie.</p>
<p>Op de valutamarkt stabiliseerde de Amerikaanse dollar op woensdag omdat handelaren hun hoogrisico weddenschappen verminderden in opkomende markten terwijl ze wachtten op Canadese rentebeslissingen en Amerikaanse gegevens over de dienstensector. In de vroege Aziatische handel daalde de Japanse yen met 0,2% tot 155,27 en bleef hangen op 168,74 tegen de euro. Eerder steeg de euro ‘s nachts met 1% ten opzichte van de Amerikaanse dollar, wat de grootste maandelijkse stijging markeerde.</p>
<p>Uit de gegevens van woensdag blijkt ook dat de reële lonen in Japan in april voor de 25e opeenvolgende maand zijn gedaald, omdat de inflatie de nominale loongroei overtrof. De Japanse yen is dit jaar de slechtst presterende G10-valuta en de vicegouverneur van de Bank of Japan heeft verklaard dat de centrale bank ‘zeer waakzaam’ moet zijn over de mogelijke impact van een zwakke yen op de economie en de inflatie.</p>
<p>Op woensdag 5 juni stegen Aziatische aandelenmarkten. De verzwakking van de Amerikaanse arbeidsmarkt heeft de marktverwachtingen voor de renteverlaging van de Federal Reserve in september versterkt, terwijl de Amerikaanse dollar stabiel blijft. De zorgen van beleggers over de afkoeling van de Amerikaanse economie hebben de risicobereidheid onderdrukt, en de focus van Azië is verschoven naar de situatie in India.</p>
<p>De Indiase verkiezingsuitslagen tonen aan dat de overwinning van de Indiase premier Narendra Modi lager was dan verwacht, wat heeft geleid tot een daling van de Indiase aandelenmarkt en een depreciatie van de roepie. Omdat dit de eerste keer in tien jaar is dat de Indiase Volkspartij onder leiding van Modi een parlementaire meerderheid heeft verloren, moet ze vertrouwen op regionale bondgenoten om de benodigde zetels te verwerven om het grootste democratische land ter wereld te regeren. Dit heeft geleid tot onzekerheid in voorspellingen over het economische beleid, inclusief het stimuleren van investeringsgestuurde groei, wat altijd de hoeksteen is geweest van Modi’s regering.</p>
<p>De MSCI Asia Pacific aandelenindex steeg met 0,24%, terwijl de Nikkei-index met 0,8% daalde, omdat de yen een twee weken hoogtepunt bereikte.</p>
<p>De Chinese aandelenmarkt schommelde, waarbij een particuliere sector enquête op woensdag liet zien dat de groeisnelheid van de dienstverlenende industrie in China in mei de snelste was in 10 maanden, en het aantal personeelsleden voor het eerst sinds januari toenam, wat erop wijst dat de dienstverlenende industrie zal blijven herstellen in het tweede kwartaal. De blauwe chip Shanghai en Shenzhen 300 Index vertoonden weinig verandering in de vroege handelssessie, terwijl de Hong Kong Hang Seng Index met 1% steeg.</p>
<p>De S&amp;P Global Service Purchasing Managers Index (PMI) steeg van 52,5 in april naar 54,0, wat de 17e opeenvolgende maand van expansie markeert en de snelste groeisnelheid sinds juli 2023.</p>
<p>Wat betreft grondstoffen daalden de olieprijzen in Azië lichtjes in de vroege handelssessie. Een brancherapport toonde een stijging van Amerikaanse ruwe olie- en brandstofvoorraden aan, wat de marktzorgen over de vraag verergerde. Brent ruwe olie futures daalden met 0,1% tot $77,47 per vat, terwijl West Texas Intermediate ruwe olie futures in de Verenigde Staten met $0,12 daalden tot $73,16 per vat.</p>
<p>De prijs van goud steeg met 0,09% naar $2.330 per ounce.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Sherry S. &amp; Icing</strong>, Gate.io-onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen 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 zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>