RGFnZWxpamtzIG5pZXV3cyB8IENyeXB0by1tYXJrdCBoZXJzdGVsZCwgYWx0Y29pbnMgc3RlZ2VuIG92ZXIgaGV0IGFsZ2VtZWVuOyBCbGFzdCBBaXJkcm9wIHphbCB3b3JkZW4gZ2VsYW5jZWVyZDsgQ29sb3NzZXVtIFJhaXNlZCAkNjBNIG9tIHRlIGludmVzdGVyZW4gaW4gdnJvZWdlIHByb2plY3Rlbg==

2024-06-26, 03:28

<p><img src="https://gimg2.gateimg.com/image/article/17193724221_19.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20De20cryptomarkt20veerde20op20terwijl20Altcoins20over20het20algemeen20stegen20De20Blast20airdrop20wordt20gelanceerd20Colosseum20haalde206020miljoen20op20om20te20investeren20in20vroege20projecten20Paradigm20leidde20de203720miljoen20financiering20van20Conduit278992"><a name="Crypto Daily Digest: De cryptomarkt veerde op, terwijl Altcoins over het algemeen stegen; De Blast airdrop wordt gelanceerd; Colosseum haalde $60 miljoen op om te investeren in vroege projecten; Paradigm leidde de $37 miljoen financiering van Conduit" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: De cryptomarkt veerde op, terwijl Altcoins over het algemeen stegen; De Blast airdrop wordt gelanceerd; Colosseum haalde $60 miljoen op om te investeren in vroege projecten; Paradigm leidde de $37 miljoen financiering van Conduit</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 ondervonden Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s (GBTC) op 25 juni een uitstroom van $30,3 miljoen aan fondsen. Ondertussen had Fidelity Bitcoin spot ETF (FBTC) een instroom van $48,8 miljoen, Bitwise Bitcoin spot ETF (BITB) had een instroom van $15,2 miljoen, en ARK 21Shares Bitcoin spot ETF (ARKB) ondervond een uitstroom van $6,2 miljoen. Na een week van netto uitstroom, de <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stromen</a> Het handelen in Bitcoin ETF-fondsen is eindelijk weer positief geworden.</p>
<p><strong>De Blast airdrop wordt gelanceerd, waarbij 17% van de tokenvoorraad wordt verdeeld onder vroege gebruikers</strong><br>Layer 2 Network Blast heeft de details aangekondigd van zijn aankomende airdrop. De oprichter van Blast is ook de oprichter van Blur op de NFT-markt, dat zich toelegt op het creëren van inheemse inkomstenmodellen voor <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> en stablecoins. Het mainnet werd eerder gelanceerd op 29 februari.</p>
<p>Volgens sociale media-aankondigingen zal de Blast Foundation, de bestuursorganisatie van Blast, de eerste fase van 17 miljard BLAST-tokens uitdelen om 10.00 uur Eastern Time op 26 juni, 22.00 uur Hong Kong Time en 16.00 uur Central European Time.</p>
<p>Van deze 17 miljard tokens zal 7% worden toegewezen aan gebruikers die helpen bij het initiëren van protocol liquiditeit door ETH of Blast’s stablecoin USDB te overbruggen. Volgens het token economie rapport van Blast zullen gebruikers die Blast Gold verdienen door deel te nemen aan gedecentraliseerde applicaties een extra 7% van de initiële airdrop ontvangen, en de overige 3% zal worden toegewezen aan de Blur Foundation voor retrospectieve en toekomstige airdrops.</p>
<p>Blast onthulde ook meer details over de token-economie: de overeenkomst verdeelt 50% van de totale voorraad van 100 miljard tokens onder gemeenschappen en plant extra community airdrops in de komende drie jaar. Het rapport over de token-economie wijst er verder op dat kernbijdragers 25,5% van de tokenvoorraad zullen ontvangen, terwijl investeerders en de Blast Foundation respectievelijk 16,5% en 8% zullen ontvangen.</p>
<p><strong>Colosseum, een startupversneller gericht op <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, raised $60 miljoen om te investeren in vroege projecten</strong><br>Colosseum is een startup-accelerator gericht op het Solana-ecosysteem en organiseert specifiek hackathons om innovatie te stimuleren. Het bedrijf heeft $60 miljoen aan fondsen opgehaald voor zijn vroege investeringsprojecten en heeft plannen om vooraf te investeren in het winnende team van <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> Hackathons.</p>
<p>Clay Robbins, medeoprichter van Colosseum, zei: ‘De markt heeft duidelijk vraag naar innovatieve en professionele ondernemersproducten in het cryptoveld. We zijn verheugd om samen te werken met een diverse groep investeerders om onze visie voor Colosseum te realiseren, waaronder ecosysteemoprichters en alumni van de Black Marathon.’</p>
<p>Eerder dit jaar organiseerde Colosseum zijn eerste Solana hackathon, waarbij meer dan 8.000 deelnemers werden aangetrokken. Matty Taylor, medeoprichter van Colosseum en voormalig hoofd ontwikkeling bij de Solana Foundation, legde uit: ‘Onze hackathon heeft als doel een eerlijke competitieve omgeving te bieden voor wereldwijde ontwikkelaars om crypto-productontwikkeling te proberen en on-chain start-ups te lanceren.’ Robbins voegde eraan toe dat Colosseum tot nu toe $2,75 miljoen aan financiering heeft verstrekt aan 11 bedrijven.</p>
<p>Als het Bonk DAO van het Solana Committee, dat $124 miljoen aan BONK-tokens beheert en bestaat uit 12 belangrijke personen, is hij van plan $500.000 te investeren in het fonds.</p>
<p><strong>Paradigm en Haun Ventures hebben gezamenlijk de financiering van $37 miljoen geleid voor Conduit.</strong><br>Conduit, een crypto-infrastructuurbedrijf, heeft $37 miljoen opgehaald in zijn meest recente financieringsronde om de ontwikkeling van nieuwe op blockchain gebaseerde producten en diensten te ondersteunen. Haun Ventures en Paradigm leidden gezamenlijk de financieringsronde van serie A, waarbij ook Robot Ventures, Credible Neutral, Coinbase Ventures en Bankless Ventures deelnamen. Verschillende angel investors hebben ook financiering verstrekt voor deze financiering.</p>
<p>Conduit heeft verklaard dat met de verbetering van de transactiesnelheid de mogelijkheid om beschikbare on-chain producten en diensten te creëren voor een breed scala aan gebruikers is toegenomen, waardoor veel potentiële zakelijke kansen voor blockchain-ontwikkelaars zijn ontstaan.</p>
<p>Conduit is van plan om de nieuw opgehaalde fondsen te gebruiken om producten te lanceren die ontwikkelaars helpen bij het bouwen van ‘aanpasbare en betrouwbare’ rollups, die of Layer 2 schaalbaarheidsoplossingen transacties wegleiden van het onderliggende netwerk, waardoor netwerkcongestie op hun blockchain wordt verminderd. Zodra deze transactieachterstanden zijn weggewerkt, kunnen on-chain transacties (zoals cryptobetalingen) sneller worden verwerkt.</p>
<p>Deze maatregelen kunnen de basis leggen voor het ontwikkelen van nieuwe toepassingen voor gedistribueerde grootboektechnologie. Conduit verklaarde in een blogpost: ‘Door on-chain computing rijk en betaalbaar te maken, maken deze nieuwe uitbreidingsoplossingen ongekende bedrijfsmodellen mogelijk.’</p>
<h2 id="h2-Markttrends20Altcoins20stegen20over20het20algemeen20terwijl20Mememunten20zoals20MAGA20de20hele20markt20leidden965320"><a name="Markttrends: Altcoins stegen over het algemeen, terwijl Meme-munten zoals MAGA de hele markt leidden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: Altcoins stegen over het algemeen, terwijl Meme-munten zoals MAGA de hele markt leidden</h2><p>BTC is hersteld van oververkocht en consolideert momenteel rond $62.000. Bitcoin spot ETF’s hebben 7 opeenvolgende dagen uitstromen gehad.</p>
<p>ETH presteerde beter dan BTC, brak vanochtend door de $3.400. Het volgende doelwit kan $3.600 zijn.</p>
<p>Tijdens de daling van BTC en ETH vertoonden Altcoins een relatief sterke prestatie en herstelden ze als eerste. Altcoins stegen over het algemeen, terwijl Meme coins aanzienlijk beter presteerden dan andere sectoren.</p>
<h3 id="h3-Macroeconomie129035"><a name="Macroeconomie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie</h3><p>Ondanks de havikachtige opmerkingen van de Federal Reserve bleven de Amerikaanse aandelen stijgen na een korte aanpassing.</p>
<h3 id="h3-Markt20Hotspots439305"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>Meme sectoren zoals PEPE, BRETT, MAGA, WIF, POPCAT, enz. leidden de winsten. MAGA is een concepttoken voor de Amerikaanse verkiezingen, afgekort als Trump’s campagneslogan Make American Great Again. MAGA is de afgelopen twee dagen met meer dan 60% gestegen. Op de 27e zullen er presidentsdebatten zijn tussen Trump en Biden, en beide presidentskandidaten hebben hun steun uitgesproken voor de crypto-industrie. Dus dit debat zal een beleidsdebat zijn en een gouden slagveld op sociale media, waar beide kandidaten zullen proberen een schitterend moment te creëren dat breed kan worden verspreid in de crypto-gemeenschap.</p>
<p>Public Chain SOL: SOL is hersteld na een daling tot $120 eergisteren en consolideert momenteel rond $140. Solana heeft de Blinks module gelanceerd, waarmee gebruikers direct sociale media platforms zoals X en Tiktok kunnen gebruiken voor functies zoals handelen, stemmen en betalingen. De nieuwe module die door Solana is gelanceerd, zal een diepgaande impact hebben op de promotie van cryptocurrencies.</p>
<p>Layer2 Project Blast: BLAST zal vanavond token airdrops uitvoeren, met in totaal 100 miljard tokens en een huidige off exchange waardering van $3 miljard. Na de over het algemeen slechte prestaties van Layer2 tokens op de markt, is het de moeite waard om uit te kijken naar welke markt BLAST zal ontstaan.</p>
<p>De huidige cryptomarkt is actief, met verschillende activa die verschillende investeringsmogelijkheden bieden. De trend van Bitcoin en <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> is relatief stabiel, terwijl Memecoin en SOL openbare ketenprojecten hoge risico en hoog rendement bieden, geschikt voor investeerders met een hogere risicotolerantie om deel te nemen. De stabiliteit van de macro-economische omgeving biedt ook goede externe ondersteuning voor de cryptomarkt. Over het algemeen neemt de huidige term actief deel aan kwalitatief hoogstaande handelstijd.</p>
<h2 id="h2-Macro20De20NASDAQindex20sloot20hoger20als20gevolg20van20de20versterking20van20technologische20aandelen20de20Dow20Jonesindex20daalde20en20de20Aziatische20markt20was20volatiel498337"><a name="Macro: De NASDAQ-index sloot hoger als gevolg van de versterking van technologische aandelen, de Dow Jones-index daalde en de Aziatische markt was volatiel" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De NASDAQ-index sloot hoger als gevolg van de versterking van technologische aandelen, de Dow Jones-index daalde en de Aziatische markt was volatiel</h2><p>Op 25 juni steeg de Nasdaq-index met 1,3% op dinsdag, gedreven door sterke winsten in Nvidia en stijgende aandelenkoersen van andere techreuzen, terwijl de Dow Jones-index daalde als gevolg van druk op de detailhandelsaandelen en investeerders die wachten op de publicatie van belangrijke inflatiegegevens deze week.</p>
<p>Specifieke gegevens: de Dow Jones daalde met 0,76%, de S&amp;P steeg met 0,39% en de Nasdaq steeg met 1,26%.</p>
<p>Het aandeel van Nvidia, het bedrijf voor kunstmatige intelligentie chips, steeg met 6,8%, na drie opeenvolgende handelsdagen van daling. De algehele chipssector presteerde goed, met de Philadelphia-index <a href="/how-to-buy/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">koop doge</a> De Docentenindex stijgt met 1,8%. Chips zijn een van de belangrijkste drijvende krachten achter de technologie-index van de S&amp;P 500. Alphabet steeg met 2,7%, Meta Platforms steeg met 2,3%, waardoor de sectorindex van Communicatiediensten steeg.</p>
<p>Vanwege zorgen over het economische vooruitzicht is het consumentenvertrouwen in de Verenigde Staten in juni afgenomen, maar huishoudens blijven optimistisch over de arbeidsmarkt en verwachten dat de inflatie in het komende jaar zal afnemen. In juni daalde de consumentenvertrouwensindex naar 100.4 en de kloof op de arbeidsmarkt werd groter van 22.7 naar 24.</p>
<p><strong>Beleggers blijven voorzichtig over Amerikaanse inflatiedata en Aziatische aandelenmarkten zijn in beroering</strong><br>Op woensdagochtend hebben Aziatische aandelenmarkten aanzienlijke volatiliteit ervaren terwijl de markt zich voorbereidde op belangrijke Amerikaanse inflatiedata, terwijl de yen/dollar wisselkoers rond de 160 schommelde. Handelaren waren bezorgd dat de Japanse autoriteiten mogelijk nieuwe interventiemaatregelen zouden nemen.</p>
<p>De harde opmerkingen van functionarissen van de Federal Reserve hebben de verwachtingen van recente renteverlagingen onderdrukt, waardoor de Amerikaanse dollar is gestegen en het risicosentiment is beperkt.</p>
<p>De MSCI Asia Pacific aandelenindex, exclusief Japan, bleef vrijwel onveranderd in volatiele handel op 566,55, iets lager dan het tweejarig hoogtepunt van 573,38 dat vorige week werd bereikt. De index steeg in juni met 3,5% en wordt verwacht voor de vijfde opeenvolgende maand te stijgen. De Nikkei-index van Japan steeg met 1,41%, terwijl Taiwanse aandelen met 0,69% stegen, beide geleid door Nvidia en in lijn met de trend van techreuzen.</p>
<p>De Chinese aandelenmarkt is licht gedaald, met blue-chip aandelen en de Shanghai Composite Index die met 0,2% zijn gedaald en naar verwachting deze maand met 4% zal dalen. De Hang Seng-index in Hong Kong daalde ook met 0,16%.</p>
<p>Fed-directeur Michelle Bauman herhaalde haar overtuiging dat het handhaven van de stabiliteit van de beleidsrente gedurende een bepaalde periode voldoende kan zijn om de inflatie onder controle te houden. Deze opmerkingen, samen met gegevens die stabiliteit op de vastgoedmarkt aantonen, hebben de marktverwachtingen onderdrukt voor wanneer en hoeveel de Federal Reserve de rentetarieven zal verlagen. De FedWatch-tool van de Chicago Mercantile Exchange laat zien dat de markt verwacht dat de Federal Reserve dit jaar de rente met 47 basispunten zal verlagen, met een kans van 66% op een renteverlaging in september.</p>
<p>Wat betreft de valutamarkt bleef de Amerikaanse dollarindex, die de Amerikaanse dollar tegen zes valuta meet, stabiel op 105,64, terwijl de wisselkoers van de euro ten opzichte van de Amerikaanse dollar op 1,0715 stond. Uit de gegevens blijkt dat de consumentenprijsindex in mei versnelde tot het hoogste niveau in zes maanden, wat de mogelijkheid van een nieuwe renteverhoging al in augustus verkleint en leidt tot een stijging van de Australische dollar. De Australische dollar steeg met 0,39% ten opzichte van de Amerikaanse dollar naar $0,6674.</p>
<p>De huidige wisselkoers van de Japanse yen tegen de Amerikaanse dollar is 159,79 en handelt binnen een smal bereik, waarbij het kritieke niveau van 160 nadert. Sommige handelaren hebben aangegeven dat dit niveau mogelijk een nieuwe ronde van interventie kan veroorzaken.</p>
<p>Met betrekking tot grondstoffen bleven de olieprijzen bijna onveranderd tijdens de Aziatische handelsuren, waarbij Brent ruwe olie-futures onveranderd bleven op $85.02 per vat en West Texas Intermediate ruwe olie-futures in de Verenigde Staten op $80.9 per vat.</p>
<p>De goudprijs is gedaald naar $2.318 per ounce, maar is dit jaar nog steeds met 12% gestegen.</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 opvattingen 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 zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>