RGFnZWxpamtzIG5pZXV3cyB8IE1peGluIGlzIGdlc3RvbGVuIHZvb3IgJDIwMCBtaWxqb2VuLCBNaWNyb1N0cmF0ZWd5IHZvZWd0IG9wbmlldXcgMTQwIG1pbGpvZW4gQlRDLXBvc2l0aWVzIHRvZSwgQ3J5cHRvIFZDIEluc3RpdHV0aW9uZWxlIGludmVzdGVyaW5nIHJldml0YWxpc2VlcnQ=

2023-09-26, 03:58

<p><img src="https://gimg2.gateimg.com/image/article/16957066280926.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20MicroStrategy20heeft20opnieuw20zijn20bezittingen20in20Bitcoin20verhoogd20Mixin20is20gestolen20voor2020020miljoen691756"><a name="Crypto Dagelijkse Samenvatting: MicroStrategy heeft opnieuw zijn bezittingen in Bitcoin verhoogd, Mixin is gestolen voor $200 miljoen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: MicroStrategy heeft opnieuw zijn bezittingen in <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> verhoogd, Mixin is gestolen voor $200 miljoen</h2><p>Onlangs heeft MicroStrategy in een rapport dat is ingediend bij de SEC onthuld dat het opnieuw 5445 BTC’s heeft gekocht van 1 augustus tot 24 september voor ongeveer $147,3 miljoen, met een gemiddelde prijs van $27.053. Op 4 september 2023 bezit MicroStrategy in totaal 158.245 BTC’s, met een aankoopprijs van ongeveer $4,68 miljard en een gemiddelde aankoopprijs van $29.582.</p>
<p>In het eerste kwartaal van 2023 heeft a16z 13 investeringen afgerond en het totale bedrag aan projectfinanciering dat bij de investering betrokken was, is met 86,7% gedaald ten opzichte van vorig jaar. De mate van contractie is voorstelbaar. In het tweede kwartaal was a16z in een relatief rustige periode beland. Van april tot augustus heeft a16z alleen vier hoofdinvesteringen en financieringstransacties afgerond, namelijk het on-chain IP-infrastructuur Store Protocol, het blockchain-gebaseerde kunstmatige intelligentie-rekenprotocol Gensyn, de open source softwarebeveiligingsoplossing Socket en de generatieve AI-tool Ideogram AI.</p>
<p>Met de terugkeer van Paradigm heeft a16z ook zijn vitaliteit hervonden. Vanaf augustus is a16z weer actief geworden, met een stijging van 2 investeringen in augustus naar 5 investeringen in september, gelijk aan het totaal van de afgelopen maanden. En alleen al in het midden tot eind september heeft a16z vier opeenvolgende investeringen gedaan binnen 10 dagen, waaronder Pahdo Labs, een ontwikkelingsstudio voor metaverseplatforms, Bastion, een startup die cryptocurrency-bewaring en andere diensten biedt, Freatic, een gedecentraliseerd informatiemarktprotocol, en Proof of Play, een GameFi-startup.</p>
<p>Onder de diepe beer zijn hackeracties frequent.</p>
<p>Mixin Network heeft aangekondigd dat in de vroege uren van 23 september, Hong Kong tijd, de database van de cloudserviceprovider van Mixin Network werd gehackt, wat resulteerde in gedeeltelijk verlies van activa op het hoofdnetwerk. Mixin Network heeft contact opgenomen met Google en blockchain-beveiligingsbedrijf SlowMist om te helpen bij het onderzoek. Na voorlopige verificatie gaat het om een bedrag van ongeveer $200 miljoen. De oplaadservice van Mixin Network is tijdelijk gestopt.</p>
<p>Nadat alle knooppunten hebben gediscussieerd en consensus hebben bereikt, zullen deze diensten worden heropend zodra de kwetsbaarheid is bevestigd en verholpen. Tijdens deze periode zal de overdracht niet worden beïnvloed. Het Mixin-team zal in de toekomst een oplossing aankondigen voor het omgaan met verloren activa. Mixin-oprichter Cedric Fung zal vanmiddag een openbare Mandarijnse live-uitzending geven over het incident. Mixin zal de inhoud achteraf samenvatten in het Engels ter referentie. Mixin zal alle moeite doen om verliezen te beperken en biedt diepe excuses hiervoor aan.</p>
<p>Mixin-oprichter Cedric Fung verklaarde dat de beschadigde activa deze keer voornamelijk zijn <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Kernactiva en er is geen sprake geweest van ernstige diefstal van activa zoals BOX en XIN. De specifieke aanvalssituatie kan nog niet worden bekendgemaakt. De functionaris verklaarde dat ze tot 50% van het verlies zouden compenseren, waarbij het overige deel wordt betaald in obligatietokens en wordt teruggekocht met winst. Daarnaast zal Mixin een nieuw systeem voor migratie van gebruikersactiva lanceren, maar momenteel kan slechts de helft van het gebruikerssaldo worden overgeboekt.</p>
<p>Volgens de Tianyancha-app toont de officiële website van Fegman (Beijing) Technology Co., Ltd. het als Mixin. Li Xiaolai en Mixin-oprichter Cedric Fung zijn beide aandeelhouders van Fegman (Beijing) Technology Co., Ltd. Momenteel heeft Cedric Fung 94% van de aandelen in handen, terwijl Li Xiaolai 5% heeft.</p>
<p>Volgens informatie is Luo Yonghao in februari 2016 toegetreden tot de aandeelhouders van Fegman en had hij een belang van 4%; In februari 2023 trok Luo Yonghao zich terug uit de rangen van Fegman aandeelhouders. Luo Yonghao plaatste in 2018 op Weibo: ‘Ik heb ooit meer dan 1 miljoen yuan geïnvesteerd in speculatie met munten, maar ik heb er sindsdien nooit meer om gegeven, en deze munten zijn gestegen naar meer dan 30 miljoen dollar.’</p>
<p>De laatste tijd zijn er regelmatig beveiligingsincidenten geweest, zoals de eerder genoemde Mixin-diefstal met $ 200 miljoen aan fondsen en de HTX-diefstal met ongeveer $ 8 miljoen aan fondsen.</p>
<p>Dus iedereen moet er veel belang aan hechten. Of het nu individuele beleggers of instellingen zijn, grote activa moeten door henzelf worden bewaard, en er zijn veel manieren om ze te bewaren. Ik zal niet doorgaan met breedsprakig te zijn.</p>
<p>Als de fondsen van individuele beleggers klein zijn, moeten ze ook worden geplaatst bij grote instellingen aan de frontlinie en de gewoonte ontwikkelen om hun eigen fondsen te bewaren. Het is veiliger om de fondsen over te maken naar hun eigen portefeuilles wanneer er niets mis is en probeer zo min mogelijk interactie te hebben met de portefeuilles waar de fondsen zijn geplaatst.</p>
<h2 id="h2-Belangrijkste20Token20Trends20van20vandaag788259"><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-BTC297393"><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/1695706730BTC 11.37.10.png" alt=""><br>Vorige week werd een vraagherstel voltooid en gisteren was er na een daling onder de bovengrens van het handelsbereik een lichte opleving. Op korte termijn heeft het zich niet gestabiliseerd boven de $26.510-markering. Het handelsvolume blijft zwak en de korte termijn richting lijkt bearish. Een conservatieve strategie moet wachten op een doorbraak onder het niveau van $25.281 voordat een shortpositie met een koersdoel van $24.225 als ondersteuning wordt overwogen.</p>
<h3 id="h3-LOOM899305"><a name="LOOM" class="reference-link"></a><span class="header-link octicon octicon-link"></span>LOOM</h3><p><img src="https://gimg2.gateimg.com/image/article/1695706748LOOM 11.37.10.png" alt=""><br>De dagelijkse grafiek heeft de laatste stijgende golf gevormd in een patroon van vijf golven, drie stijgende golven. De opzet van de dagelijkse grafiek op het niveau van $ 0,06202 is duurzaam. Het eerste kortetermijndoel van $ 0,12525 is bereikt. Een uitbraak zou kunnen leiden tot $ 0,15950, $ 0,17749 en de piek op $ 0,235. Het wordt aanbevolen om een trailing stop-loss-strategie te gebruiken.</p>
<h3 id="h3-WLD650875"><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/1695706767WLD 11.37.10.png" alt=""><br>De vieruursgrafiek is uitgebroken uit een grote stijgende driehoek, maar de korte termijn stijging gaat gepaard met zwak volume. Het doel op korte termijn is ingesteld op $1.845. Er bestaat echter een mogelijkheid van een snelle daling na een valse uitbraak. Op korte termijn is het raadzaam om boven de belangrijke ondersteuning van $1.665 te blijven.</p>
<h2 id="h2-Macro2010020kans20op20een20Amerikaanse20regeringssluiting20met20Moodys20waarschuwing20voor20een20verlaging726438"><a name="Macro: 100% kans op een Amerikaanse regeringssluiting, met Moody’s waarschuwing voor een verlaging" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: 100% kans op een Amerikaanse regeringssluiting, met Moody’s waarschuwing voor een verlaging</h2><p>De opmerkingen van functionarissen van de Federal Reserve hebben de verwachtingen versterkt dat de Amerikaanse rentetarieven lange tijd hoog zullen blijven, en de Amerikaanse dollarkoers is gestegen tot 106 voor het eerst sinds 30 november vorig jaar. In de late handelssessie heeft de index zijn winst enigszins ingeperkt en sloot uiteindelijk 0,341% hoger op 105,96. Het rendement op 10-jarige Amerikaanse staatsobligaties steeg kortstondig met meer dan 10 basispunten gedurende de dag, en bereikte opnieuw het hoogste niveau sinds oktober 2007, om uiteindelijk te sluiten op 4,539%.</p>
<p>De drie belangrijkste aandelenindices van de Amerikaanse aandelenmarkt sloten hoger af in een volatiele sessie, waarbij de Dow Jones Industrial Average met 0,13% steeg, de Nasdaq met 0,45% steeg en de S&amp;P 500-index met 0,4% steeg.</p>
<p>Gisteren heeft Moody’s opnieuw gewaarschuwd dat als de Amerikaanse overheid er niet in slaagt de begrotingswet aan te nemen vóór het einde van de maand en de werkzaamheden opschort, dit de kredietbeoordeling van de VS zal schaden. Het begrotingsjaar 2023 van de Amerikaanse federale overheid eindigt op 30 september, en als er op dat moment geen begrotingsplan is, zal de Amerikaanse overheid te maken krijgen met een ‘shutdown’.</p>
<p>Op dit moment geloven veel analisten dat de kans dat de Amerikaanse overheid op 1 oktober sluit 100% is.</p>
<p>Op dezelfde dag verklaarde Moody’s dat de sluiting van de regering de zwakke institutionele en bestuurskracht van de Verenigde Staten zal benadrukken. Moody’s verklaarde echter dat de opschorting waarschijnlijk geen significante invloed zal hebben op het vermogen van de Verenigde Staten om schulden af te lossen, en het wordt verwacht dat de opschorting van de regering relatief kort zal zijn, met beperkte inmenging in de overheid.</p>
<p>Deze dagen hebben we de kwestie van de bipartisan bestedingswetten gevolgd en we hebben je ook steeds verteld waarom de Amerikaanse regering de werkzaamheden heeft opgeschort en wat de impact is na de opschorting. Vandaag zullen we kort de mogelijke gevolgen na de opschorting opsommen:</p>
<p>Sluiting van overheidsdiensten: Wanneer de regering wordt opgeschort, zullen sommige departementen en instanties van de federale overheid worden gesloten, wat gevolgen heeft voor hun dagelijkse activiteiten. Deze departementen kunnen nationale parken, musea, rechtbanken, belastingdiensten, visum- en paspoortverwerking, enz. omvatten.</p>
<p>Overheidsmedewerkers: Een opschorting van de overheid kan ertoe leiden dat sommige overheidsmedewerkers tijdelijk worden ontslagen of verplicht zijn om zonder betaling te werken, wat van invloed kan zijn op miljoenen federale werknemers. Deze werknemers zijn mogelijk niet in staat om rekeningen te betalen, essentiële goederen te kopen of financiële verplichtingen na te komen.</p>
<p>Economische impact: De opschorting van de regering kan een negatieve invloed hebben op de economie. Omdat de sluiting van overheidsinstanties kan leiden tot een afname van sommige economische activiteiten, kunnen bedrijven worden getroffen door de opschorting van overheidscontracten. De werkloosheid van overheidsmedewerkers kan ook leiden tot een afname van hun uitgaven, waardoor de consumptie vertraagt.</p>
<p>Onderbreking van de sociale dienst: De opschorting van de overheid kan leiden tot de onderbreking van sommige sociale diensten, waaronder sociale uitkeringen, distributie van voedselbonnen, medische beveiliging, enz. Dit kan problemen opleveren voor degenen die van deze diensten afhankelijk zijn.</p>
<p>Zorgen over nationale veiligheid: Sommige nationale veiligheidsinstanties kunnen worden beïnvloed door opschortingen van de overheid, wat gevolgen heeft voor het verzamelen van informatie, grensbeveiliging en defensiewerk.</p>
<p>Vertrouwen en onzekerheid: een regeringssluiting kan leiden tot toegenomen marktonzekerheid en investeerders en bedrijven kunnen zich ongemakkelijk voelen over de toekomst, wat invloed kan hebben op financiële markten en zakelijke beslissingen.</p>
<p>Politieke impact: Overheidsopschortingen leiden vaak tot politieke geschillen en meningsverschillen, die een negatieve invloed kunnen hebben op de politieke sfeer en de reputatie van de regering kunnen beïnvloeden.</p>
<p>Of het nu gaat om een staking door de American Automobile Association, een shutdown door de Amerikaanse overheid, of hoe havikachtig de Federal Reserve is, we kunnen niet aanrommelen. Het resultaat van hoge rentetarieven is een stijging van verschillende kosten, en het is moeilijk voor instellingen of individuen om de 9% leenkosten te dragen. Daarom is de Amerikaanse vastgoedmarkt niet zo heet als voorheen, dus de Federal Reserve zal na dit jaar terugkeren naar de realiteit. Het zal zeker niet zoals de puntmatrixgrafiek laten zien dat de rentetarieven volgend jaar slechts twee keer worden verlaagd.</p>
<p>Op dit moment is het niet langer belangrijk voor ons om ons te richten op of en hoeveel renteverhogingen er dit jaar zullen plaatsvinden. Belangrijker is dat we moeten analyseren en beoordelen hoeveel renteverlagingen er volgend jaar zullen plaatsvinden en wanneer ze zullen worden doorgevoerd, aangezien dit direct van invloed is op de trend van de financiële markt.</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 investeringssuggesties.<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 vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>