RGFnZWxpamtzIE5pZXV3cyB8IE1lbWUgZW4gQUkgU2VjdG9yZW4gQmxpanZlbiBTdGVyazsgVGV0aGVyIFphbCBFZW4gRXh0cmEgMSBNaWxqYXJkIFVTRFRzIFVpdGdldmVuOyBSdW5lc3RvbmUgR3JhYWZ0IGhldCBHcm9vdHN0ZSBCbG9rIGluIGRlIEJUQyBHZXNjaGllZGVuaXMgT3A=

2024-03-04, 03:58

<p><img src="https://gimg2.gateimg.com/image/article/17095245811_2.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Tether20zal20nog20eens20120miljard20USDT20uitgeven20Runestone20graaft20het20grootste20blok20uit20in20de20geschiedenis20van20Bitcoin20een20groot20aantal20tokens20zoals20ARB20en20OP20zullen20in20maart20worden20ontgrendeld628801"><a name="Crypto Daily Digest: Tether zal nog eens 1 miljard USDT uitgeven; Runestone graaft het grootste blok uit in de geschiedenis van Bitcoin; een groot aantal tokens, zoals ARB en OP, zullen in maart worden ontgrendeld" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> zal nog eens 1 miljard USDT uitgeven; Runestone graaft het grootste blok uit in de geschiedenis van Bitcoin; een groot aantal tokens, zoals ARB en OP, zullen in maart worden ontgrendeld</h2><p>Laten we eens kijken naar de handelsactiviteiten van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Op 1 maart bleven de GBTC-fondsen van Grayscale doorgaan <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a> uit aanzienlijk, met een totaal van $492 miljoen; Ondertussen bedroeg de instroom van Fidelity <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF (FBTC) $49,3 miljoen, de instroom van Bitwise Bitcoin spot ETF (BITB) $42,3 miljoen, en de instroom van ARK 21Shares Bitcoin spot ETF (ARKB) $55,1 miljoen.</p>
<p>Volgens Whale  monitoring, <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> heeft nog eens 1 miljard USDT uitgegeven op het <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Netwerk. Tether CEO Paolo Ardoino verklaarde dat deze 1 miljard USDT de voorraad van het Ethereum-netwerk aanvult. Dit is een geautoriseerde maar niet uitgegeven transactie, wat betekent dat deze uitgifte zal worden gebruikt voor het volgende uitgifteverzoek en de uitwisseling van voorraden tussen ketens.</p>
<p>Ontwikkelaar Leonidas van Ordinals plaatste op het X-platform en meldde de laatste update over Runestone: “Eerder vandaag groef Runestone het grootste blok op in de geschiedenis van Bitcoin. Samen hebben we de grootste inie ooit van Ordinals gemaakt, met een grootte van 3,97 MB. Zonder de donaties van enkele leden van de Chinese Ordinals-gemeenschap om ervoor te betalen. Ik kijk ernaar uit te zien welke prestaties we kunnen behalen wanneer het Oosten en het Westen in de toekomst weer samenwerken.”</p>
<p>Ondertussen verklaarden ze ook dat de volgende stap in het airdrop-proces binnenkort zal beginnen. Leonidas voegde eraan toe: ‘Als je deelneemt aan het eerste jaar van Ordinals, zou je een Runestone moeten krijgen. Dat is het.’</p>
<p>Op dit moment is de prijs van Runestone-vloeren gestegen tot $878, met een totaal handelsvolume van $610.000. Bovendien zal Whales Market binnenkort de handelssectie Runes lanceren.</p>
<p>Volgens gegevens van Token Unlocks zullen tokens zoals ARB, OP, SUI, MANTA, enz. in maart aanzienlijke ontgrendelingen hebben, met een waarde van meer dan $3,4 miljard.</p>
<p>Representatieve tokens omvatten de Arbitrum-token ARB, die op 16 maart om 9:00 (UTC) 1,11 miljard tokens ter waarde van ongeveer $2,15 miljard zal ontgrendelen, wat overeenkomt met 87,2% van de circulerende voorraad; SUI heeft op 3 maart om 8:00 (UTC) 34,62 miljoen tokens ter waarde van ongeveer $57,46 miljoen ontgrendeld, wat overeenkomt met 2,81% van de circulerende voorraad; De Manta Network-token MANTA zal op 18 maart om 17:30 (UTC) 6,67 miljoen tokens ter waarde van ongeveer $17,47 miljoen ontgrendelen, wat overeenkomt met 2,66% van de circulerende voorraad; <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> Token OP zal op 29 maart om 12:00 (UTC) 24,16 miljoen tokens ter waarde van ongeveer $88,18 miljoen ontgrendelen, wat overeenkomt met 2,4% van de omloopvoorraad; SingularityNET-token AGIX zal op 28 maart om 8:00 (UTC) 8,84 miljoen tokens ter waarde van ongeveer $6,09 miljoen ontgrendelen, wat overeenkomt met 0,69% van de omloopvoorraad.</p>
<h2 id="h2-Markttrends20Meme20en20AI20hotspots20blijven20doorgaan20met20uitstekende20prestaties20in20POW20en20publieke20ketenprojecten677971"><a name="Markttrends: Meme en AI hotspots blijven doorgaan, met uitstekende prestaties in POW- en publieke ketenprojecten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: Meme en AI hotspots blijven doorgaan, met uitstekende prestaties in POW- en publieke ketenprojecten</h2><p>BTC kende een korte daling op zondagmiddag, maar herstelde zich snel en steeg verder, wat wijst op een zeer sterke prijstrend. Hooghefboomhandel is grotendeels opgeklaard tijdens de daling in het weekend en de marktsituatie is relatief gezond. De markt hypet herhaaldelijk rondom de AI- en Meme-velden. Het is de moeite waard om op te merken dat de markt vaak een aanzienlijke terugval doormaakt binnen 1 tot 2 maanden na een significante stijging in Meme.</p>
<p>Op macro-economisch vlak zijn Amerikaanse aandelen gestegen, waarbij het nieuws suggereert dat de eerste renteverlaging in juni van dit jaar zou kunnen plaatsvinden.</p>
<h3 id="h3-Markt20hotspots574239"><a name="Markt hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt hotspots:</h3><p>De meme-sector: deze sector zag significante stijgingen in tokens zoals PEPE, FLOKI, WIF, MOG en TRUMP. Onder hen verdrievoudigde de prijs van FLOKI in het weekend nadat er werd gestemd om 2% van de circulerende tokens te vernietigen. WIF bleef sterk presteren na de lancering van Robinhood vorige week. WIF was de derde Meme-token die Robinhood lanceerde, met de eerste twee als DOGE en SHIB. En de bovengenoemde twee valuta’s presteerden erg goed in de vorige bullmarkt.</p>
<p>POW-serie: Oude valuta’s zoals BCH, BSV, SYS en SMH hebben aanzienlijke stijgingen gezien. Naarmate de halvering van BTC in april nadert, richten mijnwerkers zich op het minen van andere POW-tokens. De logica hierachter is vergelijkbaar met de situatie waarin de rekenkracht van ETC aanzienlijk toenam nadat <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> overstapte naar POS.</p>
<p>Openbare ketenprojecten: Vanmorgen leidden FTM, ONE, NEAR en andere openbare ketenprojecten de toename, wat de aandacht en erkenning van investeerders voor deze projecten aantoont.</p>
<p>Over het algemeen bleef de weekendmarkt stabiel, maar Meme en AI blijven hete onderwerpen in de markt. Bovendien hebben het POW-concept en openbare ketenprojecten ook een uitstekende prestatie laten zien. Investeerders moeten de markttrends nauwlettend volgen, investeringsmogelijkheden grijpen, voorzichtig blijven en activa redelijk toewijzen. Gate.io zal gebruikers blijven voorzien van uitgebreide diensten om hen te helpen meer winst te behalen op het gebied van digitale activa.</p>
<h2 id="h2-Macro20Wereldwijde20aandelenmarkten20tonen20positief20sentiment20en20Aziatische20markten20staan20op20het20punt20van20groei20OPEC20lidstaten20verminderen20de20olieproductie20en20stuwen20de20olieprijzen20omhoog812528"><a name="Macro: Wereldwijde aandelenmarkten tonen positief sentiment en Aziatische markten staan op het punt van groei; OPEC+ lidstaten verminderen de olieproductie en stuwen de olieprijzen omhoog" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Wereldwijde aandelenmarkten tonen positief sentiment en Aziatische markten staan op het punt van groei; OPEC+ lidstaten verminderen de olieproductie en stuwen de olieprijzen omhoog</h2><p>Wat betreft de wereldwijde aandelenmarkten meldde Reuters dat het algemene sentiment hoog is; De MSCI World, Nikkei 225, Nasdaq, S&amp;P 500 en Stoxx 600 in Europa bereikten allemaal vorige week historische hoogtepunten. De veerkracht van de Amerikaanse economie, de afkoeling van de inflatie en de gekte rond grote technologieaandelen gedreven door kunstmatige intelligentie leggen een positieve toon voor de wereld, wat maandag vitaliteit aan de markt zou moeten brengen.</p>
<p>Het jaarlijkse Nationale Volkscongres zal dinsdag in Beijing geopend worden en de formulering ervan kan een significante invloed hebben op het bepalen van de richting van de activa van China in 2024. Als stimuleringsbeleid en maatregelen geloofwaardig zijn in de ogen van investeerders, lijkt het waarschijnlijk dat het herstel van de Chinese aandelenmarkt van een vijfjarig dieptepunt enkele weken geleden zal blijven voortzetten. Als ze investeerders niet kunnen overtuigen, kunnen ze deze dieptepunten in de komende weken opnieuw testen.</p>
<p>Vanwege slechte gegevensprestaties zijn de verwachtingen de afgelopen weken aanzienlijk afgenomen, dus het is onduidelijk of dit met name sterke economische activiteit weerspiegelt. Maar de Chinese aandelenmarkt is nog steeds de moeite waard om naar uit te kijken, met een stijging van ongeveer 10% vanaf het dieptepunt en nog steeds in een opwaartse trend dit jaar.</p>
<p>Ondertussen zal de Japanse regering volgens ingelichte bronnen een beslissing nemen nadat is vastgesteld of de jaarlijkse loononderhandelingen die op 13 maart zijn gehouden voldoende zullen zijn om prijsstijgingen te compenseren, en de vooruitzichten van prijstrends in overweging zullen nemen. Bronnen zeggen dat als dit wordt geïmplementeerd, dit zal betekenen dat Japan zich zal bevrijden van de deflatie die de economische activiteit al meer dan 20 jaar heeft ondermijnd.</p>
<p>Andere belangrijke Aziatische gegevens, voornamelijk inflatiegegevens uit Zuid-Korea, Thailand, de Filippijnen en Taiwan, evenals BBP-gegevens uit Zuid-Korea en Australië, de Chinese Caixin Services PMI en rentebesluiten, komen uit Maleisië.</p>
<p>Wat betreft grondstoffen hebben OPEC+-lidstaten onder leiding van Saoedi-Arabië en Rusland op zondag ingestemd met de verlenging van vrijwillige productieverlagingen van 2,2 miljoen vaten per dag tot het tweede kwartaal, wat extra steun biedt aan de markt te midden van zorgen over de mondiale economische groei en stijgende productie. De drie OPEC-olieproducerende landen hebben in hun respectieve verklaringen verklaard dat Irak de dagelijkse productievermindering van 220.000 vaten zal verlengen, de Verenigde Arabische Emiraten de dagelijkse productievermindering van 163.000 vaten zal handhaven en Koeweit de dagelijkse productievermindering van 135.000 vaten zal handhaven. Algerije heeft ook verklaard dat het de productie met 51.000 vaten per dag zal verminderen, terwijl Oman de productie met 42.000 vaten per dag zal verminderen. Kazachstan heeft verklaard dat het de vrijwillige productievermindering van 82.000 vaten per dag zal verlengen tot het tweede kwartaal.</p>
<p>Saudi-Arabië, de facto leider van de Organisatie van Olie-exporterende Landen (OPEC), heeft aangekondigd dat het de vrijwillige productievermindering van 1 miljoen vaten per dag zal verlengen tot het einde van juni, waarbij de productie rond 9 miljoen vaten per dag blijft.</p>
<p>Rusland, dat de OPEC-bondgenoten (gezamenlijk OPEC+) leidt, zal de olieproductie en -export in het tweede kwartaal met nog eens 471.000 vaten per dag verminderen. Uit de nieuwe gegevens verstrekt door de Russische vicepremier Alexander Novak blijkt dat het aandeel van de productieverminderingmaatregelen in deze maatregel zal blijven toenemen.</p>
<p>Hoewel zorgen over economische groei enige druk op de olieprijzen hebben gelegd, wordt verwacht dat de geopolitieke spanningen in 2024 en de aanvallen door de Housai-strijdkrachten op de scheepvaart in de Rode Zee de olieprijzen zullen ondersteunen. Hoewel er algemeen wordt verwacht dat OPEC+ de productie zal blijven verminderen, kan de aankondiging van Rusland de olieprijzen verder opdrijven.</p>
<p>Op vrijdag stegen de prijzen van Brent ruwe olie met $1,64, een stijging van 2%, naar $83,55 per vat, en zijn dit jaar met meer dan 8% gestegen. Op zondag kondigden OPEC+ lidstaten hun respectieve productieverlagingsplannen aan, gevolgd door een verklaring waarin een totale vermindering van 2,2 miljoen vaten per dag werd bevestigd. Het Saudi-Arabische nationale nieuwsagentschap SPA verklaarde dat de productievermindering geleidelijk zal worden opgeheven volgens de marktomstandigheden.</p>
<p>“De verlenging wordt verwacht, maar het verlengen tot het einde van het tweede kwartaal kan verrassend zijn,” zei Tamas Walga van oliebroker PVM. Hij voegde eraan toe: “Er wordt verwacht dat de markt sterker zal openen.”</p>
<p>Sinds het einde van 2022 heeft OPEC+ een reeks productieverminderingsmaatregelen geïmplementeerd om de markt te ondersteunen vanwege de toenemende productie in de Verenigde Staten en andere niet-leden landen die olie produceren, evenals zorgen van belangrijke economieën over hoge rentetarieven. Volgens schattingen van Reuters bedraagt de totale beloofde vermindering van de OPEC+ productie sinds 2022 ongeveer 5,86 miljoen vaten per dag, wat overeenkomt met ongeveer 5,7% van de wereldwijde dagelijkse vraag.</p>
<p>Het vooruitzicht voor de vraag naar olie dit jaar is onzeker. OPEC verwacht een relatief sterke vraaggroei, gedreven door Azië, van 2,25 miljoen vaten per dag. Tegelijkertijd voorspelt het Internationaal Energieagentschap een aanzienlijke vertraging in de vraaggroei, met 1,22 miljoen vaten per dag. Het IEA voorspelt ook dat de olieproductie dit jaar zal toenemen tot een historisch hoogtepunt van ongeveer 103,8 miljoen vaten per dag. Dit vormt verdere weerstand voor OPEC+, voornamelijk gedreven door niet-OPEC+ producerende landen, waaronder de Verenigde Staten, Brazilië en Guyana.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Sherry S.</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 beleggingsadviezen.<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>