RGFnZWxpamtzIG5pZXV3cyB8IE1hc3NhdmVya29vcCB2YW4gTXQuR294IHpvcmd0IGVydm9vciBkYXQgQlRDIGRhYWx0IG5hYXIgJDU1SzsgU29sYW5hIGxhbmNlZXJ0IEZpcmVkYW5jZXIgVnVsbmVyYWJpbGl0eSBCb3VudHkgUHJvZ3JhbTsgVW5pU2F0IGtvbmRpZ3Qgc2lnbmlmaWNhbnRlIG9udHdpa2tlbGluZ3N2b29ydGdhbmcgYWF

2024-07-08, 03:40

<p><img src="https://gimg2.gateimg.com/image/article/17204098961_6-06.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20MtGoxs20Bitcoin20is20zwaar20verkocht20met20prijzen20die20zijn20gedaald20naar205500020Solana20lanceerde20het20Firedancer20kwetsbaarheidsbeloningsprogramma20UniSat20kondigde20significante20ontwikkelingsvoortgang20aan20in20Fractal20Swap52722"><a name="Crypto Dagelijkse Samenvatting: Mt.Gox’s Bitcoin is zwaar verkocht, met prijzen die zijn gedaald naar $55.000; Solana lanceerde het Firedancer kwetsbaarheidsbeloningsprogramma; UniSat kondigde significante ontwikkelingsvoortgang aan in Fractal Swap" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Mt.Gox’s <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> is zwaar verkocht, met prijzen die zijn gedaald naar $55.000; <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> lanceerde het Firedancer kwetsbaarheidsbeloningsprogramma; UniSat kondigde significante ontwikkelingsvoortgang aan in Fractal Swap</h2><p>Laten we eerst de handelsactiviteiten van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens gegevens van Farside Investor had Grayscale Bitcoin spot ETF’s (GBTC) op 6 juli een uitstroom van $28,6 miljoen. Ondertussen had Fidelity Bitcoin spot ETF (FBTC) een instroom van $117,4 miljoen, Bitwise Bitcoin spot ETF (BITB) een instroom van $30,2 miljoen, en ARK 21Shares Bitcoin spot ETF (ARKB) een instroom van $11,3 miljoen.</p>
<p><strong><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> heeft het Firedancer kwetsbaarheidsbountyprogramma gelanceerd, met een prijs van $1 miljoen</strong></p>
<p>De zeer verwachte Solana onafhankelijke validatieclient ‘Firedancer’ zal zijn eerste kwetsbaarheidsbeloningsprogramma lanceren. Jump Crypto heeft deze client ontwikkeld om de veerkracht van Solana te verbeteren en high-frequency trading te optimaliseren.</p>
<p>Ontwikkelaar Cantelope Peel heeft aangekondigd dat het bounty-programma op 10 juli van start gaat en zes weken zal duren. Het bounty-programma, ondersteund door Immunefi, biedt tot $1 miljoen aan beloningen aan ontwikkelaars die significante fouten ontdekken in Firedancer v0.1 (bijgenaamd ‘Frankendacer’). Cantelope Peel verklaarde op het X-platform dat er ‘miljoenen uitvoeringsslots zijn getest en gematcht met het Solana-protocol’, wat aangeeft dat de ontwikkeling van Firedancer soepel verloopt.</p>
<p><strong>De Bitcoin van Mt.Gox werd zwaar verkocht, wat leidde tot een daling van de prijs tot $55.000</strong></p>
<p>Als gevolg van de massale verkoop van Bitcoin door de Japanse Cryptocurrency Exchange Mt.Gox, daalden de Bitcoin-prijzen op een gegeven moment naar $55.200. Sinds mei heeft Mt.Gox voor het eerst 47.229 bitcoins overgebracht naar een nieuw portefeuilleadres. Volgens gegevens van Arkham Intelligence, een blockchain-analyseplatform, heeft de beurs Bitcoin overgebracht van de ‘koude kluis’ om 12:30 uur UTC op 5 juli.</p>
<p>Deze overdracht valt samen met het begin van het plan van Mt.Gox om schuldeisers terug te betalen; in totaal zal voor $8,5 miljard aan Bitcoin worden gebruikt voor de terugbetaling. De markt maakt zich zorgen dat er een grote hoeveelheid Bitcoin op de markt kan komen, hoewel sommige analisten hebben aangegeven dat de totale waarde van de deze keer verkochte Bitcoin mogelijk dicht bij $4,5 miljard ligt.</p>
<p><strong>UniSat kondigde significante ontwikkelingsvoortgang aan in Fractal Swap</strong></p>
<p>UniSat heeft de nieuwste ontwikkelingen aangekondigd in zijn Swap product. Het team heeft de afgelopen zes maanden samengewerkt met L1F om de standaardisatie van de L1 (Bitcoin Mainnet) brc20 swap te bevorderen, die deel zal uitmaken van de brc-20 standaard upgrade. Hoewel het coördineren van meerdere teams resulteerde in langzamere vooruitgang dan verwacht, heeft het team geverifieerd dat het product kan werken op het Bitcoin mainnet.</p>
<p>Het grootste deel van het technische werk voor de Swap module is afgerond en de resterende taken omvatten:</p>
<p>Assisteer indexen anders dan de UniSat Indexer om effectief inschrijvingen gerelateerd aan het swap module te identificeren en te berekenen;</p>
<p>Zorg ervoor dat de berekeningen die door UniSat zijn ingediend overeenkomen met die van andere teams door middel van hash-verificatie om boekhoudkundige verschillen te voorkomen.</p>
<p>Naast het bevorderen van de standaardisatie van swaps, heeft het team ook aangekondigd dat ze voortgang hebben geboekt bij het uitbreiden van het Bitcoin-netwerk door middel van een methode genaamd Fractal Bitcoin, en het team verwacht Fractal Bitcoin in september te leveren. Fractal Bitcoin zal een swap-product bieden met dezelfde functionaliteit als de mainnet swap-module - Fractal Swap, waardoor er vanaf het begin van het project goede liquiditeit is. Fractal Swap zal ook een concurrerend roll-up mechanisme implementeren waarmee gebruikers hun roll-up resultaten in een sorter kunnen verpakken en transactiekosten verdienen voor alle transacties.</p>
<p><strong>Marktoverzicht</strong></p>
<p>Firedancer kwetsbaarheidsbeloningsprogramma: De Solana Independent Verifier-client zal op 10 juli beginnen met het kwetsbaarheidsbeloningsprogramma, dat 6 weken zal duren, met beloningen tot $1 miljoen.</p>
<p>Mt.Gox Bitcoin Verkoop: Als gevolg van de verkoop van Bitcoin door Mt.Gox daalde de prijs van Bitcoin op een gegeven moment naar $55.200. De markt maakt zich zorgen over de mogelijke impact van een grote instroom van Bitcoin.</p>
<p>UniSat Fractal Swap: De ontwikkeling van UniSat’s Swap-product verloopt soepel. Verwacht wordt dat Fractal Bitcoin in september wordt gelanceerd en dezelfde swap-functie biedt als het hoofdnetwerk.</p>
<h2 id="h2-Markttrends20Cryptocurrency20maakte20kortstondig20een20opleving20door20in20het20weekend20en20keerde20terug20naar20een20neerwaartse20trend661223"><a name="Markttrends: Cryptocurrency maakte kortstondig een opleving door in het weekend en keerde terug naar een neerwaartse trend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: Cryptocurrency maakte kortstondig een opleving door in het weekend en keerde terug naar een neerwaartse trend</h2><p>BTC is dit weekend hersteld boven $58.000 en is gedaald tot onder $54.500.</p>
<p>ETH herstelde boven de $3.000 en viel ook scherp, op dit moment daalt het naar ongeveer $2.830.</p>
<p>Altcoins vielen over het algemeen scherp terug na een opleving in het weekend, en de markt keerde terug naar een neerwaartse trend.</p>
<p>Indicator analyse:<br>De AHR99-index: Vandaag staat deze op 0.66, geschikt voor reguliere investeringen.</p>
<p>Angst en hebzucht index: Vandaag staat deze op 28, wat aangeeft dat investeerders zich zorgen maken over de toekomstige marktsituatie.</p>
<h3 id="h3-Macroeconomie289903"><a name="Macroeconomie:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie:</h3><p>Afgelopen vrijdag sloten de drie belangrijkste Amerikaanse aandelenindexen gezamenlijk hoger, wat wijst op een positieve markt <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> over de toekomstige economie.</p>
<p>Het rendement van Amerikaanse schatkistobligaties blijft stijgen en het rendement op 10-jarige schatkistobligaties bereikt een nieuw hoogtepunt van de maand. De stijging van de rendementen op schatkistobligaties kan enige druk uitoefenen op risicovolle activa (zoals cryptocurrency).</p>
<h3 id="h3-Markt20Hotspots813192"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>Inie gedeelte: SATS oververkocht en hersteld. De Inion Wallet Unisat kondigde aan SATS te gebruiken als de Gas token voor Swap en heeft vorig jaar zijn belofte aan de gemeenschap waargemaakt. Ondanks positief nieuws betaalt de markt niet voor het algehele verhaal van BTC Layer2 wordt niet betaald door de markt, en het inies en runen gedeelte staat voor een neergang.</p>
<p>Meme sector: Ton ecosysteemleider Meme-token NOT is in het weekend met 60% gestegen, maar de Trump-concepttoken MAGA is meer dan 50% gestegen, maar nu is alles teruggelopen. Populaire Meme-tokens hebben in de reboundmarkt een sterkere veerkracht getoond en investeerders moeten letten op hun hoge volatiliteit.</p>
<h3 id="h3-Om20samen20te20vatten737927"><a name="Om samen te vatten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Om samen te vatten</h3><p>De huidige markt ondergaat een algemene correctie, waarbij BTC en ETH significante dalingen ervaren na een korte opleving. Ook de Altcoin-markt presteerde slecht, met een algemene dalende trend. Hoewel sommige sectoren in de Web3-markt, zoals Meme-tokens, veerkracht hebben getoond, neigt het algemene marktsentiment voorzichtig te zijn. Op macro-economisch gebied presteerden Amerikaanse aandelen sterk, maar de stijging van de rendementen op schatkistobligaties kan druk uitoefenen op de cryptomarkt. Investeerders moeten waakzaam blijven in de huidige marktomgeving, activa redelijk toewijzen en tijdig investeren om om te gaan met marktschommelingen.</p>
<h2 id="h2-Macro20Nasdaq20en20SampP2050020Index20bereiken20historische20hoogtepunten20met20hoop20op20renteverlagingen20als20gevolg20van20werkgelegenheidsgegevens179309"><a name="Macro: Nasdaq en S&amp;P 500 Index bereiken historische hoogtepunten, met hoop op renteverlagingen als gevolg van werkgelegenheidsgegevens" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Nasdaq en S&amp;P 500 Index bereiken historische hoogtepunten, met hoop op renteverlagingen als gevolg van werkgelegenheidsgegevens</h2><p>Op vrijdag 5 juli sloot de Wall Street aandelenmarktindex hoger, waarbij de door technologie gedomineerde Nasdaq-index en de benchmark S&amp;P 500-index historische hoogtepunten bereikten. Nieuwe gegevens tonen aan dat de Amerikaanse arbeidsmarkt zwak is, wat de marktverwachtingen voor een renteverlaging in september vergroot.</p>
<p>Grote aandelen zoals Microsoft hebben de aandelenmarkt omhoog gestuwd, waarbij Microsoft bijna 1,5% steeg en sloot op een historisch hoogtepunt. Meta Platforms bereikte ook een historisch sluitingshoogtepunt, met een stijging van ongeveer 5,9%, waardoor de informatietechnologiesector naar een nieuw hoogtepunt werd gedreven.</p>
<p>Specifieke indexprestaties: de Dow Jones-index steeg met 0,17%, de Standard &amp; Poor’s-index steeg met 0,54% en de Nasdaq-index steeg met 0,9%.</p>
<p>Volgens gegevens van het Ministerie van Arbeid is de werkgelegenheidsgroei in de Verenigde Staten in juni licht vertraagd, waarbij de werkloosheidscijfer zijn hoogste niveau in twee en een half jaar heeft bereikt, en ook de loongroei afneemt. In april en mei is het aantal banen in de VS met 111.000 gestegen, een daling van 111.000 ten opzichte van eerdere schattingen, wat aangeeft dat de trend van de werkgelegenheidsgroei afneemt. Ondanks een gestage toename van de werkgelegenheid in juni, waren de werving in de overheid en de gezondheidszorg goed voor ongeveer driekwart van de nieuwe banen, en het werkloosheidscijfer bereikte een twee-en-een-halfjaar hoogtepunt van 4,1%, wat wijst op een zwakke arbeidsmarkt.</p>
<p>Beleggers verwachten dat deze gegevens een intensievere discussie zullen uitlokken over renteverlagingen wanneer de Federal Reserve later deze maand bijeenkomt. De FedWatch-tool van de Chicago Mercantile Exchange toont aan dat de kans op renteverlaging door de Federal Reserve in september is gestegen van 66% vóór de gegevenspublicatie naar 79%.</p>
<p>Op 8 juli stegen Aziatische aandelenmarkten iets op maandag, omdat het vertrouwen van beleggers in de Amerikaanse renteverlaging in september toenam, terwijl de Franse verkiezingsresultaten wezen op een zwevend parlement en de euro geconfronteerd werd met politieke onzekerheid.</p>
<p>In Frankrijk versloeg de linkse coalitie onverwacht de uiterst rechtse en behaalde de eerste plaats. Deze grote verrassing zou voorkomen dat de Nationale Liga van Marina Le Pen (RN) de regering overneemt. Beleggers maken zich ook zorgen dat linkse plannen veel van de pro-markthervormingen van president Emmanuel Macron kunnen ondermijnen.</p>
<p>Investeerders hebben hun hoop vergroot op het versoepelen van het Amerikaanse beleid en het ondersteunen van de aandelenmarkt. De MSCI Asia Pacific aandelenindex steeg met 0,1%, en bereikte vorige week een tweejarig hoogtepunt. De Nikkei-index in Japan steeg met 0,2% en nadert een historisch hoogtepunt. Chinese blue-chip aandelen daalden met 0,4%, terwijl de obligatierendementen stegen doordat de centrale bank nieuwe geldmarktoperaties lanceerde.</p>
<p>Later deze week zullen Citigroup, JPMorgan Chase en Wells Fargo Bank hun financiële rapporten op de economische kalender vrijgeven. Voorzitter van de Federal Reserve Jerome Powell zal zijn standpunten presenteren in het Congres op dinsdag en woensdag. Het Amerikaanse consumentenprijsrapport van donderdag wordt verwacht te worden vrijgegeven, waarbij de algehele inflatie naar verwachting zal afnemen van 3,3% naar 3,1% en de kerninflatie stabiel blijft op 3,4%. De inflatiegegevens van Duitsland werden op dezelfde dag vrijgegeven, terwijl China deze week consumentenprijzen en handelsgegevens zal vrijgeven.</p>
<p>Wat betreft grondstoffen zijn de olieprijzen gedaald vanwege de markt die wacht op de impact van Hurricane Beryl op de toevoer van de Golf van Mexico. De prijs van Brent ruwe olie daalde met 14 cent tot $86,40 per vat, terwijl de prijs van Amerikaanse ruwe olie met 29 cent daalde tot $82,87 per vat.</p>
<p>De prijs van goud blijft op een bijna één maand hoogtepunt van $2.385 per ounce.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Sherry S. &amp; Icing</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 enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen met vermelding van Gate.io. In alle glen zal er juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>