RGFnZWxpamtzIG5pZXV3cyB8IE1pY3JvU3RyYXRlZ3kga29jaHQgb3BuaWV1dyBCVEMsIEp1c3RpbiBTdW4gZW4gYW5kZXJlIGtvcHN0dWtrZW4ga29jaHRlbiBsYWdlIENSViBlbiB6aWpuIG9wdGltaXN0aXNjaCBvdmVyIGRlIHRvZWtvbXN0IGVydmFuLCBkZSBJbnRlcm5hbCBSZXZlbnVlIFNlcnZpY2UgaGVlZnQgZWVuIG5pZXV3ZSB

2023-08-02, 04:03

<p><img src="https://gimg2.gateimg.com/image/article/16909546010802.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20MicroStrategy20koopt20opnieuw20BTC20en20de20Internal20Revenue20Service20brengt20een20nieuwe20gids20uit20voor20de20betaling20van20crypto20belasting583805"><a name="Crypto Dagelijks Overzicht: MicroStrategy koopt opnieuw BTC, en de Internal Revenue Service brengt een nieuwe gids uit voor de betaling van crypto belasting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: MicroStrategy koopt opnieuw BTC, en de Internal Revenue Service brengt een nieuwe gids uit voor de betaling van crypto belasting</h2><p>MicroStrategy lanceerde opnieuw. Michael Saylor, oprichter van MicroStrategy, verklaarde op sociale media dat MicroStrategy in juli opnieuw 467 bitcoins kocht voor ongeveer $14,4 miljoen.</p>
<p>Volgens het financiële rapport van MicroStrategy heeft het zijn bezit van 12.333 bitcoins verhoogd in het tweede kwartaal. Op 31 juli 2023 heeft MicroStrategy 152.800 bitcoins gekocht voor ongeveer $4,53 miljard, met een gemiddelde prijs van $29.672 per stuk. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>. Volgens de documenten die door MicroStrategy zijn ingediend bij de U.S. Securities and Exchange Commission (SEC), is MicroStrategy van plan om tot $750 miljoen aan aandelen uit te geven en te verkopen voor algemene bedrijfsdoeleinden, zoals het verwerven van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> en werkkapitaal.</p>
<p>Zodra dit nieuws naar buiten kwam, begon Bitcoin de markt te trekken, en nu is het teruggekeerd naar het vorige schokbereik. Er is geen twijfel dat MicroStrategy op tijd en overtuigend overtuigd was dat Bitcoin in de toekomst een internationale valuta zou worden, anders zouden ze niet op deze manier grootschalige aankopen hebben gedaan.</p>
<p>We weten nu dat BlackRock en andere grote instellingen achter ons staan. Aangezien iedereen aan boord is, zullen we in de toekomst gek exporteren. BlackRock en andere instellingen hebben genoeg kracht zodat we kunnen wachten.</p>
<p>Het CRV-evenement is viraal gegaan in de DeFi-kring. In de afgelopen twee dagen hebben Justin Sun en Jeffrey Huang CRV’s gekocht via OTC, evenals Jihad Wu en anderen. Ze zijn optimistisch en denken dat CRV de hoeksteen is van DeFi, dus iedereen is vrijgevig om lage CRV’s te kopen.</p>
<p>Op dit moment heeft Jeffrey Huang volgens informatie op de keten 3,75 miljoen CRV’s ingezet en vergrendeld in het Curve-protocol die hij via OTC van de oprichter van Curve heeft verworven. Het adres dat is gemarkeerd als ‘Justin Sun’ heeft zojuist 2 miljoen USDT’s overgemaakt naar het adres van de oprichter van Curve. Vervolgens heeft de oprichter van Curve 5 miljoen CRV’s overgemaakt naar het adres van Justin Sun.</p>
<p>Curve-oprichter Michael Egorov heeft vandaag in totaal 54,5 miljoen CRVs verkocht en $21,8 miljoen opgehaald. Daarvan werden er 12,5 miljoen CRVs verkocht aan DWFLabs; 3,75 miljoen CRVs werden verkocht aan Huang Licheng; 2,5 miljoen CRVs werden verkocht aan Cream Finance; 2,5 miljoen CRVs werden verkocht aan adressen die beginnen met 0xb0b; 2,5 miljoen CRVs werden verkocht aan adressen die beginnen met 0xb0b; 1,25 miljoen CRVs werden verkocht aan adressen die beginnen met 0xcb5; en 250.000 CRVs werden verkocht aan adressen die beginnen met 0x9db.</p>
<p>De belangrijkste leenposities van Curve-oprichter Egorov zijn allemaal hersteld tot gezonde tarieven boven 1,6. Daarvan is de leengezondheidsgraad op <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a> V2 is 1.67; De gezondheidstarieven van de twee leningen op Abracadabra waren respectievelijk 1.63 en 1.89; Het gezondheidstarief voor leningen op Fraxlend is 1.91.</p>
<p>Gisteren heeft de Internal Revenue Service een nieuwe gids uitgegeven waarin staat dat de staking beloningen die verkregen zijn op de POS blockchain onderhevig zijn aan belasting.</p>
<p>Volgens een besluit van de Internal Revenue Service (IRS) op maandag moeten cryptocurrency investeerders die beloningen ontvangen voor validatieactiviteiten op het Proof of Stake (POS) netwerk deze beloningen opnemen in hun inkomsten in het jaar waarin ze deze tokens onder controle hebben.</p>
<p>Volgens juridische analyse omvat ‘de reële marktwaarde van de validatiebeloning die is ontvangen, het totale inkomen van de belastingplichtige voor het belastingjaar waarin de belastingplichtige controle en zeggenschap over de validatiebeloning verkrijgt.’ De analyse stelt dat de waarde moet worden berekend vanaf het moment dat de Amerikaanse belastingplichtige controle krijgt over de token.</p>
<p>De Internal Revenue Service wees in de gids op dat als “belastingbetalers extra eenheden van cryptocurrency ontvangen als prikkels voor verificatie,” deze regel ook van toepassing is op investeerders die tokens inzetten via de cryptocurrency-uitwisseling.</p>
<h2 id="h2-Belangrijkste20Token20Trends20van20vandaag259833"><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-BTC88485"><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/1690954650BTC.png" alt=""><br>De trend van Bitcoin heeft het verwachte patroon gevolgd van een initiële daling gevolgd door een consolidatiefase, waarbij de sleutelhalslijnondersteuning op $28,5K USD werd bevestigd, zoals eerder vermeld. Vanochtend heeft de prijs van Bitcoin met succes de pullback voltooid door het cruciale ondersteuningsniveau op $30K USD te heroveren. Als de korte termijn stabiliteit behoudt boven $29,5K USD, is er nog steeds potentieel voor een doelprijs van $36K USD, met de mogelijkheid van een eindejaarsopwaartse trend.</p>
<h3 id="h3-ETH435979"><a name="ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ETH</h3><p><img src="https://gimg2.gateimg.com/image/article/1690954672ETH.png" alt=""><br>Terwijl de algehele markt tekenen vertoont van het doorbreken van ondersteuning, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Het korte termijn volume blijft relatief zwak en is nog niet boven de significante opwaartse trendlijn hersteld. Voor agressieve korte termijn handelaren wordt geadviseerd om te observeren of <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> stabiliteit kan herwinnen in de opwaartse trend, en zo ja, dit beschouwen als een signaal om long posities in te nemen. Een conservatieve korte termijn strategie suggereert te wachten op een doorbraak boven $2,037 USD om duurzaam te mikken op de topweerstand op $2,358 USD. Het is belangrijk op te merken dat het korte termijn perspectief nog steeds een bearish voorkeur heeft.</p>
<h3 id="h3-CRV577382"><a name="CRV" class="reference-link"></a><span class="header-link octicon octicon-link"></span>CRV</h3><p><img src="https://gimg2.gateimg.com/image/article/1690954691CRV.png" alt=""><br>Curve’s oprichter, Michael Egorov, heeft off-exchange transacties uitgevoerd ter waarde van ongeveer $12 miljoen USD in CRV, met een gemiddelde OTC-prijs van ongeveer $0.4 USD, waarbij hij vervolgens verschillende hoeveelheden USDT heeft ontvangen voor het oplossen van de liquidatiecrisis. Voor korte termijn CRV-handelaren wordt een mogelijke voortdurende terugval naar $0.558 USD verwacht. Voor degenen die optimistisch zijn over CRV, wordt het sequentiële opbouwen van posities voorgesteld op de volgende gele ordonnantieniveaus: $0.541 USD, $0.527 USD en $0.517 USD.</p>
<h2 id="h2-Macro20JOLTs20aangekondigd20gisteren20de20economische20vooruitzichten20verbeteren20en20de20verwachting20van20renteverlagingen20kan20een20bullmarkt20in20de20cryptoruimte20inluiden257307"><a name="Macro: JOLTs aangekondigd gisteren, de economische vooruitzichten verbeteren, en de verwachting van renteverlagingen kan een bullmarkt in de cryptoruimte inluiden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: JOLTs aangekondigd gisteren, de economische vooruitzichten verbeteren, en de verwachting van renteverlagingen kan een bullmarkt in de cryptoruimte inluiden</h2><p>Austan Goolsbee, de ‘grote duif’ van de Federal Reserve, weerlegt het idee van renteverlagingen en stelt dat het stopzetten van renteverhogingen meer bewijs van inflatieverlichting vereist, en eventuele renteverlagingen zullen in de verre toekomst plaatsvinden.</p>
<p>Raphael Bostic gelooft ook dat de actie in september afhankelijk is van gegevens, en er is aanzienlijke vooruitgang geboekt op het gebied van inflatie. Er bestaat een risico op overmatige verstrakking, maar de rente zal pas in de tweede helft van volgend jaar worden verlaagd.</p>
<p>Gisteravond bedroeg het aantal vacatures voor JOLTs in de Verenigde Staten in juni 9,582 miljoen, lager dan de verwachte 9,61 miljoen en 9,824 miljoen, een nieuw dieptepunt sinds april 2021.</p>
<p>De markt heeft altijd verwacht dat de renteverlaging volgend jaar zou beginnen, aangezien de renteverhoging zijn einde nadert en de ultrahoge rentevoering van de economie onvermijdelijk tot een economische recessie zal leiden. Daarom moet de Federal Reserve de rente verlagen.</p>
<p>Hoewel functionarissen van de Federal Reserve onlangs vertrouwen hebben uitgesproken in de vooruitzichten van een zachte landing, hebben hun voorspellingen hun ongerustheid blootgelegd.</p>
<p>Federal Reserve-voorzitter Jerome Powell erkende ook tijdens een recente persconferentie dat de Amerikaanse arbeidsmarkt mogelijk meer zwakte nodig heeft om de inflatie terug te brengen naar 2%. De mediane voorspelling van FOMC-leden die beleid formuleren vanaf juni is dat de werkloosheid volgend jaar zal stijgen tot 4,5%, bijna een procentpunt hoger dan nu.</p>
<p>Als er niet veel bewijs is dat suggereert dat de economie kan functioneren bij een werkloosheidspercentage lager dan 4% en consistentie kan handhaven met 2% inflatie, verwacht hij dat de kans op een harde landing hetzelfde blijft.</p>
<p>Het huidige probleem is de periode voor renteverlagingen. Zodra de renteverlagingen beginnen, zal de economie weer actief worden, en het ontbreken van renteverlagingen heeft gefaald om de optimistische ontwikkelingstrend van de Amerikaanse economie te beteugelen.</p>
<p>Dus, als de rentetarieven volgend jaar worden verlaagd, zal er opnieuw een nieuwe golf van groei moeten beginnen, en de omvang van de cryptomarkt wordt naar verwachting verder vergroot. We zullen afwachten.</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 beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>