RGFnZWxpamtzIG5pZXV3cyB8IEJ1bGxpc2ggYWFua29vcCB2YW4gQlRDLW9wdGllcyBrYW4gQlRDIG5hYXIgJDc0SyBkcmlqdmVuOyBQYXhvcyB6YWwgZGUgcmVudGUgZHJhZ2VuZGUgc3RhYmllbGUgbXVudCBVU0RMIHVpdGdldmVuOyBTdGFibGVjb2luIE1pbnRpbmcgUHJvdG9jb2wgTV4wIEZpbmFuY2llcmluZyB2YW4gJDM1TQ==

2024-06-06, 03:32

<p><img src="https://gimg2.gateimg.com/image/article/17176446551_5.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Het20geconcentreerde20bullish20kopen20van20BTCopties20kan20BTC20naar20nieuwe20hoogtepunten20stuwen20Paxos20International20zal20gereguleerde20rentedragende20stablecoins20USDL20uitgeven20Stablecoinmintprotocol20M020financiert203520miljoen235053"><a name="Crypto Daily Digest: Het geconcentreerde bullish kopen van BTC-opties kan BTC naar nieuwe hoogtepunten stuwen; Paxos International zal gereguleerde rente-dragende stablecoins USDL uitgeven; Stablecoin-mintprotocol M^0 financiert $35 miljoen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Het geconcentreerde bullish kopen van BTC-opties kan BTC naar nieuwe hoogtepunten stuwen; Paxos International zal gereguleerde rente-dragende stablecoins USDL uitgeven; Stablecoin-mintprotocol M^0 financiert $35 miljoen</h2><p>Laten we eerst onderzoeken <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Handelsactiviteiten van ETF’s. Volgens gegevens van Farside Investor ontvingen Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s (GBTC) op 5 juni nog steeds $14,6 miljoen aan inkomende fondsen; Ondertussen had Fidelity Bitcoin spot ETF (FBTC) een instroom van $220,6 miljoen, Bitwise Bitcoin spot ETF (BITB) een instroom van $18,5 miljoen, en ARK 21 Shares Bitcoin spot ETF (ARKB) een instroom van $71,4 miljoen.</p>
<p>De gecombineerde nettostroom van Amerikaanse spot Bitcoin ETF’s bereikte het op een na hoogste niveau in de geschiedenis, met een bedrag van $886,6 miljoen.</p>
<p><strong>Bitcoin-optiehandelaren verwachten dat de prijzen een nieuw hoogtepunt zullen bereiken en door $74.000 heen zullen breken.</strong><br>Marktgegevens tonen aan dat Bitcoin (BTC) optiehandelaren constant wedden op het bereiken van een nieuwe hoogte deze maand. In een marktupdate op woensdag verklaarde QCP, een hedgefonds voor digitale activa, ‘Onze handelsafdeling heeft sterke bullish bewegingen gezien en heeft een groot aantal bull opties gekocht die vervallen in juni, wat erop wijst dat de optiemarkt deze maand een historisch hoogtepunt van $74.000 kan bereiken.’</p>
<p>Joshua Lim, medeoprichter van Arbelos Markets, een belangrijk handelsbedrijf voor cryptoderivaten, wees erop dat het dinsdag ‘bullish option buying’ zeer geconcentreerd was, met ongeveer 1.100 bull optiecontracten die gekocht werden voor 28 juni, en met uitoefenprijzen variërend van $74.000 tot $80.000, wat overeenkomt met ongeveer $80 miljoen aan nominale vraag.</p>
<p>In een Telegram-uitzending zei Paradigm, een institutioneel handelsnetwerk voor crypto-derivaten, ‘De opties van vandaag’ <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stromen</a> is duidelijk bullish. Eind juni was er een grote bullish spread in BTC-prijzen, terwijl aan het einde van juli de schaal relatief klein was.”</p>
<p>Matrixport wees erop dat het doorbreken van het niveau van $72.000 een bearish squeeze kan veroorzaken, aangezien ongeveer $1,5 miljard aan geheven futurescontracten in deze range wedden op lagere prijzen die geliquideerd kunnen worden en de opwaartse trend kunnen verergeren.</p>
<p><strong>Paxos International zal gereguleerde rente-dragende stablecoins USDL uitgeven</strong><br>Paxos International geeft een rentedragende stablecoin uit genaamd Lift Dollar (USDL). USDL zal worden gereguleerd door de Abu Dhabi Global Market (ADGM) en overnachtingrendementen uitbetalen op basis van de rente verdiend door Paxos International op zijn ondersteunende reserves.</p>
<p>USDL zal worden gedekt door liquide Amerikaanse staatsobligaties en kasreserves in een verhouding van 1:1, in overeenstemming met de eisen van de ADGM Financial Services Regulatory Authority. Paxos International zal geen rente verdienen op deze reserves, maar zal wel vergoedingen in rekening brengen bij tokenhouders voor uitgifte.</p>
<p>Paxos kondigt ook aan dat USDL zal worden uitgebracht in Argentinië via distributeurs Ripio, Buenbit, Manteca en Plus Crypto.</p>
<p>Paxos beweert dat USDL de eerste in zijn soort is. The <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Het slimme contract zal een ‘rebasing’-mechanisme gebruiken om USDL-inkomsten toe te wijzen op basis van marktomstandigheden. Volgens Bloomberg zal het rendement rond de 5% liggen. Paxos International verklaarde in een verklaring dat USDL de eerste rentegevende en gereguleerde stablecoin is. Stablecoin-houders kunnen ook rente verdienen door te staken, opnieuw te staken en te gaan yield-farmen.</p>
<p><strong>Bain Capital Crypto leidde een financieringsronde van $35 miljoen voor het stabiele-coin-muntsysteem M^0</strong><br>M^0 (M Zero) is een gedecentraliseerd stablecoin-muntprotocol dat $35 miljoen heeft opgehaald in A-ronde-financiering, geleid door Bain Capital Crypto. De officiële verklaring luidt dat het is geïmplementeerd op het Ethereum-mainnet en in de komende weken zal worden gelanceerd.</p>
<p>M^0 is een stablecoin-muntprotocol gebaseerd op Ethereum. Goedgekeurde entiteiten kunnen een stablecoin genaamd M maken, die ‘alleen over-garandeerd is door Amerikaanse schatkistobligaties’. Om M te slaan, moet de entiteit toestemming krijgen van de protocolbeheersafdeling. Eenmaal goedgekeurd, zullen ze hun eigen gestandaardiseerde ‘hoogwaardige’ onderpand verstrekken, dat onafhankelijke validators zullen inspecteren om ervoor te zorgen dat het aan de normen voldoet.</p>
<p>Op woensdag verklaarde M^0 dat andere investeerders in deze financieringsronde onder andere Galaxy Ventures, Wintermute Ventures, GSR, Caladan en SCB 10X zijn. Luca Prosperi, voorzitter van de Raad van Bestuur van de M^0 Foundation, verklaarde dat deze financieringsronde in de vorm van eigen vermogen plus tokens was. M^0 heeft twee soorten ‘governance tokens’ uitgegeven aan investeerders - POWER en ZERO, maar moet zich houden aan de lock-up periode.</p>
<p>De serie A-financiering van M^0 vond plaats in april 2023, en het bedrijf haalde $22,5 miljoen op in een financieringsronde geleid door Pantera Capital. De serie A-financiering bracht het totale financieringsbedrag van M^0 op $57,5 miljoen. Prosperi wees erop dat de vraag naar serie A-financiering 2,5 keer het opgehaalde bedrag is.</p>
<h2 id="h2-Markttrends20BTC20consolideert20op20een20hoog20niveau20terwijl20Altcoins20over20het20algemeen20stijgen84233"><a name="Markttrends: BTC consolideert op een hoog niveau, terwijl Altcoins over het algemeen stijgen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC consolideert op een hoog niveau, terwijl Altcoins over het algemeen stijgen</h2><p>BTC consolideert rond de $71.000 en kan op zoek zijn naar nieuwe richtingen. De consolidatieperiode weerspiegelt meestal het marktsentiment en investeerders moeten nauwlettend toezien op de belangrijke ondersteunings- en weerstandsniveaus. De instroom van bijna $900 miljoen in spot-ETF’s duidt op sterke interesse van institutionele beleggers en kan wijzen op toekomstig opwaarts potentieel.</p>
<p>ETH is doorgebroken naar $3.850, deze doorbraak kan verdere winsten veroorzaken, vooral aangedreven door de Layer 2 oplossing en DeFi-project.</p>
<p><a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> brak door de $700, bereikte een historisch hoogtepunt en toont sterke marktvraag. Projecten in het BNB-ecosysteem, zoals BB en BURGER, profiteren ook hiervan.</p>
<h3 id="h3-Macroeconomie802958"><a name="Macroeconomie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie</h3><p>Amerikaanse aandelenmarkt steeg: De sterke prestaties van de aandelenmarkt stimuleren doorgaans het beleggingssentiment in risicovolle activa, waaronder cryptocurrencies.</p>
<p>Renteverlagingen kunnen worden verwacht: de VS wordt verwacht de rente in september met 70% te verlagen, en de Bank of Canada heeft de rente al verlaagd. Dit kan leiden tot meer geldstromen naar risicovolle activa zoals cryptocurrencies.</p>
<h3 id="h3-Markt20Hotspots995519"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>Meme sectoren: SLERF, GME, PEOPLE, enz., hebben het goed gedaan en zijn met meer dan 20% gestegen. Investeerders kunnen zich richten op deze zeer volatiele activa, maar moeten risicobeheer in de gaten houden.</p>
<p>BNB-ecosysteem: Projecten zoals BB en BURGER profiteren van de stijging van <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> en kunnen nog verdere groeimogelijkheden hebben. Gebruikers kunnen overwegen om te zoeken naar investeringsmogelijkheden in deze projecten.</p>
<p>Pow sector: KAS steeg met 20% en bereikte een historisch hoogtepunt, met de mogelijkheid om in de toekomst de krc20-standaard te lanceren. De krc20-standaard is vergelijkbaar met de ERC20-standaard van Ethereum, dit kan meer projecten aantrekken om uitgebracht te worden op het Kas-netwerk.</p>
<p>TAIKO werd gelanceerd op Gate.io, maar de prijsprestaties waren gemiddeld. De marktkapitalisatie van $2,5 miljard kan als hoog worden beschouwd en investeerders moeten voorzichtig zijn.</p>
<p>Over het algemeen is de huidige marktprestatie sterk, maar de cryptomarkt is zeer volatiel en investeerders moeten mentaal voorbereid zijn.</p>
<h2 id="h2-Macro20Gegevens20ondersteunen20de20Fed20om20beleid20te20versoepelen20met20de20SampP2050020en20Nasdaq20die20historische20hoogtepunten20bereiken20en20de20wereldwijde20aandelenmarkten20stijgen300723"><a name="Macro: Gegevens ondersteunen de Fed om beleid te versoepelen, met de S&amp;P 500 en Nasdaq die historische hoogtepunten bereiken en de wereldwijde aandelenmarkten stijgen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Gegevens ondersteunen de Fed om beleid te versoepelen, met de S&amp;P 500 en Nasdaq die historische hoogtepunten bereiken en de wereldwijde aandelenmarkten stijgen</h2><p>Op woensdag 5 juni, gedreven door technologische aandelen, bereikten de S&amp;P 500-index en de Nasdaq-index historische slotrecords. De markt heeft economische gegevens verwerkt, die de Federal Reserve kunnen ondersteunen bij het starten van een zeer verwachte cyclus van beleid versoepeling.</p>
<p>Indexprestaties: de Dow Jones-index steeg met 0,25%, de Standard &amp; Poor’s-index steeg met 1,18% en de Nasdaq-index steeg met 1,96%.</p>
<p>Het particuliere werkgelegenheidsrapport van mei, dat woensdag werd vrijgegeven, toonde aan dat de spanning op de arbeidsmarkt is verminderd, wat de Federal Reserve ertoe kan aanzetten om dit jaar de rente te verlagen. Het rapport van dinsdag wees erop dat het aantal vacatures in april is gedaald tot het laagste niveau in meer dan drie jaar.</p>
<p>Technologische aandelen leiden de 11 sectoren van de S&amp;P 500 index, gevolgd door telecommunicatie- en industriële aandelen. De chipsector steeg met 4,5%, aangedreven door Nvidia en Taiwanese halfgeleiderfabrikanten. De marktwaarde van Nvidia heeft voor het eerst de $3 biljoen markt overschreden en is daarmee Apple voorbijgestreefd om het op één na grootste en meest waardevolle bedrijf ter wereld te worden.</p>
<p>De sterke stijging op Wall Street, afgenomen volatiliteit, afgenomen obligatierendementen en relatief stabiele Amerikaanse dollar zouden goed nieuws moeten zijn voor Aziatische beleggers op donderdag.</p>
<p>De Indiase aandelenmarkt steeg woensdag met meer dan 3%, waarbij de helft van de daling op dinsdag werd hersteld. De Nifty 50-index en de Standard&amp;Poor’s BSE Sensex-index van de National Stock Exchange of India staan momenteel boven de niveaus van vrijdag, omdat eerdere verkiezingen en definitieve resultaten voor schommelingen hebben gezorgd.</p>
<p>De euro is donderdag iets sterker geworden op de geldmarkt omdat de Europese Centrale Bank (ECB) beleidsbeslissingen zal aankondigen en handelaren geloven dat renteverlagingen vrijwel zeker zijn. De Amerikaanse dollar daalde daarentegen vanwege de hernieuwde inzet van de markt dat de Federal Reserve naar verwachting dit jaar een versoepelingscyclus zal starten. De euro steeg met 0,07% naar $1,0876 terwijl handelaren uitkijken naar de bijeenkomst van de Europese Centrale Bank later die dag om richtlijnen te krijgen over het rentebeeld van de bank.</p>
<p>De Japanse yen herstelde zich enigszins van de daling van de vorige handelsdag en steeg met 0,4% naar 155,50 yen ten opzichte van de Amerikaanse dollar.</p>
<p>Gegevens tonen aan dat de uitbreidingssnelheid van de bedrijfsactiviteit in de Eurozone in mei het snelste tempo in een jaar bereikte, omdat de groeisnelheid van de dienstensector de krimp van de productiesector overschreed. De Pan-Europese STOXX 600-index steeg met 0,8%, terwijl de meest uitgebreide aandelindex van de MSCI Asia Pacific-regio met 1% steeg. De Nikkei-index werd echter opnieuw beïnvloed door de versterking van de yen, en de Tokyo-beurs daalde met 0,9%.</p>
<p>Wat betreft grondstoffen stegen de olieprijzen in de vroege Aziatische handel op donderdag. De markt verwacht dat de Federal Reserve de rente zal verlagen in september, en de markt herstelt zich van de verkoop veroorzaakt door de toenemende Amerikaanse voorraden en de OPEC+ bevoorradingsplannen. Brent ruwe olie future stegen met 27 cent, of 0,34%, tot $78,68 per vat, terwijl West Texas Intermediate ruwe olie future met 36 cent, of 0,49%, stegen tot $74,43 per vat.</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 standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>