RGFnZWxpamtzIG5pZXV3cyB8IDFpbmNoIFRlYW0ga29jaHQgNjA4Ny43IEVUSHMgdGVnZW4gZWVuIGdlbWlkZGVsZGUgcHJpanMgdmFuICQxLDY1NTsgRXRoZXJldW0taGFuZGVsc2tvc3RlbiBiZXJlaWt0ZW4gZWVuIDggbWFhbmRlbiBkdXJlbmQgZGllcHRlcHVudCwgZGUgRmVkIHdvcmR0IGJlc2NodWxkaWdkIHZhbiBoZXQgYmVsZW1

2023-08-29, 03:45

<p><img src="https://gimg2.gateimg.com/image/article/16932874630829.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20The2020201inch2020team20kocht206087720ETHs20tegen20een20gemiddelde20prijs20van201655202020Ethereum2020handelskosten20bereikten20een20820maanden20laag20BlackRock20was20de20op20n20na20grootste20aandeelhouder20van20de20top20vijf20mijnbouwbedrijven20qua20marktkapitalisatie952454"><a name="Crypto Dagelijkse Samenvatting: The   1inch  team kocht 6.087,7 ETHs tegen een gemiddelde prijs van $1.655;   Ethereum  handelskosten bereikten een 8 maanden laag, BlackRock was de op één na grootste aandeelhouder van de top vijf mijnbouwbedrijven qua marktkapitalisatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: The <a href="/price/1inch-1inch" rel="nofollow noopener noreferrer" target="_blank">1inch</a> team kocht 6.087,7 ETHs tegen een gemiddelde prijs van $1.655; <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> handelskosten bereikten een 8 maanden laag, BlackRock was de op één na grootste aandeelhouder van de top vijf mijnbouwbedrijven qua marktkapitalisatie</h2><p>Gisterochtend hield Terry Gou, oprichter van de Hon Hai Technology Group (Foxconn), die eerder had opgeroepen tot de ontwikkeling van blockchain in Taiwan, een ‘Persconferentie van de Mainstream Publieke Opinie Alliantie’ bij de Zhang Rongfa Foundation in Taipei, waarbij hij officieel zijn kandidatuur voor het leiderschap van Taiwan in 2024 aankondigde.</p>
<p>Terry Gou beweerde ooit Taiwan te willen omvormen tot een AI-technologie-experimenteel eiland en gebruikte het betalingsplan van Facebook’s Libra als voorbeeld om blockchainfinanciering in Taiwan te introduceren. Hij noemde ook dat het concept van de metaverse 5-10 jaar zal duren om te implementeren en wees erop dat de virtuele valutamarkt gemengd is en nog steeds zeer speculatief is.</p>
<p>Gisteren plaatste Crypto KOL-The ₿itcoin Therapist op Twitter dat BlackRock de op een na grootste aandeelhouder is van vier van de vijf grootste mijnbouwbedrijven qua marktwaarde, Riot Blockchain, Marathon Digital Holdings, Cipher Mining en TeraWulf.</p>
<p>Volgens monitoring van @EmberCN, de <a href="/price/1inch-1inch" rel="nofollow noopener noreferrer" target="_blank">1inch</a> Het teamadres (gelabeld als 1inch: Team Investeringsfondscollectie) kocht op 28 augustus 6.087,7 ETH’s met behulp van 10 miljoen USDT’s en 70.000 USDC’s (ongeveer $10,07 miljoen), met een gemiddelde aankoopprijs van $1.655.</p>
<p>Eerder werd gemeld dat op 5 juli het 1inch-team ongeveer 11.000 ETH verkocht, deze omzette in WETH en ze in verschillende transacties omwisselde voor DAI. Vervolgens verklaarde Sergej Kunz, medeoprichter van 1inch, dat de reden voor de eerdere verkoop van 11.000 ETH was dat het team nieuwe functies aan het testen was in Fusion-modus.</p>
<p>Onlangs heeft het incident van PEPE die verpletterd werd ook voor opschudding gezorgd.</p>
<p>Gisteren plaatste oprichter klokkenluider PAULY op Twitter dat het PEPE-team eerder meer dan $10 miljoen aan fondsen uit de portemonnee van CEX had gestolen en het op de openbare markt had verkocht. Nu hebben ze de overgebleven $9,6 miljoen overgeboekt naar een portemonnee die wordt gecontroleerd door een 25-jarige anonieme persoon. Ze hadden al veel short orders geregeld voor insider trading voordat ze fondsen van CEX stalen. Hun marktmanipulatie en schendingen van insider trading gaan door.</p>
<p>Wat betreft gegevens, volgens de gegevens vrijgegeven door Bitrace’s DeTrust risico-gegevensplatform, is er in 2022 meer dan 115 miljard USDT gestroomd naar enkele Zuidoost-Aziatische platformadressen, voornamelijk inclusief $37,16 miljard aan online gokfondsen en $69,78 miljard aan witwasmiddelen, met ongeveer 460 miljoen frauduleuze USDT betrokken.</p>
<p>Het onlangs populaire SocialFi-platform, friend.tech, heeft de afgelopen 24 uur slechts $ 160.000 aan protocolkosten gegenereerd. Het is aanzienlijk gedaald vanaf zijn hoogtepunt en loopt ver achter op bekende DeFi-protocollen zoals Lido, <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a>, en MakerDAO.</p>
<p>In tegenstelling hiermee kan het protocol tot $1,12 miljoen aan protocolkosten genereren binnen 24 uur na het hoogtepunt, en het huidige cijfer is minder dan 20% van het hoogtepunt.</p>
<p>De NFT-markt blijft traag, en volgens Dune-gegevens bedroeg het handelsvolume van de NFT-markt in de afgelopen week slechts $8,91 miljoen, wat het laagste punt in twee jaar bereikte.</p>
<p>Volgens CryptoQuant-gegevens wordt de dagelijkse vergoeding die door gebruikers wordt betaald voor het uitvoeren van uitwisselingen op <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> op 27 augustus was 1.719 ETH, wat het laagste punt is sinds 26 december vorig jaar en een daling van 89% ten opzichte van het jaarlijkse hoogtepunt van 16.720 ETH op 5 mei. De daling van de totale betalingstarieven duidt op een lage netwerkgebruik, mogelijk als gevolg van de toenemende populariteit van L2-schaalbaarheidsoplossingen, een langetermijnpositieve ontwikkeling voor Ethereum.</p>
<h2 id="h2-Belangrijkste20Token20Trends20van20vandaag855959"><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-BTC730156"><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/1693280667BTC 0829.png" alt=""><br>Het 4-uursdiagram toont smalle consolidatie en oscillatie. De focus van vandaag moet liggen op het al dan niet doorbreken van het weerstandsniveau van $26.510, wat een dubbele bodempatroon zou kunnen vormen. De lagere steun staat op $25.606, terwijl de belangrijkste verdedigingslijn op $24.226 blijft.</p>
<h3 id="h3-SEI16400"><a name="SEI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SEI</h3><p><img src="https://gimg2.gateimg.com/image/article/1693280678SEI 0829.png" alt=""><br>Er zijn tekenen van een kortetermijnbodem, en de cruciale neklijn is precies gevormd op $0,1290 USD. Een potentieel omgekeerd hoofd en schouders patroon verscheen op het uurlijkse diagram, waardoor een kortetermijn herstel strategie van ongeveer $0,13 USD mogelijk is. Korte termijn doelen zijn $0,1395 USD en $0,1433 USD - snel in en uit.</p>
<h3 id="h3-DOGE831181"><a name="DOGE" class="reference-link"></a><span class="header-link octicon octicon-link"></span>DOGE</h3><p><img src="https://gimg2.gateimg.com/image/article/1693280695DOGE 0829.png" alt=""><br>De algehele dagelijkse grafiek is 835 dagen dalend geweest, mogelijk klaar voor significante prijsactie voor het einde van het jaar. De basiskoers blijft op $0,05099 USD. In het g van een onafhankelijke rally zijn de opeenvolgende doelen $0,10799 USD, $0,15879 USD, $0,43360 USD en een nieuwe historische hoogtepunt.</p>
<h2 id="h2-Macro20Amerikaanse20aandelen20stuwen20de20markt20aan202020optimisme2020met20het20Huis20dat20de20Federal20Reserve20veroordeelt20voor20het20belemmeren20van20de20betaling20van20wetgeving20inzake20stablecoin62833"><a name="Macro: Amerikaanse aandelen stuwen de markt aan   optimisme , met het Huis dat de Federal Reserve veroordeelt voor het belemmeren van de betaling van wetgeving inzake stablecoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Amerikaanse aandelen stuwen de markt aan <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">optimisme</a>, met het Huis dat de Federal Reserve veroordeelt voor het belemmeren van de betaling van wetgeving inzake stablecoin</h2><p>De Amerikaanse aandelenmarkt steeg over de hele linie en <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> in de regio Azië-Pacific doordrongen Europa en de Verenigde Staten. De Dow Jones-index sloot 0,62% hoger, de S&amp;P 500-index steeg met 0,63% en de Nasdaq-index steeg met 0,84%; De goudprijzen stegen met 0,3% tot $1920; Amerikaanse schatkistobligaties stegen en het rendement van de tweejaars schatkistobligaties daalde met 4,1 basispunten tot 5,0371%; Het rendement van de 10-jaars schatkistobligatie daalde met 3,7 basispunten tot 4,198%;</p>
<p>Op maandag bleef de markt de toespraak van Powell vorige week verwerken en wedden dat de waarschijnlijkheid van een renteverhoging van 25 basispunten in november zou toenemen van 33% een week geleden tot 51%, en ze wedden dat de rentetarieven nog een tijdje hoog zouden blijven.</p>
<p>Handelaren voorspellen dat de waarschijnlijkheid dat de Federal Reserve de rente verlaagt van de huidige niveaus tegen juni 2024 58% is, lager dan de 62% van afgelopen vrijdag en de 83% van een week geleden. Stijgende rentetarieven kunnen een onheilspellend teken zijn voor de aandelenmarkt.</p>
<p>Wachten op een reeks zware gegevens deze week, het belangrijkste risicopunt voor deze week zal beginnen vanaf donderdag, wanneer de favoriete inflatie-indicatoren van de Federal Reserve, de kern-PCE-prijsindex van juli en het rapport over niet-agrarische werkgelegenheid, zullen worden vrijgegeven. Ze zullen ofwel de twee pijlers van het herstel versterken, namelijk zachte landing en inflatie-terugtrekking, of deze drijfveren verzwakken. Er wordt verwacht dat zowel de Amerikaanse ADP-gegevens als de niet-agrarische gegevens zullen afnemen in vergelijking met eerdere waarden.</p>
<p>Aan de andere kant heeft de voorzitter van de Commissie financiële diensten van het Amerikaanse Huis van Afgevaardigden, McHenry, in een brief aan Federal Reserve-voorzitter Powell op 28 augustus verklaard dat de recente toezichts- en reguleringsbrieven (SR 23-7 en SR 23-8) van de Federal Reserve de vooruitgang die het Congres heeft geboekt bij het wetgeven ter oprichting van een regelgevend kader voor stabiele betaalcoins hebben ondermijnd en ongetwijfeld financiële instellingen zullen beletten deel te nemen aan het digitale activa-ecosysteem.</p>
<p>Congressman Patrick French Hill en Bill Huizeng schreven in hun brieven: “De Federal Reserve voorkomt dat banken betalingsstablecoin uitgeven of deelnemen aan het betalingsstablecoin-ecosysteem door deze regulerende brieven uit te geven. Het door het Congres opgezette regelgevingskader zal consumenten beter beschermen en zekerheid bieden voor marktdeelnemers, wat heeft geleid tot de introductie van de Clarity for Payment stablecoins Act. Echter, minder dan twee weken hierna heeft de Federal Reserve SR 23-7 en SR 23-8 uitgebracht zonder samen te werken met het Congres om een haalbaar mechanisme op te zetten.</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 mening van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan, mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>