RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBkYWFsZGUgb25kZXIgJDY0SywgbWV0IGVlbiBzdGlqZ2luZyBpbiBoZXQgdm9sdW1lIHZhbiBsaXF1aWRhdGllOyBQYXJ0aWNsZSBoYWFsZGUgJDE1TSBvcCBpbiB0b2tlbnJvbmRlLWZpbmFuY2llcmluZzsgUGFudGVyYSBDYXBpdGFsIGhhYWx0IGZvbmRzZW4gb3Agdm9vciBkZSAyZSBUT04taW5

2024-06-24, 04:05

<p><img src="https://gimg2.gateimg.com/image/article/17192018621_17.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Bitcoin20daalde20onder20de206400020met20een20stijging20in20het20opruimvolume20Modulaire20blockchain20Particle20haalde201520miljoen20op20in20een20financieringsronde20voor20tokens20Pantera20Capital20werft20fondsen20voor20de20tweede20TONtokeninvestering622521"><a name="Crypto Dagelijkse Samenvatting: Bitcoin daalde onder de $64.000, met een stijging in het opruimvolume; Modulaire blockchain Particle haalde $15 miljoen op in een financieringsronde voor tokens; Pantera Capital werft fondsen voor de tweede TON-tokeninvestering" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> daalde onder de $64.000, met een stijging in het opruimvolume; Modulaire blockchain Particle haalde $15 miljoen op in een financieringsronde voor tokens; Pantera Capital werft fondsen voor de tweede TON-tokeninvestering</h2><p>Laten we eerst de handelsactiviteiten van onderzoeken. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens gegevens van Farside Investor ondervonden de Grayscale Bitcoin spot ETF’s (GBTC) op 21 juni een uitstroom van $34,2 miljoen aan middelen. Ondertussen ondervond Fidelity Bitcoin spot ETF (FBTC) een uitstroom van $44,8 miljoen, Bitwise Bitcoin spot ETF (BITB) had een instroom van $29 miljoen, ARK 21Shares Bitcoin spot ETF (ARKB) ondervond een uitstroom van $28,8 miljoen, en WisdomTree Bitcoin spot ETF (BTCW) had een nettostroom van $6,6 miljoen.</p>
<p><strong><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> daalt onder de $64.000, met een stijging in de afwikkelingsvolume</strong><br>De prijs van Bitcoin heeft zich rond de $63,600 genesteld na aanpassing, en in de afgelopen dag is het bedrag aan long-liquidatie gestegen tot meer dan $27 miljoen.</p>
<p>Volgens Coinglass-gegevens is er in de afgelopen 24 uur meer dan $33,85 miljoen aan Bitcoin-posities geliquideerd, terwijl er meer dan $132 miljoen aan posities op de bredere cryptomarkt zijn geliquideerd. Van deze totale liquidatiebedragen is ongeveer $105 miljoen een longpositie.</p>
<p>Op het moment van schrijven van dit artikel is de handelsprijs van Bitcoin ongeveer $63,649, wat in de afgelopen 24 uur met meer dan 2.4% is gedaald. De prijs van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> daalde meer dan 2% gedurende dezelfde periode naar $3.434. Volgens de gegevens van Coingecko is de huidige wereldwijde marktwaarde van crypto $2,45 biljoen, een daling van 3,2% in de afgelopen 24 uur.</p>
<p><strong>Modulaire blockchain Particle haalde $15 miljoen op in tokenronde financiering</strong><br>Particle Network, een modulaire blockchain-ontwikkelaar die zich richt op ketenabstractietechnologie, heeft succesvol $15 miljoen opgehaald in serie-A-financiering.</p>
<p>Particle Network is een modulaire layer 1 blockchain die zich richt op keten abstractietechnologie, waardoor de ervaring voor ontwikkelaars en gebruikers wordt vereenvoudigd. Het belangrijkste product is een “universele rekening” waarmee gebruikers alle fondsen op de keten kunnen gebruiken om transacties uit te voeren in het gehele blockchain-ecosysteem. Universele rekeningen worden ondersteund door twee belangrijke functies, “Universele Liquiditeit” en “Universeel Gas,” waardoor gebruikers hun tokens op elke keten kunnen gebruiken en transactie- of gasvergoedingen kunnen betalen.</p>
<p>Article Network kondigde donderdag aan dat de financieringsronde gezamenlijk zal worden geleid door Spartan Group en Gumi Cryptos Capital, met bedrijven als SevenX Ventures, Morningstar Ventures, <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a> Handelaren en HashKey Capital nemen deel.</p>
<p>De oprichter en CEO van Article, Wang Pengyu, onthulde dat deze financieringsronde in maart is gestart en vorige maand is afgerond. Deze financiering maakt gebruik van de Future Token Simple Agreement (SAFT) structuur, hoewel Wang Pengyu geen commentaar heeft gegeven over de waardering. De A-ronde financiering heeft het totale financieringsbedrag van Article gebracht op $25 miljoen - daarvoor had het bedrijf al $10 miljoen opgehaald via drie rondes van financiering.</p>
<p>Het Particle Network bevindt zich momenteel in de eerste fase van het testen van het netwerk, met ongeveer 1,3 miljoen geregistreerde algemene accounts en het registreren van meer dan 114 miljoen transacties. Dit netwerk is gebouwd met behulp van de Cosmos SDK, compatibel met <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> virtuele machines en geïntegreerd met het BeaconKit-framework van Berachain. De belangrijkste concurrenten van Particle zijn NEAR (Chain Signature Technology) en <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a>‘s AggLayer (Chain Unification-technologie).</p>
<p><strong>Pantera Capital werft geld in voor de tweede TON-tokeninvestering</strong><br>TON blockchain, voorheen bekend als Telegram Open Network, werd oorspronkelijk gelanceerd door Telegram. Echter, als gevolg van beschuldigingen door de Amerikaanse Securities and Exchange Commission in 2019 dat Telegram tokens genaamd “Grams” verkocht in strijd met federale effectenwetten, trok Telegram zich terug uit het project. In 2020 stemden Telegram en haar dochteronderneming TON Issuer Inc. ermee in om meer dan $1,2 miljard terug te geven aan investeerders en een civiele boete van $18,5 miljoen te betalen.</p>
<p>Het aantal gebruikers en transacties op de TON blockchain is de laatste tijd snel gegroeid. <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> De USDT stablecoin van Gate.io werd ook gelanceerd op het TON-netwerk in april. Pantera verklaarde in een e-mail dat de adoptiesnelheid van USDT op het TON-netwerk alle voorgaande blockchains overtrof en in minder dan twee maanden de omloop van 400 miljoen USDT overschreed.</p>
<p>Als reactie daarop is crypto-venturekapitaalfirma Pantera bezig met het werven van fondsen om een nieuwe beleggingsfonds op te richten dat specifiek gericht is op investeringen in open netwerken. <a href="/price/toncoin-ton" rel="nofollow noopener noreferrer" target="_blank">Toncoin</a>, verdubbelde zijn investering in de token. Kort voor de oprichting van het nieuwe TON-fonds van Pantera deed het bedrijf zijn grootste investering sinds de oprichting in 2003. Hoewel Pantera de handelsvoorwaarden niet heeft bekendgemaakt, wordt gemeld dat de investering in maart is gedaan tegen een prijs ‘veel lager dan de spotprijs’. Pantera heeft deze investering officieel aangekondigd in mei.</p>
<p>Van de nieuwste TON-fondsen is Pantera overtuigd van de vooruitzichten van deze token. Vorige maand zei Pantera-partner Ryan Barney: “We geloven dat het TON-netwerk nog in de beginfase zit en kijken uit naar de adoptie van Telegram’s gebruikersbasis van het ecosysteem en nieuwe functies.”</p>
<h2 id="h2-Markttrends20De20markt20blijft20dalen20maar20de20daling20van20Altcoins20is20afgenomen439875"><a name="Markttrends: De markt blijft dalen, maar de daling van Altcoins is afgenomen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: De markt blijft dalen, maar de daling van Altcoins is afgenomen</h2><p>BTC daalde vanochtend onder de $63.000, en Bitcoin spot ETF’s bleven netto uitstromen ervaren. De markt ontbrak aan nieuwe kapitaalinvoer en het sentiment van beleggers was voorzichtig.</p>
<p>ETH zakte vanochtend bijna onder de $3.400, en de volatiliteit is nu afgenomen.</p>
<p>Altcoins zijn over het algemeen in waarde gedaald, maar de daling is kleiner in vergelijking met voorgaande weken, wat erop wijst dat sommige investeerders wellicht kopen wanneer de prijzen dalen of de marktverkoopdruk verminderen.</p>
<h3 id="h3-Markt20Hotspots317288"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>Publieke Chain TON: TON heeft relatief goede prestaties laten zien onder talloze Altcoins, voornamelijk vanwege de talloze kleine games binnen zijn ecosysteem. Deze kleine games, met extreem hoge dagelijkse actieve gebruikers, hebben de marktverwachtingen voor de marktkapitalisatie van TON versterkt.</p>
<p>BLAST Airdrop: Het Layer2-project Blast, gelanceerd door Pacman, de oprichter van het NFT-handelsplatform Blur, staat op het punt token-airdrops te ontvangen. Momenteel is de TVL van Blast $2 miljard. Vanwege de algemene trage marktsituatie is de prestatie van de nieuwe valuta slecht geweest, wat te zien is aan de grote controverse die vorige week werd veroorzaakt door het populaire Layer2-project ZK. Investeerders moeten een voorzichtige houding aannemen ten opzichte van nieuwe projecten.</p>
<p>Meme sector: Het concepttoken MAGA voor de Amerikaanse verkiezingen presteerde afgelopen weekend goed, steeg op een gegeven moment met 30%, maar de opleving was niet zwak na een scherpe daling vanmorgen. Het presidentsverkiezingsdebat wordt verwacht op de 27e, wat de gevoeligheid van de markt voor politieke gebeurtenissen aantoont. De celebrity coin DADDY wordt voortdurend gepromoot door Andrew Tate, en de prijs is verdubbeld, met een huidige circulerende marktwaarde van ongeveer $170 miljoen. Het beroemdheidseffect en de promotie via sociale media hebben een aanzienlijke impact op Meme-tokens.</p>
<h3 id="h3-Samenvattend73801"><a name="Samenvattend:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvattend:</h3><p>Vanwege de over het algemeen lage marktstemming moeten beleggers voorzichtig blijven en grote investeringen vermijden wanneer de markt onstabiel is. U kunt potentiële projecten, zoals TON en BLAST, in de gaten houden. Ondertussen moet u zich richten op de algehele marktstemming en de specifieke prestaties van nieuwe projecten om te voorkomen dat u blindelings de trend volgt. Bovendien moeten gebruikers ook overwegen om hun investeringen te diversifiëren om fondsen niet op één project of sector te concentreren, om risico’s te verminderen. Behoud flexibiliteit, pas investeringsstrategieën op tijd aan en doe goed werk bij het stoppen van verliezen en winsten.</p>
<h2 id="h2-Macro20Zwakte20in20technologische20aandelen20en20versterking20van20de20Amerikaanse20dollar20hadden20invloed20op20de20wereldwijde20markten20terwijl20inflatie20en20politieke20factoren20leidden20tot20een20daling20van20de20Aziatische20aandelenmarkten866406"><a name="Macro: Zwakte in technologische aandelen en versterking van de Amerikaanse dollar hadden invloed op de wereldwijde markten, terwijl inflatie en politieke factoren leidden tot een daling van de Aziatische aandelenmarkten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Zwakte in technologische aandelen en versterking van de Amerikaanse dollar hadden invloed op de wereldwijde markten, terwijl inflatie en politieke factoren leidden tot een daling van de Aziatische aandelenmarkten</h2><p>Afgelopen vrijdag daalden de wereldwijde aandelenmarkten voor de tweede opeenvolgende handelsdag als gevolg van de zwakte van technologieaandelen, terwijl de Amerikaanse dollar het hoogste niveau sinds begin mei bereikte. Deze trend is het gevolg van de index die de Amerikaanse bedrijfsactiviteit meet, die licht stijgt naar het hoogste punt in meer dan twee jaar.</p>
<p>S&amp;P Global verklaarde dat de Amerikaanse Composite PMI Output Index, die de productie en diensten volgt, deze maand licht steeg naar 54,6, het hoogste niveau sinds april 2022, met een lezing van 54,5 in mei. Een lezing boven de 50 geeft aan dat de economie groeit.</p>
<p>De Dow Jones Industrial Average steeg met 0,04% tot 39150,33 punten; De S&amp;P 500 index daalde met 8,55 punten, of 0,16%, tot 5464,62 punten; De Nasdaq Composite Index daalde met 0,18% tot 17689,36 punten. Vorige week steeg de Dow Jones Industrial Average lichtjes met 1,44%, wat de grootste wekelijkse stijging sinds medio mei markeert. De S&amp;P 500 index steeg met 0,61%, wat de derde opeenvolgende week van winst markeert. De Nasdaq index steeg deze week slechts met 0,003%, wat de derde opeenvolgende week van winst markeert.</p>
<p>Hoewel het aantal eerste werkloosheidsuitkeringen in de Verenigde Staten vorige week is afgenomen, laten de laatste gegevens zien dat het totale aantal mensen dat werkloosheidsuitkeringen ontvangt het hoogste niveau heeft bereikt sinds januari, wat wijst op een aanhoudende afkoeling van de arbeidsmarkt.</p>
<p>Op 24 juni daalden Aziatische aandelenmarkten omdat investeerders wachtten op de aanstaande publicatie van Amerikaanse prijsgegevens in de hoop dat dit een aanhoudende vertraging in de inflatie zou laten zien. De MSCI Asia Pacific aandelenindex exclusief Japan daalde met 0,9%, de Zuid-Koreaanse aandelenmarkt daalde met 0,8% en de Nikkei-index in Japan steeg licht met 0,2%. Tegelijkertijd testte de Amerikaanse dollar de 160 yen-grens en blijft de markt waakzaam over mogelijke interventiemaatregelen die Japan kan nemen.</p>
<p>Geopolitieke informatie is bijzonder zorgwekkend, met het eerste debat van de Amerikaanse president gepland voor donderdag en de eerste ronde van de stemming voor de Franse algemene verkiezing gepland voor het weekend.</p>
<p>In de valutamarkt steeg de Amerikaanse dollarprijsindex, die de wisselkoers van de Amerikaanse dollar tegenover een mandje van belangrijke valuta meet, met 0,17% tot 105,81, terwijl de euro met 0,09% daalde tot $1,069. De Amerikaanse dollar steeg met 0,43% ten opzichte van de Japanse yen tot 159,59. De gegevens die vrijdag door Japan zijn vrijgegeven, toonden aan dat de vraaggedreven inflatie in mei vertraagde, wat een schaduw werpt over de vooruitzichten van de Bank of Japan om de rentetarieven te verhogen.</p>
<p>Wat betreft grondstoffen zijn de olieprijzen licht gedaald na een stijging van ongeveer 3% vorige week. De prijzen van Brent ruwe olie daalden met 17 cent tot $85.07 per vat, terwijl de prijzen van Amerikaanse ruwe olie met 18 cent daalden tot $80.55 per vat.</p>
<p>De goudprijs staat onder druk vanwege de versterking van de Amerikaanse dollar en bereikt $2.324 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 standpunten 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 op voorwaarde dat Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>