RGFnZWxpamtzIG5pZXV3cyB8IE11c2sgdmFuIHBsYW4gb20gYWxsZSBUd2l0dGVyLWdlYnJ1aWtlcnMgaW4gcmVrZW5pbmcgdGUgYnJlbmdlbiwgQ2l0aWdyb3VwIGxhbmNlZXJ0IHRva2VuZGllbnN0ZW4sIFdhdCB6YWwgZGUgRmVkIHplZ2dlbiB3YW5uZWVyIGRlIGdvdWRwcmlqcyBvcCAkMTkzMCBzdGFhdD8=

2023-09-19, 05:21

<p><img src="https://gimg2.gateimg.com/image/article/16951015990919.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20Musk20plant20om20alle20Twittergebruikers20in20rekening20te20brengen20Citigroup20lanceert20tokenservice26565"><a name="Crypto Dagelijks Overzicht: Musk plant om alle Twitter-gebruikers in rekening te brengen; Citigroup lanceert token-service" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: Musk plant om alle Twitter-gebruikers in rekening te brengen; Citigroup lanceert token-service</h2><p>Volgens The Information verklaarde Musk maandag tijdens een live-uitzending met de Israëlische premier Netanyahu dat Twitter gebruikers een kleine maandelijkse vergoeding in rekening zal brengen om robots en spam op het platform te bestrijden. Musk heeft de nieuwe abonnementsprijs niet bekendgemaakt, maar noemde het een ‘klein bedrag aan geld’. Hij heeft het oplaadplan niet in detail gespecificeerd, noch heeft hij onthuld wanneer de kosten zouden beginnen.</p>
<p>Volgens Bloomberg heeft Citigroup een tokenservice gelanceerd als onderdeel van een bredere inspanning om digitale activa aan institutionele klanten te leveren. Het nieuwe product zet klantendeposito’s om in digitale tokens, die worden geleverd door de afdeling financiële en handelsoplossingen van het bedrijf. Tot op heden heeft de afdeling zich ingezet om deze service te gebruiken om de mogelijkheden voor kasbeheer en handelsfinanciering te verbeteren.</p>
<p>De verklaring stelt dat voor de nieuwe producten van Citigroup, het bedrijf zal vertrouwen op de privé-blockchain die eigendom is van en beheerd wordt door de bank. Klanten hoeven geen eigen digitale portemonnee op te zetten, maar kunnen toegang krijgen tot de dienst via het bestaande systeem van de bank.</p>
<p>De aankondiging van Grayscale vertegenwoordigt de aandeelhouders van elke product recorddatum vanaf het einde van de werkdag op 26 september 2022. Het doet onherroepelijk afstand van alle rechten op ETHW (ETHPoW) toegewezen aan dergelijke record-datum aandeelhouders. Grayscale vertegenwoordiging, na grondige beoordeling en overleg met de product service provider, is vastgesteld dat de productbewaarder geen ETHPoW-tokens ondersteunt en geen handelsplatform met significante liquiditeit voor ETHPoW-tokens heeft ontwikkeld.</p>
<p>Daarom is het onmogelijk om het recht op het verwerven en verkopen van ETHPoW tokens uit te oefenen, aangezien Grayscale een afstand doet van de rechten door de houders van de registratiedatum aandelen over deze activa. BlockBeats meldde eerder dat op 16 september vorig jaar, volgens een officiële mededeling, Grayscale verklaarde dat zijn ETHE en GDLC fondsen passief ongeveer 3,1 miljoen ETHW airdrop tokens hadden ontvangen en van plan waren om deze tokens binnen haalbare grenzen te verkopen en de netto-opbrengst in contanten te verdelen onder relevante aandeelhouders.</p>
<p>Volgens Bloomberg is Ant Group van plan zich terug te trekken uit zijn fonds van $ 100 miljoen en de cryptocurrency-sector te verlaten. Volgens ingewijden is Ant Group van plan zich terug te trekken uit zijn investering in A&amp;T Capital, de kern van Ant Group’s weddenschap op het gebied van digitale activa. Het is momenteel onduidelijk of dit durfkapitaalbedrijf zal blijven opereren of nieuwe investeerders zal aantrekken. Vanaf maandagmiddag stuurde de website van het bedrijf een time-outfout terug naar gebruikers. Een woordvoerder van Ant Group reageerde niet op verzoeken om commentaar.</p>
<p>A&amp;T is opgericht in april 2021 en heeft geïnvesteerd in enkele van de meest populaire crypto-startups, waaronder Matrixport, een instelling voor digitale activa-leningen, en ConsenSys, een <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> softwarefabrikant. Ant Group is een belangrijke investeerder in A&amp;T. Volgens de gegevens van PitchBook daalde het crypto-durfkapitaal in het tweede kwartaal tot het laagste niveau sinds 2020 (zoals weergegeven in de figuur), wat plaatsvond na de crash van virtuele activa vorig jaar.</p>
<p>Bovendien, <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a>, de schaalbaarheidsoplossing van <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Layer-2, heeft officieel aangekondigd dat de derde ronde van luchtdroppings zal beginnen om 2:10 (Peking tijd) op 19 september 2023, voor gebruikers die hun OP stemrechten toevertrouwden tijdens de momentopnameperiode van 8:00 (Peking tijd) op 20 januari tot 8:00 (Peking tijd) op 20 juli 2023. Het totale aantal luchtdroppings is 19.411.313 OP’s, die rechtstreeks zullen worden verdeeld over 31.870 unieke adressen zonder interactie met een website om tokens aan te vragen.</p>
<h2 id="h2-Belangrijkste20Token20Trends20van20Vandaag515684"><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-BTC822689"><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/1695101695BTC 11.53.48.png" alt=""><br>De opleving van de markt deze week heeft twee belangrijke niveaus bereikt: $26.975 en $27.283. Op korte termijn moet het binnen het handelsbereik stabiel blijven en mogelijk het ondersteuningsniveau van $26.205 testen. De maandelijkse handelsvolume lijkt nog steeds ontoereikend, dus het is raadzaam om voorzichtig te blijven en te observeren zonder posities in te nemen.</p>
<h3 id="h3-TIP503495"><a name="TIP" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TIP</h3><p><img src="https://gimg2.gateimg.com/image/article/1695101718TIP.png" alt=""><br>De token opende vandaag eerder een short positie, met een totale voorraad van 10 miljard TIP-tokens, en de initiële waardering is slechts $4 miljoen USD. U kunt overwegen om in te zetten op de dip bij $0,00028 en de markt in de gaten te houden, aangezien sociale financiering op korte termijn aandacht krijgt. Initieel worden doelen geschat op $0,00062, $0,00086 en $0,001098.</p>
<h3 id="h3-KAS943716"><a name="KAS" class="reference-link"></a><span class="header-link octicon octicon-link"></span>KAS</h3><p><img src="https://gimg2.gateimg.com/image/article/1695101738KAS 11.53.48.png" alt=""><br>Het vier-uur durende diagram toont een bullish head and shoulders patroon, en het all-time high is op het niveau van $0.05179. Op korte termijn bestaat er een kans op het her testen van het all-time high. Aggressieve strategieën moeten worden voorbereid en doel niveaus achtereenvolgens: $0.05179, $0.05458 en $0.05735. Conservatieve strategieën moeten wachten op een doorbraak voordat ze instappen.</p>
<h2 id="h2-Macro20De20goudprijs20herstelt20zich20en20toekomstige20trends20wachten20op20momentum20van20de20Federal20Reserve508934"><a name="Macro: De goudprijs herstelt zich en toekomstige trends wachten op momentum van de Federal Reserve" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De goudprijs herstelt zich en toekomstige trends wachten op momentum van de Federal Reserve</h2><p>Amerikaanse aandelen stegen licht, waarbij de Dow Jones Index met 0,02% steeg, de S&amp;P 500 Index met 0,07% en de Nasdaq Index met 0,01%. Voor Amerikaanse aandelen is het goed nieuws dat niet daalt, wat aangeeft dat de staking van de Amerikaanse autoarbeiders nog geen paniek op de markt heeft veroorzaakt. De Amerikaanse minister van Financiën Yellen verklaarde dat het nog te vroeg is om de mogelijke impact van een staking op de Amerikaanse auto-industrie te beoordelen.</p>
<p>Goudprijzen hebben een doorbraaktrend laten zien en zijn gestegen tot $1.930, boven het 50-daags voortschrijdend gemiddelde. Het rendement van de 10-jarige staatsobligatie daalde met 1,5 basispunten tot ongeveer 4,32%, dicht bij het intraday dieptepunt; Op een gegeven moment in de sessie bereikte het een hoogtepunt van 4,3565%, waarbij opnieuw een licht hoger jaarlijks hoogtepunt van 4,36% werd getest.</p>
<p>De Federal Reserve wordt verwacht de rente onveranderd te laten, maar handelaren zullen twee subtiele veranderingen in de grafiek van de Federal Reserve nauwlettend volgen.</p>
<p>Ten eerste geloofden in de vorige grafiek die in juni van dit jaar werd vrijgegeven, slechts 6 van de 18 functionarissen van de Federal Reserve dat de Fed de renteverhogingen had voltooid. Verwacht wordt dat het aantal mensen dat gelooft dat de Fed de renteverhogingen in deze rastergrafiek heeft voltooid, zal toenemen (met een gematigde trend);</p>
<p>Ten tweede en nog belangrijker, voorspellen functionarissen van de Federal Reserve de mediane punt voor 2024, wat kan wijzen op een vermindering van de renteverlagingen, waarbij slechts drie renteverlagingen volgend jaar worden getoond (wat wijst op een strakkere houding die de verwachtingen overtreft).</p>
<p>Ongeacht hoe de huidige macro markt verandert, blijft de verwachting van een renteverlaging volgend jaar bestaan, en het is ook voorbestemd om volgend jaar te worden verlaagd. Wanneer de rente wordt verlaagd, weet iedereen wat de markt zal doen, dus we zijn niet ver verwijderd van de bullish markt waarop we wachten. In elk g niet vallen in de vroege stadia van de bearmarkt. Tegelijkertijd moeten we voldoende contanten aanhouden. <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Vloeien</a> en geduldig wachten op een kans.</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 visie van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt zich alle rechten voor op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt genoemd. In alle glen zullen juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>