RGFpbHkgTmV3cyB8IFNFQyBrYW4gbWVlcmRlcmUgQlRDLXNwb3QgRVRGJ3MgZ29lZGtldXJlbiwgbWVlciBkYW4gNjYgdmFsc2UgUFlVU0QtdG9rZW5zIGluIG9tbG9vcCBvcCBkZSBtYXJrdCwgTW9vZHkncyB2ZXJsYWFndCBkZSBrcmVkaWV0d2FhcmRpZ2hlaWQgdmFuIEFtZXJpa2FhbnNlIGJhbms=

2023-08-09, 04:20

<p><img src="https://gimg2.gateimg.com/image/article/16915618730809.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20Cathie20Wood20beweert20dat20de20SEC20meerdere20Bitcoin20spot20ETFs20zal20goedkeuren20er20zijn20frequente20hacker20aanvallen20geweest20met20meer20dan206620valse20PYUSD20tokens20in20omloop20op20de20markt147263"><a name="Crypto Dagelijks Overzicht: Cathie Wood beweert dat de SEC meerdere Bitcoin spot ETF’s zal goedkeuren, er zijn frequente hacker aanvallen geweest, met meer dan 66 valse PYUSD tokens in omloop op de markt." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: Cathie Wood beweert dat de SEC meerdere <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s zal goedkeuren, er zijn frequente hacker aanvallen geweest, met meer dan 66 valse PYUSD tokens in omloop op de markt.</h2><p>Gisteren verklaarde Cathie Wood, CEO van Ark Invest, in een interview met Bloomberg dat de Amerikaanse Securities and Exchange Commission (SEC) mogelijk meerdere goedkeuringen zal verlenen. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> gelijktijdig spot-ETF’s verhandelen, wat kan bijdragen aan een gelijk speelveld. Bedrijven zoals BlackRock, Fidelity, WisdomTree, VanEck en Invesco hebben allemaal aangevraagd om Bitcoin-spot-ETF’s te lanceren.</p>
<p>Wood verklaarde dat vanwege de gelijkenis van potentiële fondsen het succes van elk fonds afhankelijk zal zijn van de marketingvaardigheden van de uitgever. In juni van dit jaar verklaarde Ark Invest dat vanwege de eerdere indiening van de aanvraag van het investeringsbedrijf bij de SEC, haar aanvraag voor een Bitcoin spot ETF als eerste zou worden goedgekeurd.</p>
<p>Onlangs zijn er voortdurend beveiligingsincidenten opgedoken in de cryptoruimte, en we moeten allemaal aandacht besteden aan het voorkomen van risico’s.</p>
<p>Volgens CoinDesk zijn er momenteel meer dan 66 valse PYUSD-tokens die verschijnen op netwerken zoals <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Chain en Base, waarvan het merendeel circuleert op Ethereum.</p>
<p>Oplichters hebben geprobeerd PayPal’s Amerikaanse dollar stablecoin PayPal USD (PYUSD) te gebruiken om fraude te plegen door valse tokens uit te geven op verschillende netwerken. De grootste ‘PYUSD’-valse token werd gemunt op <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> en gelanceerd enkele minuten na de aankondiging van PayPal. Momenteel heeft het handelsvolume van de token $2,6 miljoen bereikt.</p>
<p>PayPal heeft expliciet verklaard dat PYUSD alleen kan worden verzonden tussen geverifieerde PayPal- en andere compatibele portefeuilles, en deze nep-tokens zijn waarschijnlijk een honeypot-zwendel, wat betekent dat investeerders deze tokens eenmaal gekocht niet kunnen verkopen.</p>
<p>Onlangs kondigde Paxos het contractadres aan van de Amerikaanse dollars stablecoin PYUSD van PayPal en on-chain data toont aan dat er 26,9 miljoen PYUSD zijn uitgegeven, met in totaal 8 houders. Het contractadres is 0x6c3ea903640685206290770BEdFcAbA0e23A0e8.</p>
<p>Gisteren, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Het gedecentraliseerde ecosysteemhandelsplatform Cypher van Gate.io is gehackt, wat resulteerde in een verlies van ongeveer $1 miljoen aan cryptomiddelen. Momenteel is het contract voor dit protocol bevroren en proberen ontwikkelaars contact op te nemen met de hackers om een terugbetaling van de fondsen te onderhandelen.</p>
<p>Volgens de monitoring van het Beosin EagleEye-platform van het blockchain-beveiligingsauditbedrijf Beosin is het DeFi-protocol Steadefi gehackt en is ongeveer $ 1,14 miljoen gestolen. De hacker nam controle over de wallet van de protocol-deployer en heeft het eigendom van alle kluisjes overgedragen naar de wallet onder hun controle. Op dit moment heeft de hacker alle beschikbare leenfondsen op Arbitrum uitgeput en <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Avalanche</a>, en geruilde activa voor ETH via een cross-chain brug om over te dragen naar het Ethereum mainnet. Steadefi is in onderhandeling met de hacker en is van plan een beloning van 10% aan te bieden.</p>
<p>De markt is traag en hackers hebben ook veel geduld. Gisteren meldde de media dat de hackerorganisatie Lazarus Group $37 miljoen heeft gestolen van CoinsPaid, een in Estland gevestigde cryptobetalingsservice, via een zes maanden durende social engineering hack.</p>
<p>CoinsPaid verklaarde dat in maart 2023 de ingenieurs van CoinsPaid een lijst met problemen met betrekking tot de technologische infrastructuur ontvingen van een zogenaamde ‘Oekraïense crypto-verwerkingsstartup’. Tussen juni en juli ontvingen de ingenieurs valse baanaanbiedingen. Wanneer de werknemer kwaadaardige code downloadt, kan de hacker toegang krijgen tot het systeem van CoinsPaid en softwarekwetsbaarheden gebruiken om succesvolle autorisatieverzoeken te vervalsen en fondsen uit de hot wallet van CoinsPaid te halen.</p>
<p>Wat betreft gegevens, volgens het Glassnode-rapport zijn er meer dan 13,3 miljoen BTC’s al minstens een jaar inactief op de keten, ter waarde van $388,7 miljard, wat equivalent is aan 68,54% van de BTC-omloopsupply (19.451.256 BTC’s), wat wijst op een neiging om Bitcoin voor langetermijnrendementen vast te houden.</p>
<h2 id="h2-Belangrijkste20Token20Trends20van20vandaag659607"><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-BTC798033"><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/1691561921BTC.png" alt=""><br>Op de 4-uurs grafiek is een duidelijk W bodempatroon gevormd, met potentie om een omgekeerd hoofd-en-schouderspatroon te vormen, gericht op de korte-termijn ondersteuning op $28,5K USD. Als dit niveau standhoudt, is het doel om door te breken en te streven naar $36K USD.</p>
<h3 id="h3-TARA978489"><a name="TARA" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TARA</h3><p><img src="https://gimg2.gateimg.com/image/article/1691561941TARA.png" alt=""><br>De daggrafiek is meer dan tien keer gestegen vanaf de bodem en wordt geconfronteerd met weerstand op $0.01226 USD. Kijk uit naar een mogelijke doorbraak, de volgende doelen zijn: $0.0158 USD, $0.0287 USD, $0.0437 USD.</p>
<h3 id="h3-UNIBOT24443"><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/1691561957UNIBOT.png" alt=""><br>Korte termijn posities worden ingenomen op $137.23 USD en $157.56 USD. Het bereiken van een nieuwe all-time high vanochtend kan de tweede golf van aanvallen in gang zetten. Volgende hoogtepunten worden geprojecteerd op $213.81 USD, $290.16 USD en $335.56 USD.</p>
<h2 id="h2-Macro20Moodys20verlaging20van20de20kredietwaardigheid20van20Amerikaanse20banken20verspreiding20van20paniek20over20de20financile20crisis278292"><a name="Macro: Moody’s verlaging van de kredietwaardigheid van Amerikaanse banken, verspreiding van paniek over de financiële crisis" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Moody’s verlaging van de kredietwaardigheid van Amerikaanse banken, verspreiding van paniek over de financiële crisis</h2><p>Moody’s, een van de drie belangrijkste internationale ratingbureaus, heeft de kredietwaardigheid van tien kleine banken in de Verenigde Staten met één stap verlaagd en aangekondigd dat zes grote banken worden beoordeeld, wat negatieve informatie brengt naar de kapitaalmarkt.</p>
<p>Dit heeft zorgen over financiële risico’s en crises aangewakkerd, vooral nu de Verenigde Staten in maart van dit jaar te maken kregen met een geconcentreerde uitbraak van kleine bankrisico’s. Men dacht dat Bank of America in orde was, maar de verlaging door Moody’s heeft opnieuw marktgedachten en zorgen aangewakkerd. De risiscrisis van kleine banken zal onvermijdelijk leiden tot andere belangrijke risico’s, dus de markt kan ze niet negeren.</p>
<p>Ten tweede heeft de zwakke handelsgegevens in China geleid tot een daling van de internationale olieprijzen, wat heeft geleid tot een reeks aanpassingen in de prijzen van grondstoffenfutures, wat ook van invloed is geweest op het marktsentiment. Over het algemeen is het negatieve sentiment op de Amerikaanse markt voornamelijk te wijten aan de impact van de combinatie van dit slechte nieuws. Deze superpositie kan het effect van het bericht versterken, niet alleen slecht nieuws maar ook goed nieuws.</p>
<p>Voorzitter van de Philadelphia Federal Reserve, Patrick Harker, gelooft dat de Amerikaanse economie op een gestage neerwaartse traject is en dat de Federale Reserve mogelijk een punt heeft bereikt waarop de rentetarieven stabiel kunnen blijven. Het wordt verwacht dat de kern PCE-index tegen het einde van 2023 zal dalen tot iets onder de 4%, onder de 3% tegen 2024 en het doel van 2% tegen 2025 zal bereiken. Een zachte landing voor de economie is zeer waarschijnlijk.</p>
<p>Richmond Fed-voorzitter Thomas Barkin verklaarde dat het BBP van de VS stabiel blijft en de arbeidsmarkt veerkrachtig blijft. De inflatie is nog steeds te hoog. Hij wil niet ‘vooraf aankondigen’ waar de rentetarieven naartoe zullen gaan.</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 standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<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 er juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>