RGFnZWxpamtzIG5pZXV3cyB8IENyeXB0byBNYXJrdCBFcnZhYXJ0IFp3YWtrZSBGbHVjdHVhdGllczsgSGFtc3RlciBLb21iYXQga29uZGlndCA2MCUgVG9rZW4gQWlyZHJvcCBhYW47IEJsYWNrYmlyZCBMYWJzIGxhbmNlZXJ0IFdlYjMgUGxhdGZvcm0gdm9vciBSZXN0YXVyYW50IEJldGFsaW5nZW4=

2024-07-31, 03:46

<p><img src="https://gimg2.gateimg.com/image/article/17223972451_24.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Hamster20Kombat20kondigt206020token20airdrop20aan20Blackbird20Labs20lanceert20Web3platform20voor20restaurantbetalingen20Movement20Labs20Testnet20vrijgegeven20trekt2016020miljoen20aan20beloofde20TVL20aan853335"><a name="Crypto Daily Digest: Hamster Kombat kondigt 60% token airdrop aan; Blackbird Labs lanceert Web3-platform voor restaurantbetalingen; Movement Labs Testnet vrijgegeven, trekt $160 miljoen aan beloofde TVL aan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Hamster Kombat kondigt 60% token airdrop aan; Blackbird Labs lanceert Web3-platform voor restaurantbetalingen; Movement Labs Testnet vrijgegeven, trekt $160 miljoen aan beloofde TVL aan</h2><p>Laten we eerst de handelsactiviteit van onderzoeken <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF’s. Volgens gegevens van Farside Investor had Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Spot ETF (GBTC) op 30 juli een uitstroom van $73,6 miljoen. Ondertussen had de Fidelity Bitcoin Spot ETF (FBTC) een uitstroom van $2,9 miljoen, de Bitwise Bitcoin Spot ETF (BITB) een uitstroom van $3,2 miljoen en de ARK 21Shares Bitcoin Spot ETF (ARKB) een uitstroom van $7,9 miljoen.</p>
<p>Bitwise <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Spot ETF (ETHW) had een instroom van $3,5 miljoen; Fidelity Ethereum Spot ETF (FETH) had op de eerste dag een netto-instroom van $16,4 miljoen; Grayscale Ethereum Spot ETF (ETHE) had op de eerste dag een netto-uitstroom van $120,3 miljoen.</p>
<p>Het marktaandeel van Bitcoin, dat de relatieve marktwaarde van Bitcoin ten opzichte van de totale marktwaarde van cryptocurrencies meet, bereikte vorige week een hoogtepunt van 52,7%, het hoogste niveau in drie jaar sinds april 2021.</p>
<p><strong>Hamster Kombat lanceert een nieuwe whitepaper en wijst 60% van de tokens toe aan spelers via airdrop</strong></p>
<p>Het team van Hamster Kombat heeft dinsdag een nieuw whitepaper uitgebracht waarin de token-economie van het project wordt toegelicht en het aankomende token-luchtdropevenement wordt onthuld. In het whitepaper wordt beweerd dat ze van plan zijn de ‘grootste luchtdrop in de cryptogeschiedenis’ te houden en dat het spel momenteel 300 miljoen gebruikers heeft. Volgens het whitepaper zal 60% van de tokens ‘specifiek’ worden gebruikt om spelers te belonen.</p>
<p>Het whitepaper vermeldt ook dat ‘de resterende middelen zullen worden gebruikt om marktvloeibaarheid, ecosysteempartnerschappen en subsidies, beloningsteams en andere projecten te bieden.’ Ontwikkelaars verklaarden dat Hamster Kombat geen steun heeft ontvangen van investeringsmaatschappijen of durfkapitalisten, en daarom geen ‘verkoopdruk’ zal ondervinden.</p>
<p>Aanvankelijk was het de bedoeling dat het spel deze maand zijn eerste airdrop zou ondergaan, maar dinsdag werd aangekondigd dat het uitvoeren van de airdrop een complexe operatie zou zijn. De ontwikkelaar verklaarde in de officiële Telegramgroep dat de Hamster-token airdrop een technisch complexe taak is en dat we geen specifieke datum hebben vastgesteld omdat het moeilijk is om de exacte tijd van de uitvoering van dit plan te voorspellen.</p>
<p>Hoewel de oprichter anoniem blijft, hebben ze in korte tijd een grote spelersgemeenschap opgebouwd, en is Hamster Kombat een veelbesproken onderwerp geworden in het crypto-veld. Voormalig Hamster Kombat heeft 50 miljoen dagelijks actieve gebruikers in 190 landen.</p>
<p>Het spel werd geïnspireerd door het succes van Notchcoin. Ter referentie, Notcoin heeft in mei meer dan 80 miljard NOT-tokens ter waarde van ongeveer $1 miljard gedropt.</p>
<p><strong>Blackbird Labs lanceert <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> platform voor restaurant betalingen</strong></p>
<p>Op 30 juli kondigde Blackbird Labs, een hoteltechnologie-startup opgericht door medeoprichter van Resy en Eater, Ben Leventhal, de lancering aan van een Web3-betaalplatform genaamd Blackbird Pay, speciaal ontworpen voor restaurants. Het platform is gebouwd op het nieuwe blockchain-netwerk Blackbird Flynet van Blackbird en biedt restaurants voor het eerst een eigen end-to-end betalings- en afwikkelingsnetwerk, met als doel problemen zoals verminderde winst en kasreserves op te lossen.</p>
<p>Het doel van Blackbird Pay is om de afwikkelingstijd te verkorten en de transactiekosten voor restaurants te verlagen tot ongeveer 2% per transactie. Bovendien stelt het klanten in staat om betalingen te doen met behulp van Blackbird’s eigen token FLY, dat wordt uitgegeven als beloning op het platform. Blackbird Pay stelt klanten van aangesloten restaurants in staat om betalingen rechtstreeks vanuit de Blackbird-app te doen met behulp van creditcards, betaalpassen, FLY-tokens of <a href="/price/usd-coin-usdc" rel="nofollow noopener noreferrer" target="_blank">USD Coin</a> (USDC). De applicatie kent ook aan elke gebruiker een unieke klantwaardering toe, die restaurants kunnen gebruiken als basis voor op maat gemaakte punten, voordelen en beloningsprogramma’s.</p>
<p>De potentiële toepassing van Web3-startups in de cateringindustrie is enorm en omvat kostenverlaging, beloningsprogramma’s voor management en gamificatie. Andere deelnemers zijn DevourGO, een <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> maaltijdbezorgdienst. Volgens de gegevens van de American Restaurant Association zullen de verkopen van Amerikaanse restaurants naar verwachting in 2024 voor het eerst de $1 biljoen overschrijden.</p>
<p>Roni Mazumdar, mede-eigenaar van Unpalogetic Foods, verklaarde dat Blackbird en vergelijkbare diensten restaurants kunnen helpen duizenden dollars te besparen aan maandelijkse transactiekosten.</p>
<p>Blackbird is nog steeds bezig met het ontwikkelen van berichten- en ontdekkingstoepassingen voor restaurants, waaronder projecten zoals Blackbird Breakfast Club en Bar Blackbird, gericht op het genereren van meer voetverkeer naar restaurants tijdens het laagseizoen. Het bedrijf haalde $ 24 miljoen op in Series A-financiering onder leiding van Andreessen Horowitz.</p>
<p><strong>Movement Labs sluit zich aan <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> AgLayer van ‘s werelds testnet geeft $160 miljoen vrij aan beloofde TVL</strong></p>
<p>Blockchain-ontwikkelingsbedrijf Movement Labs kondigde aan dat het zich aansluit bij Polygon’s Ethereum Layer 2 AgLayer, ter gelegenheid van de lancering van het openbare testnetwerk van Movement. Movement is het eerste Move-gebaseerde ecosysteem dat AgLayer gebruikt om de kloof tussen de Move- en EVM-ecoen te overbruggen en Ethereum-ontwikkelaars in staat te stellen Solidity-contracten op Move-gebaseerde ketens te implementeren zonder code aan te passen.</p>
<p>AgLayer is een interoperabiliteitslaag ontwikkeld door <a href="/price/polygon-matic" target="_blank" class="blog_inner_link">Polygon</a> Labs en andere kernbijdragers, met als doel het bevorderen van eenheid in liquiditeit en veiligheid over ketennetwerken. AgLayer vereenvoudigt het proces van het converteren of veilig overdragen van inheemse Ethereum-assets van de ene keten naar de andere door ZK-gebaseerde beveiligingsbewijzen opnieuw af te wikkelen naar Ethereum.</p>
<p>AgLayer zal dienen als een verenigde liquiditeitslaag tussen MoveVM-gebaseerde chains, andere ‘AggChains’ en Ethereum, om de problemen van blockchain-fragmentatie aan te pakken. De infrastructuur zal ook gebruikmaken van Celestia’s gegevensbeschikbaarheidslaag voor kosteneffectieve, hoge doorvoer buiten de keten gegevensopslag met behoud van de beveiliging van Ethereum.</p>
<p>Movement Labs kondigde in april van dit jaar de voltooiing aan van een financieringsronde van $38 miljoen voor Serie A, geleid door Polychain Capital, met als doel de virtuele machine Move van Facebook te introduceren in Ethereum. Move werd in eerste instantie ontwikkeld door leden van het Diem-stablecoinproject van Facebook. Movement Labs beweert dat vóór de implementatie van het mainnet, de publieke testnet Parthenon al $160 miljoen aan beloofde TVL had aangetrokken.</p>
<h2 id="h2-Markttrends20De20algehele20markt20is20zwak20en20volatiel20en20de20markt20wacht20op20de20rentebeslissing20van20de20Federal20Reserve297784"><a name="Markttrends: De algehele markt is zwak en volatiel, en de markt wacht op de rentebeslissing van de Federal Reserve" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: De algehele markt is zwak en volatiel, en de markt wacht op de rentebeslissing van de Federal Reserve</h2><p>BTC vertoont een zwakke en volatiele trend rond $66.000. Het Mt.Gox-incident blijft borrelen, met een grote hoeveelheid BTC die wordt overgeboekt voor compensatie, wat enige verkoopdruk op de markt heeft veroorzaakt. Ondertussen heeft de Bitcoin spot ETF een uitstroom gezien van bijna $100 miljoen, en hoewel BlackRock zijn relevante gegevens nog niet heeft bijgewerkt, is het marktsentiment enigszins beïnvloed.</p>
<p>ETH: In vergelijking met Bitcoin heeft ETH relatief goed gepresteerd, met een prijs die boven $3.250 gehandhaafd blijft. De uitstroom van Grayscale Ethereum ETF’s is de afgelopen dagen vertraagd.</p>
<p>Altcoin: De Altcoin-markt mist nieuwe hotspots en ervaart over het algemeen een neerwaartse trend. De focus van investeerders ligt voornamelijk op mainstream valuta’s, en het marktsentiment voor Altcoins is relatief laag.</p>
<h3 id="h3-Gegevensindicatoren762689"><a name="Gegevensindicatoren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gegevensindicatoren</h3><p>Vandaag staat de AHR999-index op 0,87, hoewel de index licht gedaald is, is het nog steeds geschikt voor langetermijnbeleggers om regelmatig te investeren. De AHR999-index is een belangrijke indicator voor het meten van de langetermijnbeleggingswaarde van de markt, en de huidige waarden geven aan dat er nog steeds goede langetermijnbeleggingsmogelijkheden op de markt zijn.</p>
<p>De Fear &amp; Greed Index blijft op 61, wat wijst op een afname van de hebzuchtige marktsentiment. Deze index is een belangrijke indicator voor het meten van marktsentiment, waarbij hogere waarden wijzen op een hebzuchtigere markt en vice versa wijzen op een angstigere markt. De huidige waarden geven aan dat het marktsentiment rustiger wordt en investeerders voorzichtig moeten blijven in hun operaties.</p>
<h3 id="h3-Macro20Nieuws47949"><a name="Macro Nieuws" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro Nieuws</h3><p>Amerikaanse aandelenmarkt: De drie belangrijkste indexen hebben geschommeld, waarbij technologie-aandelen, vertegenwoordigd door NVIDIA, met 7% zijn gedaald, waardoor de Nasdaq-index meer dan 1% is gedaald. Dit nieuws heeft een zekere negatieve invloed gehad op de wereldwijde activamarkt.</p>
<p>Monetair beleid: De Federal Reserve zal haar rentebesluit om 2:00 uur Beijing-tijd op donderdag bekendmaken en Fed-voorzitter Powell zal om 2:30 uur een toespraak houden. Er wordt verwacht dat er mogelijk aanzienlijke marktfluctuaties zullen zijn voor en na deze periode, en investeerders moeten hun posities redelijk beheersen.</p>
<h3 id="h3-Markt20Hotspots126625"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p><strong>Telegram mini game</strong><br>Hamster Kombat, dat meer dan 50 miljoen Telegram-abonnees heeft, heeft gisteren zijn token whitepaper bijgewerkt en aangekondigd dat 60% van zijn tokens zal worden gebruikt voor gebruikersairdrops. Hoewel de officiële beweert dat er meer dan 300 miljoen gebruikers in het spel zijn, lijkt de waarde van de airdrop van tokens die een enkele gebruiker kan ontvangen beperkt te zijn in het licht van deze schaal van gebruikersgroep. Het is vermeldenswaard dat Gate.io pre-market trading heeft gelanceerd voor deze token, en investeerders kunnen letten op de prestaties op de markt.</p>
<p><strong><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Ecosysteem</strong><br>De prijs van <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> (SOL) is onder de $180 markt gezakt, en alle on-chain Meme tokens, behalve BOME, bevinden zich in een neerwaartse trend. Marktmening suggereert dat de aanzienlijke daling van SOL mogelijk verband houdt met de verzending van SOL die tegen een gereduceerde prijs is gekocht door een bepaalde crypto-investeringsinstelling. Volgens nieuwsberichten zal de SOL die door de instelling tegen een gereduceerde prijs is gekocht een vergrendelingsperiode van 4 jaar ondergaan, maar in werkelijkheid circuleren deze tokens al op de markt en is er geen verplichte vergrendelingsmechanisme. Dit heeft een aanzienlijke negatieve invloed gehad op de marktprijs van SOL.</p>
<h3 id="h3-Conclusie280913"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h3><p>Over het algemeen is het huidige marktsentiment relatief kalm, met aanzienlijke differentiatie in de prestaties van de belangrijkste valuta’s. De korte termijn trend van de markt is onzeker, en de rentebeslissing van de Fed en de toespraak van Powell zullen de focus van de markt deze week zijn, wat naar verwachting aanzienlijke schommelingen op de risicomarkt zal veroorzaken. Beleggers moeten hun posities redelijkerwijs onder controle houden en voorzichtige operaties handhaven.</p>
<h2 id="h2-Macro20De20markt20is20voorzichtig20voor20de20publicatie20van20financile20rapporten20van20technologieaandelen20met20de20SampP2050020en20Nasdaqindices20die20dalen217988"><a name="Macro: De markt is voorzichtig voor de publicatie van financiële rapporten van technologieaandelen, met de S&amp;P 500 en Nasdaq-indices die dalen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De markt is voorzichtig voor de publicatie van financiële rapporten van technologieaandelen, met de S&amp;P 500 en Nasdaq-indices die dalen</h2><p>Op dinsdag 30 juli sloten de S&amp;P 500-index en de Nasdaq-index lager, voornamelijk gedrukt door zwakke prestaties in chip- en grote tech-aandelen, terwijl een reeks belangrijke financiële rapporten van techbedrijven die deze week worden uitgebracht, ook de marktonzekerheid vergrootten. Daarentegen steeg de Dow Jones Industrial Average lichtjes.</p>
<p>Als een van de leiders op het gebied van kunstmatige intelligentie daalde de aandelenkoers van Microsoft met 0,89% tot $422,92 voordat het kwartaalresultaat bekend werd gemaakt. Ondanks hoge marktverwachtingen was de prestatie van de softwaregigant lager dan de groeiprognose voor Azure cloud computing services, waardoor de aandelenkoers met ongeveer 5% daalde in de handel na sluitingstijd.</p>
<p>Specifieke gegevens tonen aan dat de Dow Jones Industrial Average met 0,5% steeg, terwijl de S&amp;P 500-index met 0,5% daalde en de Nasdaq-index met 1,28% daalde.</p>
<p>Chipfabrikant Nvidia daalde met 7,04% en sloot op $103,73. Dit trok ook andere chipaandelen naar beneden, waardoor de Philadelphia Semiconductor Index met 3,88% daalde. Daarnaast steeg Apple met 0,26%, daalde Amazon met 0,81% en daalde Meta met 0,54%, voornamelijk vanwege marktzorgen over de waardering ervan.</p>
<p>Deze week zullen ook meerdere gegevens over de arbeidsmarkt worden vrijgegeven, waaronder het werkgelegenheidsrapport van de overheid op vrijdag. Uit de vacature- en arbeidsmobiliteitsonderzoek, dat dinsdag werd vrijgegeven, bleek dat het aantal vacatures in juni 8,18 miljoen bedroeg, hoger dan de verwachtingen van economen van 8 miljoen.</p>
<p>Op woensdag 31 juli bleven de Aziatische aandelenmarkten binnen een bekend bereik, wat de divergentie weerspiegelt op het gebied van kunstmatige intelligentie vanwege het scherpe prestatiecontrast tussen techgigant Microsoft en chipfabrikant AMD. Voordat de Bank of Japan haar beleidsbeslissing bekendmaakte, versterkte de yen. Op woensdag stonden het beleid van centrale banken over de hele wereld centraal in de aandacht van beleggers en ook de Federal Reserve zal later op die dag haar rentebesluit bekendmaken. De markt verwacht over het algemeen dat de Amerikaanse centrale bank de rente ongewijzigd zal houden, maar kan wijzen op toekomstige renteverlagingen.</p>
<p>Aan de Chinese kant toonde een officieel fabrieksonderzoek dat woensdag werd vrijgegeven aan dat de productieactiviteit voor de derde opeenvolgende maand is gekrompen, wat de marktverwachtingen voor meer economische stimuleringsmaatregelen vergroot. De officiële inkoopmanagersindex (PMI) voor juli daalde van 49,5 in juni naar 49,4, hoewel het onder de boom bust line van 50 ligt, is het hoger dan de mediane voorspelling van 49,3 in een Reuters-onderzoek.</p>
<p>Bij de eerste handel daalde de yen met 1%, maar vanwege de algehele waardering van de yen wordt verwacht dat deze in juli met 3,7% zal dalen.</p>
<p>Op de grondstoffenmarkt steeg Amerikaanse ruwe olie met 0,67% naar $75,23 per vat, terwijl Brent-ruwe olie met 0,5% steeg naar $79,02 per vat. Goudprijzen stegen ook met ongeveer 1% op dinsdag, omdat investeerders verwachtten dat de Federal Reserve dit weekend aanwijzingen zou kunnen geven over een renteverlaging in september. Spotgoud steeg met 0,8% naar $2403,47 per ounce, terwijl de afrekenprijs van Amerikaanse goudtermijncontracten met 1% steeg naar $2451,9 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 opvattingen van de onderzoeker en vormt geen enkele beleggingssuggesties.<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>