RGFnZWxpamtzIG5pZXV3cyB8IFVpdGdpZnRlIHZhbiBBYXZlJ3MgZWlnZW4gc3RhYmxlY29pbiBHSE8gb3ZlcnNjaHJlZWQgMjAgbWlsam9lbiwgZGUgQlRDLXZvbGF0aWxpdGVpdHNpbmRleCBiZXJlaWt0ZSBlZW4gbmlldXcgbGFhZ3RlcHVudDsgSXMgWCBGaW5hbmNpYWxpemF0aW9uIGVlbiBncm9vdCB2b29yZGVlbCB2b29yIERPR0U

2023-08-14, 03:58

<p><img src="https://gimg2.gateimg.com/image/article/16919919740814.jpg" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Lineas20mainnet20is20overgezet20naar2024783ETH20en20SANDs20zijn20vandaag20ontgrendeld20voor20meer20dan2030020miljoen156043"><a name="Crypto Daily Digest: Linea’s mainnet is overgezet naar 24.783ETH en SANDs zijn vandaag ontgrendeld voor meer dan 300 miljoen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Linea’s mainnet is overgezet naar 24.783ETH en SANDs zijn vandaag ontgrendeld voor meer dan 300 miljoen</h2><p>Wat betreft recente projecttrends, volgens DuneAnalytics-gegevens is het aantal aangevraagde WLD-tokens meer dan 16 miljoen, met 517.5471 aanvraagadressen, en verdient elke WLD-tokenaanvrager een gemiddelde winst van $55,26. Aan de andere kant heeft het mainnet van Linea 24.783ETH overbrugd, met in totaal 22.8901 transacties en 165.920 interactieve adressen.</p>
<p>Wat betreft marktgegevens, volgens Theblock-gegevens, de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De Volatility Index bereikte 42,48 en bereikte daarmee een nieuw dieptepunt dit jaar. Sommige media beweren spottend dat <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> echt een ‘stablecoin’ is geworden. De cryptomarkt wacht op een doorbraak om dit dilemma van niet stijgen of dalen te doorbreken.</p>
<p>Wat betreft uitgifte en ontgrendeling, de inheemse stablecoin GHO van <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a> heeft de 20 miljoen overschreden sinds de lancering op de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> mainnet op 15 juli. SAND zal vandaag 332,5 miljoen worden ontgrendeld, wat ongeveer 16,2% van de circulatie vertegenwoordigt. Er wordt gemeld dat de kosten voor seed round investeerders om SAND te kopen $0,0036 bedragen. Momenteel is de prijs van SAND $0,4, en de winst voor seed round investeerders zal meer dan honderd keer hoger zijn.</p>
<p>In ander nieuws heeft de vernieuwde X (voorheen Twitter) een betalingsdienst remittentielicentie verkregen van Georgia, VS, nog een licentie verkregen door X bedrijf na Michigan, Missouri en New Hampshire. Dit betekent dat Musk X kan financieren. Zou dit positief nieuws kunnen zijn voor <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a>?</p>
<p>Volgens het officiële Twitter-account van Certik heeft het EOA-adres (0xe10d) dat verband houdt met de Steadf-projectzwendel op 7 augustus 100 ETH (ongeveer $185.000) overgemaakt naar Tornado Cash. Op dit moment heeft het adres nog steeds 424 ETH (ongeveer 786.000) in bezit.</p>
<p><a href="/price/apecoin-ape" rel="nofollow noopener noreferrer" target="_blank">ApeCoin</a> heeft een nieuw voorstel gelanceerd, AIP-266 genaamd, om een nieuw voorstel genaamd ‘Efficiency Improvement Proposal EIS’ te lanceren, met als doel de <a href="/price/apecoin-ape" target="_blank" class="blog_inner_link">ApeCoin</a> Special Committee in staat te stellen om efficiëntere DAO-werkzaamheden te bevorderen. Naar verluidt eindigt de stemming over het voorgestelde amendement op 17 augustus.</p>
<p>Gisteren, <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> oprichter Hayden Adams verklaarde op Tweet dat het bedrijf geen andere band heeft met vroege werknemer AzFlin. Omdat AzFlin eerder een ontwikkelaar was van het MEME-token FRENS, enkele uren na het inzetten van het FRENS-token, gebruikte AzFlin een multi-bridge HOP om 14 WETH’s van het Base-netwerk over te dragen, en verkocht zelfs de tokens die werden voorgesteld uit liquiditeit, wat zorgen baarde over <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> vanuit de buitenwereld.</p>
<h2 id="h2-Belangrijkste20Token20Trends20van20vandaag223434"><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-BTC702193"><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/1691992007BTC.png" alt=""><br>Dagelijkse voortschrijdende gemiddelden zijn in lijn, met een convergente houding verwacht tegen de ochtend van 22 augustus. Voorzichtige bullish aanbeveling voor longposities bij een doorbraak boven $30.888 USD of shortposities bij een daling onder $28.535 USD, met behoud van algemene ondersteuning langs de paarse opwaartse trendlijn.</p>
<h3 id="h3-WLD57490"><a name="WLD" class="reference-link"></a><span class="header-link octicon octicon-link"></span>WLD</h3><p><img src="https://gimg2.gateimg.com/image/article/1691992025WLD.png" alt=""><br>De korte termijn grijpstrategie blijkt effectief, met een nauwkeurige basis op $1.650 USD, zoals verwacht terugverend naar $1.714 USD, $1.745 USD en $1.790 USD, en afsluitend op $1.845 USD, wat een herstel van 10,12% vanaf de bodem oplevert. Het langetermijnperspectief blijft bearish, waarbij observatie wordt geadviseerd voor mogelijke secundaire bodemvorming.</p>
<h3 id="h3-MC361095"><a name="MC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>MC</h3><p><img src="https://gimg2.gateimg.com/image/article/1691992040MC.png" alt=""><br>De 4-uurs grafiek doorbreekt een grootschalige convergente bovengrens. De instapposities van vorige week varieerden rond de $ 0,2568 USD, wat een opwaartse beweging liet zien naar een piek van $ 0,3700 USD in de afgelopen twee dagen, met een piekwinst van 44,08%. Winstnemingen zijn aan te bevelen. De stabiliteit op lange termijn zou moeten worden gehandhaafd op ongeveer $ 0,2930 USD.</p>
<h2 id="h2-Macro20De20aandacht20van20de20Amerikaanse20economie20is20verschoven20en20het20effect20van20renteverhogingen20is20tijdelijk20vervaagd439086"><a name="Macro: De aandacht van de Amerikaanse economie is verschoven en het effect van renteverhogingen is tijdelijk vervaagd." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De aandacht van de Amerikaanse economie is verschoven en het effect van renteverhogingen is tijdelijk vervaagd.</h2><p>CPI blijft een zorg voor de Amerikaanse regering en de Federal Reserve, en wordt momenteel verwacht, maar er is nog steeds een mogelijkheid van renteverhogingen in het vierde kwartaal.</p>
<p>De voormalige waarnemend directeur van de OCC verklaarde dat duidelijke regulering van stablecoins ten goede komt aan de wereldwijde adoptie van de Amerikaanse dollar. Sommige Amerikaanse wetgevers zijn echter van mening dat dit schadelijk kan zijn voor het financiële systeem en de economie.</p>
<p>Naarmate de hitte van het renteverhogingsevenement van de Federal Reserve afneemt, heeft de Amerikaanse overheid haar economische doel verlegd naar de detailhandelsverkopen. Dit komt omdat de markt het afgelopen jaar zeer bezorgd is geweest over inflatie, maar naarmate de prijzen afkoelen en de inflatie het doel nadert, zal de focus verschuiven.</p>
<p>Een van de beste economische indicatoren die de gezondheid van de Amerikaanse economie weerspiegelt, zijn de detailhandelsverkopen, die het focuspunt zullen worden van volgende Amerikaanse transacties. De maandelijkse detailhandelsverkopen in de Verenigde Staten worden verwacht te groeien met 0,4%, met een vorige waarde van 0,2%, een jaarlijkse lezing van 1,5% en een vorige waarde van 1,49%.</p>
<p>De verschuiving van de aandacht van de Amerikaanse overheid in de economische sector betekent dat de cryptomarkt tijdelijk niet zal worden beïnvloed door het rentebeleid van de Federal Reserve op korte termijn. Momenteel zijn de problemen waarmee de hele industrie wordt geconfronteerd meer geconcentreerd op regelgevende aspecten.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Charles T.</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 beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten voor dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>