RGFnZWxpamtzIG5pZXV3cyB8IFBheVBhbCBsYW5jZWVyZGUgZWVuIEFtZXJpa2FhbnNlIGRvbGxhciBzdGFiaWVsZSBtdW50IFBZVVNELCBNb25ldGFpcmUgQXV0b3JpdGVpdCB2YW4gU2luZ2Fwb3JlIG9uZGVyc3RldW50IGlubm92YXRpZSBpbiBkZSBXZWIzLWluZHVzdHJpZTsgQlRDLXZvbGF0aWxpdGVpdCBkYWFsZGUgdG90IGhpc3R

2023-08-08, 03:41

<p><img src="https://gimg2.gateimg.com/image/article/16914730690808.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20De20Monetaire20Autoriteit20van20Singapore20heeft2011020miljoen20genvesteerd20in20innovatie20in20sectoren20zoals20Web203020en20PayPal20heeft20een20Amerikaanse20dollar20stabiele20munt20PYUSD20gelanceerd383838"><a name="Crypto Dagelijkse Samenvatting: De Monetaire Autoriteit van Singapore heeft $110 miljoen geïnvesteerd in innovatie in sectoren zoals Web 3.0, en PayPal heeft een Amerikaanse dollar stabiele munt PYUSD gelanceerd." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: De Monetaire Autoriteit van Singapore heeft $110 miljoen geïnvesteerd in innovatie in sectoren zoals Web 3.0, en PayPal heeft een Amerikaanse dollar stabiele munt PYUSD gelanceerd.</h2><p>Gisteren beloofde de Monetary Authority of Singapore om tot S$ 150 miljoen te verstrekken voor technologie en innovatie in de financiële sector, inclusief Web 3.0. Volgens het New Financial Sector Technology and Innovation Plan (FSTI 3.0) van de Monetary Authority of Singapore (MAS) zal er binnen drie jaar tot S$ 150 miljoen (ongeveer $110 miljoen) worden geïnvesteerd.</p>
<p>FSTI 3.0 heeft als doel innovatie te versnellen en te versterken door projecten te ondersteunen die gebruik maken van geavanceerde technologieën of regionale verbindingen, terwijl de toewijding van MAS om een levendig technologie-ecosysteem voor de financiële sector te bevorderen wordt verdubbeld.</p>
<p>Volgens Bloomberg heeft PayPal (PYPL.O) een Amerikaanse dollar-stablecoin gelanceerd voor overboekingen en betalingen. Paxos Trust Co. geeft PayPal USD (PYUSD) uit en wordt volledig ondersteund door Amerikaanse dollardeposito’s, kortlopende schatkistobligaties en soortgelijke contante equivalenten. Het is gekoppeld aan de Amerikaanse dollar en zal geleidelijk worden opengesteld voor de klanten van PayPal in de Verenigde Staten. Deze token kan ook worden overgeboekt naar compatibele portefeuilles van derden buiten het PayPal-netwerk.</p>
<p>PYUSD is ontworpen om gemakkelijk om te zetten in Amerikaanse dollars en andere cryptocurrencies die beschikbaar zijn op het PayPal-netwerk. Het kan worden gebruikt om aankopen te financieren en zal binnenkort beschikbaar zijn op PayPal’s populaire betalingsapplicatie, Venmo. Gebruikers kunnen uiteindelijk hun tokens tussen PayPal- en Venmo-wallets sturen. PayPal verklaarde dat Paxos vanaf september maandelijkse rapporten zal vrijgeven waarin de activa die PYUSD ondersteunen worden beschreven. Paxos zal ook derden-certificering van accountantskantoren vrijgeven voor PYUSD-reserve-activa.</p>
<p>Gisteren heeft de BitVol ( <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De volatiliteitsindex, gelanceerd door financieel indexbedrijf T3 Index in samenwerking met handelsplatform voor Bitcoin-opties LedgerX, daalde naar 37,08, een historisch dieptepunt van 0,96% vergeleken met 5 augustus.</p>
<p>De BitVol-index meet de verwachte geïmpliceerde volatiliteit van 30 dagen die wordt afgeleid uit verhandelbare Bitcoin-optieprijzen. Geïmpliceerde volatiliteit verwijst naar de volatiliteit die wordt geïmpliceerd door de werkelijke optieprijs. Het gebruikt de B-S optieprijsformule om de werkelijke prijs van de optie te berekenen en deze te delen door volatiliteit σ - de volatiliteit die wordt afgeleid door andere parameters in de formule te vervangen.</p>
<p>De werkelijke prijs van opties wordt gevormd door concurrentie tussen talloze optiehandelaren, daarom vertegenwoordigt geïmpliceerde volatiliteit de visies en verwachtingen van marktdeelnemers over de toekomst van de markt, en wordt beschouwd als het dichtst bij de ware volatiliteit op dat moment.</p>
<p>Bitcoin heeft volatiliteit bereikt die tot historische dieptepunten is gedaald, wat bewijst dat de huidige fase de meest rustige periode op de markt is sinds maart 2020. Bovendien is historisch gezien een dergelijke lage volatiliteit consistent met de fase van heraccumulatie na een bear markt.</p>
<p>Volgens het laatste wekelijkse rapport van CoinShares bedroeg de totale uitstroom van gelden uit digitale activaproducten vorige week $107,4 miljoen. De nettouitstroom van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> bereikte $111,4 miljoen, de grootste wekelijkse uitstroom sinds maart. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> beleggingsproducten hebben een netto uitstroom van $5.9 miljoen. <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> De beleggingsproducten van Gate.io kenden een nettostroom van $9,5 miljoen, wat een nieuw hoogtepunt is in de nettostroom voor een enkele week sinds maart 2022. De wekelijkse handelsvolume van beleggingsproducten ligt 36% lager dan het jaargemiddelde tot nu toe, maar wordt meer beïnvloed door het handelsvolume op een bredere beursmarkt, die 62% lager is dan het jaargemiddelde tot nu toe.</p>
<p>Vanuit regionaal perspectief is de uitstroom van fondsen voornamelijk geconcentreerd bij twee ETP-aanbieders in Duitsland en Canada, met respectievelijk uitstromen van $71 miljoen en $29 miljoen.</p>
<h2 id="h2-Belangrijkste20token20trends20van20vandaag807936"><a name="Belangrijkste token trends van vandaag" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijkste token trends van vandaag</h2><h3 id="h3-BTC639317"><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/1691473101BTC.png" alt=""><br>Blijft samenkomen bij de terminal, in afwachting van een keerpunt voor richtingbeslissing. Agressieve lange instapstrategie: $28.550 USD; Agressieve korte instapstrategie: $27.950 USD, met een voortdurend zicht op het niveau van $26,5K USD.</p>
<h3 id="h3-UNIBOT179736"><a name="UNIBOT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>UNIBOT</h3><p><img src="https://gimg2.gateimg.com/image/article/1691473119UNIBOT.png" alt=""><br>Op de 4-uurs grafiek vertoont zich een opwaarts convergentiepatroon, dat kortstondig de belangrijke neklijn van $157,56 USD overschrijdt. Korte termijn aandacht wordt aanbevolen, een conservatieve lange strategie adviseert te wachten op een doorbraak van de vorige hoogste waarde, met als doel vervolgens $213,81 USD, $290,16 USD en $335,56 USD.</p>
<h3 id="h3-YGG744970"><a name="YGG" class="reference-link"></a><span class="header-link octicon octicon-link"></span>YGG</h3><p><img src="https://gimg2.gateimg.com/image/article/1691473142YGG.png" alt=""><br>Gisteren werd het dagelijkse doel van $0,97786 USD bereikt, gevolgd door een aanzienlijke terugval naar het niveau van $0,33290 USD, waarbij 7 market makers betrokken waren. De marktdynamiek wijst op actieve participatie in de contractmarkt en beveelt winstnemingen aan voor degenen die op korte termijn winst hebben gemaakt.</p>
<h2 id="h2-Macro20Hawkish20en20dovish20gemengd20de20kans20dat20de20Fed20de20rente20in20september20verhoogt20is20nog20steeds20erg20laag794731"><a name="Macro: Hawkish en dovish gemengd, de kans dat de Fed de rente in september verhoogt, is nog steeds erg laag" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Hawkish en dovish gemengd, de kans dat de Fed de rente in september verhoogt, is nog steeds erg laag</h2><p>Washington brouwt een nieuwe fiscale confrontatie die het beleid van de Fed zou kunnen compliceren en de waarschuwing van Fitch zou kunnen versterken dat de schade veroorzaakt door de VS zelf zijn positie in de wereldeconomie schaadt.</p>
<p>Het Amerikaanse Congres is in augustus vertrokken, maar heeft het groeiende conflict over uitgaven en hete maatschappelijke kwesties niet opgelost, waardoor het risico op een regerings-shutdown als gevolg van de uitputting van federale fondsen na 30 september is toegenomen. Dit is het nieuwste g van ‘brinkmanship’ in de Amerikaanse begroting. Soortgelijke gebeurtenissen blijven zich voordoen, wat Fitch ertoe heeft aangezet om vorige week de AAA-rating van Amerikaanse staatsobligaties te annuleren. Deze historische beslissing heeft Wall Street en Washington in wanhoop gebracht.</p>
<p>Aan de andere kant zijn de voorzitters van de Fed deels havikachtig en deels duifachtig, waarbij ze actief informatie in de markt infiltreren. Momenteel hebben we herhaaldelijk benadrukt dat de kans op een renteverhoging in september groot is, maar qua marktsentiment is de kans op een renteverhoging vrijwel nul.</p>
<p>Dus we hoeven ons niet langer zorgen te maken over de invloed van voortdurende renteverhogingen in september op de markt. Laten we eens kijken naar wat de voorzitters van de Fed hebben gezegd.</p>
<p>De voorzitter van de New York Fed, John Williams, verklaarde dat de rentetarieven naar verwachting zullen dalen met de inflatie, en het is niet uitgesloten dat er begin 2024 een mogelijkheid is om de rentetarieven te verlagen, maar de details hangen af van economische gegevens. Er wordt verwacht dat de werkloosheid volgend jaar zal stijgen tot boven de 4%.</p>
<p>Fed-gouverneur Michelle W. Bowman ging door met ‘havikachtige’ uitspraken, waarbij ze aangaf dat er waarschijnlijk verdere renteverhogingen nodig zullen zijn om de inflatie tot de doelstelling te verlagen. Bij het nemen van beslissingen zal gezocht worden naar bewijs van een aanhoudende en betekenisvolle daling van de inflatie.</p>
<p>Voorzitter van de Atlanta Federal Reserve, Raphael Bostic, verklaarde dat er geen behoefte is om de rentetarieven in september opnieuw te verhogen en dat er geen behoefte is om de rente te verlagen vóór de tweede helft van volgend jaar.</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 opvattingen van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten voor dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen bij auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>