RGFnZWxpamtzIG5pZXV3cyB8IEFtZXJpa2FhbnNlIGJvZWtob3Vka3VuZGlnZSByZWdlbGdldmVuZGUgaW5zdGFudGllcyBtb2VkaWdlbiBwbGF0Zm9ybXMgYWFuIG9tIGNyeXB0b3MgdmFzdCB0ZSBob3VkZW4sIEhLIEN5YmVycG9ydCB3b3JkdCB2ZXJkYWNodCB2YW4gaGFja2VuLCBTSElCIFdhbHZpc3NlbiBoZWJiZW4gJDEwME0gYWF

2023-09-08, 03:58

<p><img src="https://gimg2.gateimg.com/image/article/16941520350908.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Amerikaanse20boekhoudkundige20toezichthoudende20instanties20kunnen20platforms20aanmoedigen20om20cryptocurrencies20vast20te20houden20en20Cyberport20in20Hong20Kong20wordt20verdacht20van20gehackt20te20zijn849179"><a name="Crypto Dagelijkse Samenvatting: Amerikaanse boekhoudkundige toezichthoudende instanties kunnen platforms aanmoedigen om cryptocurrencies vast te houden, en Cyberport in Hong Kong wordt verdacht van gehackt te zijn" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Amerikaanse boekhoudkundige toezichthoudende instanties kunnen platforms aanmoedigen om cryptocurrencies vast te houden, en Cyberport in Hong Kong wordt verdacht van gehackt te zijn</h2><p>Volgens The Block heeft de Financial Accounting Standards Board (FASB) nieuwe regels goedgekeurd die bedrijven in staat stellen om hun cryptocurrency-bezittingen tegen reële waarde te rapporteren.</p>
<p>De nieuwe regels zullen tegen het einde van 2023 worden aangekondigd en in 2025 van kracht worden, maar het bedrijf kan deze regels vooraf toepassen. Ingekapselde tokens vallen niet onder de nieuwe regels. Sommige professionals zijn van mening dat eerdere boekhoudkundige meetmethoden een van de grootste obstakels vormden voor instellingen om cryptocurrencies aan te houden, die aan waardevermindering moeten worden onderworpen. De reële waarde zal instellingen aanmoedigen om cryptocurrencies aan te houden.</p>
<p>Veel grote Web3-bedrijven, zoals MicroStrategy en Bitfinex, houden vast <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> op hun balans. Berenberg Capital verklaarde in een rapport dat de nieuwe regels de nadelige effecten van waardeverminderingen onder de huidige FASB-regels kunnen “eliminieren”.</p>
<p>Aan de kant van de gigant heeft Google gisteren zijn advertentiebeleid bijgewerkt. Vanaf 15 september kunnen adverteerders Google Advertising Services gebruiken om NFT-games te promoten, zolang de advertentie-inhoud geen gokgerelateerde inhoud bevat. Als je spelers aanbeveelt om in-game items te kopen die de gebruikerservaring verbeteren, zoals kleding, wapens en bepantsering van personages, voldoet dit aan het nieuwste advertentiebeleid van Google. Maar games die “NFT staking” of “sociale casino’s” promoten, worden verbannen van het gebruik van Google-advertentieservices.</p>
<p>Al in juli van dit jaar stond Google toe dat Android-gebruikers games konden downloaden uit de Google Play Store en digitale activa zoals NFT’s konden kopen, verkopen en verdienen.</p>
<p>Volgens mediaberichten heeft het Zuidoost-Aziatische multifunctionele online dienstenplatform Grab (taxi, voedselbezorging, betalingsapplicatie) een Web3-tabblad toegevoegd voor een cryptoportemonnee op basis van de <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> Netwerk. Daarvan heeft Grab samengewerkt met de Monetary Authority of Singapore om NFT-vouchers in Singapore te lanceren, die kunnen worden gebruikt voor dagelijkse maaltijden en ervaringsgerichte consumptie.</p>
<p>Gebruikers kunnen vouchers inwisselen bij geselecteerde handelaren, unieke NFT’s met Singaporese kenmerken verdienen en meer beloningen ontvangen. Grab is een van de grootste multifunctionele online platforms in Zuidoost-Azië, met het hoofdkantoor in Singapore en ongeveer 180 miljoen gebruikers.</p>
<p>Hong Kong Cyberport is gehackt, waarbij start-up bedrijfsinformatie, bedrijfsdocumenten, identiteitsdocumenten en andere informatie door hackers zijn verkregen, met een totaal van ongeveer 400 GB aan bedrijfsgegevens. In de post van X (voorheen bekend als Twitter), een account dat zich richt op netwerkbeveiliging, is te zien dat de gestolen gegevens op de website van de hacker ongeveer $300.000 (ongeveer HKD 2,35 miljoen) kost.</p>
<p>Volgens gegevens van het marktinlichtingenplatform IntoTheBlock hebben grote houders van SHIB (blauwe walvissen) gekke aankopen gedaan in de afgelopen week. Er is in totaal $100 miljoen aan SHIB verzameld, wat betekent dat deze investeerders in ieder g niet hebben deelgenomen aan de verkoop.</p>
<p>De term ‘grote houder’ verwijst hier naar het totale aantal adressen dat tussen 0,1% en 1% van het omloopvolume in handen heeft, evenals adressen die meer dan 1% van het omloopvolume in handen hebben.</p>
<p>Gegevens tonen aan dat <a href="/price/shiba-inu-shib" rel="nofollow noopener noreferrer" target="_blank">Shiba Inu</a> daalde vorige week met 7%, en de huidige prijs is ongeveer $0.00000767.</p>
<h2 id="h2-Belangrijkste20trends20van20vandaag20in20tokens61458"><a name="Belangrijkste trends van vandaag in tokens" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijkste trends van vandaag in tokens</h2><h3 id="h3-BTC216400"><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/1694152077BTC.png" alt=""><br>Het vieruurschema toont een opvallend afgerond bodempatroon, en het is de moeite waard om te observeren of <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> vandaag door het niveau van $26.510 kan breken en duurzaam erboven kan blijven. Er is een kans op voortgezette opwaartse beweging richting $26.975 en $27.283 als het doorbreekt. Als het dat niet doet, zal het waarschijnlijk blijven oscilleren binnen een bereik, waardoor het raadzaam is om een conservatieve strategie van laag kopen en hoog verkopen te hanteren.</p>
<h3 id="h3-SSV815325"><a name="SSV" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SSV</h3><p><img src="https://gimg2.gateimg.com/image/article/1694152096SSV.png" alt=""><br>SSV heeft een aanzienlijke daling meegemaakt van zijn hoogtepunt van $99 naar de huidige prijs van $16.09, waarbij de daggrafiek een neerwaartse trend vertoont. Op korte termijn kan er een opleving zijn met doelen op $16.72 en $17.36. Het wordt aanbevolen om korte termijn oplevingen te benutten met een snelle instap- en uitstapstrategie.</p>
<h3 id="h3-TORN186771"><a name="TORN" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TORN</h3><p><img src="https://gimg2.gateimg.com/image/article/1694152113TORN.png" alt=""><br>TORN, een toonaangevend project op het gebied van gemengde muntafspraken, heeft een aanzienlijke daling meegemaakt vanaf zijn hoogste punt ooit van $948,8 tot $2,91, een daling van 99,69%. De daggrafiek vertoont tekenen van bodemvorming op $2,5060 en heeft onlangs het convergerende driehoekspatroon opnieuw getest. Een verwachte doorbraak is rond 09/13 en een conservatieve strategie houdt in dat men zich op lagere niveaus positioneert.</p>
<h2 id="h2-Macro20De20vraag20naar20goud20heeft20een20nieuw20hoogtepunt20bereikt20en20renteverhogingen20kunnen20in20september20worden20opgeschort273011"><a name="Macro: De vraag naar goud heeft een nieuw hoogtepunt bereikt en renteverhogingen kunnen in september worden opgeschort" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De vraag naar goud heeft een nieuw hoogtepunt bereikt en renteverhogingen kunnen in september worden opgeschort</h2><p>Na de ISM non-manufacturing index van woensdag, die aantoonde dat de dienstensector sterk bleef, bereikte het aantal eerste aanvragen voor werkloosheidsuitkeringen dat op donderdag werd aangekondigd een zesmaands dieptepunt, wat erop wijst dat de arbeidsmarkt nog steeds veerkracht heeft en opnieuw de verwachtingen van de markt voor het aanscherpen van het beleid van de Federal Reserve versterkt. De Amerikaanse dollar index stond boven het niveau van 105 en sloot 0,19% hoger op 105,07.</p>
<p>Na het vrijgeven van sterke gegevens steeg de Amerikaanse schatkistrendement kort maar daalde daarna lichtjes. Het rendement op de schatkistpapieren van twee jaar daalde van 5,02% naar 4,95% op de dag, en het rendement op de schatkistpapieren van tien jaar daalde van 4,29% naar ongeveer 4,25%.</p>
<p>Spotgoud daalde kortstondig tijdens de handelssessie en keerde vervolgens terug naar het niveau van $1.920, maar slaagde er niet in om dat niveau aan het einde van de dag vast te houden, en sloot 0,17% hoger op $1.919,66 per ounce. Spotzilver daalde zeven opeenvolgende handelsdagen en sloot 0,86% lager op $22,97 per ounce, waarbij een nieuw dieptepunt werd bereikt in bijna drie weken.</p>
<p>Volgens een analyse van een strateeg bij JPMorgan Chase heeft de kapitaalallocatie van beleggers aan goud een 11-jarig hoogtepunt bereikt. Strateeg geleid door Nikolaos Panigrtzoglou verklaarde dat de impliciete allocatie van goud door niet-bancaire beleggers wordt geleid door het aankoopgedrag van centrale banken. Hij verkreeg deze gegevens door de voorraad goud te verdelen in gouden munten, staven of fysieke goud-ETF’s door de voorraad financiële activa.</p>
<p>Hij zei: “Volgens historische normen lijkt de allocatie van goud door investeerders momenteel behoorlijk hoog, en mensen moeten aannemen dat de structurele groei van de vraag van centrale banken de historische normale niveaus overschrijdt (vanwege zorgen over sancties of wijdverbreide uitwendige diversificatie van investeringen van overheidsobligaties van de Groep van Zeven (G7)) om optimistisch te zijn over goud.”</p>
<p>Volgens de meest recente gegevens voor het tweede kwartaal die zijn vrijgegeven door de World Gold Council, zijn de aankopen van goud door centrale banken normaler geworden. Als de aankoopacties van centrale banken genormaliseerd worden, zou goud zijn historische relatie met inflatie-gecorrigeerde obligatierendementen kunnen herstellen. Normaal gesproken zal de goudprijs voor elke stijging van 100 basispunten in het reële rendement van een 10-jarige staatsobligatie met €209 (ongeveer $224) dalen, en vice versa. Maar dat was vorig jaar niet het g.</p>
<p>Een week voor de vergadering zullen functionarissen van de Federal Reserve een periode van stilte ingaan, waarbij Logan en Williams een van de laatste functionarissen zijn die van plan zijn om in het openbaar te spreken.</p>
<p>Afgelopen donderdag lokale tijd brachten ze hun laatste openbare verklaring uit, waarin ze een pro-duif standpunt innamen en suggereerden dat renteverhogingen mogelijk worden opgeschort in september.</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 genoemd. In alle glen zal juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>