RGFnZWxpamtzZSBuaWV1d3MgfCBNZWVyZGVyZSB1aXR2b2VyZW5kZSBsZWlkZXJzIHZhbiB0ZWNoIGdpZ2FudGVuIHppam4gdG9lZ2V0cmVkZW4gdG90IFdMRDsgQURBIGhlZWZ0IGRlIE1pQ0EtbmFsZXZpbmdzaW5kaWNhdG9yZW4gYmlqZ2V3ZXJrdDsgQmxhc3QgaGVlZnQgZGUgMmUgZmFzZSB2YW4gZGUgQWlyZHJvcC1yZWdlbHMgdWl

2024-07-03, 03:31

<p><img src="https://gimg2.gateimg.com/image/article/17199773311_4.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Meerdere20utives20van20tech20giganten20zijn20lid20geworden20van20Worldcoin20Cardano20heeft20de20MiCAnalevingsindicatoren20vooraf20bijgewerkt20Blast20kondigt20de20tweede20fase20van20de20airdropregels20aan20en20verdeelt201020miljard20BLASTs683385"><a name="Crypto Daily Digest: Meerdere utives van tech giganten zijn lid geworden van Worldcoin; Cardano heeft de MiCA-nalevingsindicatoren vooraf bijgewerkt; Blast kondigt de tweede fase van de airdrop-regels aan en verdeelt 10 miljard BLASTs" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Meerdere utives van tech giganten zijn lid geworden van Worldcoin; <a href="/price/cardano-ada" target="_blank" class="blog_inner_link">Cardano</a> heeft de MiCA-nalevingsindicatoren vooraf bijgewerkt; Blast kondigt de tweede fase van de airdrop-regels aan en verdeelt 10 miljard BLASTs</h2><p>Allereerst gaan we 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 6 maart een uitstroom van $32,4 miljoen aan fondsen. Ondertussen had Fidelity Bitcoin spot ETF (FBTC) een instroom van $5,4 miljoen, Bitwise Bitcoin spot ETF (BITB) ondervond een uitstroom van $6,8 miljoen, en ARK 21Shares Bitcoin spot ETF (ARKB) had een instroom van $2,5 miljoen.</p>
<p><strong>Meerdere topmensen van techreuzen hebben zich aangesloten bij het Worldcoin-project van Sam Altman</strong><br>Sam Altman, CEO van OpenAI, medeoprichter van Worldcoin en Tools for Humanity, is een belangrijke bijdrager aan het project voor oogbal scannende encryptie van Worldcoin. Het bedrijf heeft onlangs aangekondigd dat het vier voormalige leidinggevenden van Apple, Google, Meta, Tesla en X heeft aangesteld voor het team.</p>
<p>De specifieke situatie is als volgt:</p>
<p>Rich Heley: Voormalig Apple, Meta en Tesla utives, die dienen als Chief Equipment Officer, verantwoordelijk voor het leiden van het ontwerp, de prestaties en de toegankelijkheid van Orb. Orb is een hardwareapparaat ontwikkeld door Tools for Humanity voor de iris-scanning van Worldcoin.</p>
<p>Damien Kieran: Voormalig Chief Privacy Officer van X, momenteel Chief Privacy Officer van Tools for Humanity. Zijn taak is samenwerken met wereldwijde gegevensprivacy functionarissen en regelgevende instanties om nieuwe branche standaarden voor naleving en privacybescherming te ontwikkelen.</p>
<p>Adrian Ludwig: Voormalig Google Android Security Director en Chief Information Security Officer van het bedrijf, is verantwoordelijk voor gegevensbeveiliging binnen en buiten Tools for Humanity.</p>
<p>Ajay Patel: Voormalig teamleider voor Google Payments en huidig Global ID Director, verantwoordelijk voor het leiden van de marketingstrategie, publiek-private partnerschappen en algemene gebruikerservaring.</p>
<p>Worldcoin streeft ernaar om zijn digitale identiteitssysteem, World ID, te gebruiken om de individuele uniciteit te valideren via biometrische gegevens en een wereldwijde digitale valuta te creëren die eerlijk wordt verdeeld onder iedereen. Tools for Humanity is van mening dat in het tijdperk van kunstmatige intelligentie de noodzaak van dergelijk “bewijs van menselijkheid” bijzonder belangrijk is. Het toevoegen van nieuwe werknemers heeft als doel om te helpen bij het aanpakken van privacy- en beveiligingsuitdagingen en “technologie te bouwen om een rechtvaardiger economisch systeem op te zetten.”</p>
<p>Sinds de lancering vorig jaar heeft Worldcoin te maken gehad met regelgevingsuitdagingen in meerdere landen. Worldcoin is gebaseerd op OP Mainnet en heeft plannen om over te gaan naar zijn <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Laag 2 blockchain deze zomer.</p>
<p><strong><a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> bijgewerkte MiCA-nalevingsstatistieken op voorhand</strong><br>De Cardano Foundation heeft samengewerkt met het Crypto Carbon Rating Institute (CCRI) om duurzaamheidsindicatoren uit te brengen die voldoen aan de MiCA-standaarden, met als doel Cardano op de voorgrond van regulering te plaatsen, met de nadruk op energie-efficiëntie en transparantie. Dit rapport is uitgebracht op 2 juli en voldoet aan de eis van MiCA voor crypto-uitgevers en dienstverleners om duurzaamheidsindicatoren bekend te maken. Volgens de Cardano Foundation werkt ze samen met CCRI om de kwaliteit van blockchain-monitoring en gegevensverzamelingsmethoden te waarborgen.</p>
<p>Het rapport wijst erop dat Cardano opereert met behulp van een energiezuiniger consensusprotocol en veel minder elektriciteit verbruikt dan het Proof of Work-protocol. Het geeft het jaarlijkse totale elektriciteitsverbruik en de koolstofvoetafdruk van het Cardano-netwerk, evenals de marginale elektriciteitsvraag per transactie per seconde. Het rapport geeft ook duurzaamheidsindicatoren die voldoen aan de ontwerpregelgevende technische normen van de Europese Autoriteit voor effecten en markten.</p>
<p>Frederik Gregor, CEO van Cardano Foundation, verklaarde dat de stichting door duurzaamheidsindicatoren te ontwikkelen die voldoen aan MiCA-normen, beoogt te voldoen aan aankomende EU-regelgeving en tegelijkertijd een benchmark te stellen voor de crypto-industrie. Hij wees erop: “Met de gedeeltelijke implementatie van MiCA-regelgeving bevindt de industrie zich momenteel in een zes maanden durende countdown om belangrijke ESG-bindende vereisten te implementeren.”</p>
<p>Deze inspanningen zijn cruciaal voor het opbouwen van vertrouwen bij regelgevende instanties, investeerders en gebruikers, waardoor de weg wordt vrijgemaakt voor een meer wijdverbreide adoptie van blockchaintechnologie op een duurzame manier.</p>
<p><strong>Blast kondigt de regels voor puntenallocatie aan voor de tweede fase van de airdrop, die 10 miljard BLASTs zal verdelen.</strong><br>Blast heeft onlangs de puntentoewijzingsregels vrijgegeven voor de tweede fase van luchtdroppen. In de tweede fase zal Blast 10 miljard BLAST-luchtdroppen verspreiden, waarvan 50% zal worden toegewezen aan reguliere punten (Punt). Gebruikers kunnen Punten verdienen door het vasthouden van ETH, WETH, USDB en BLAST, en de accumulatiesnelheid van Punten voor elk activum is hetzelfde.</p>
<p>Nog eens 50% van de aandelen wordt toegewezen aan goudpunten (Gold). Dapp kan Gold verdienen en het op basis van zijn aantrekkingskracht op de Blast-hoofdwebsite en toekomstige Big Bang-wedstrijden aan gebruikers verdelen. De toewijzing van Gold zal plaatsvinden in de eerste week van elke maand en het eerste nummer zal op 8 juli worden aangekondigd.</p>
<p>Bovendien ontvangen gebruikers die de Blast App hebben geïnstalleerd een “Golden Ticket” op basis van hun ETH, WETH, USDB en BLAST-saldi. Golden Tickets stellen gebruikers in staat om meer punten en goud te verdienen.</p>
<p>De mechanismen zoals Jackpot, puntvermenigvuldiger en een uitnodiging om punten terug te verdienen die bestaan in de eerste fase zullen blijven bestaan. Maar de uitnodigingen in de tweede fase worden onafhankelijk berekend.</p>
<h2 id="h2-Markttrends254618"><a name="Markttrends" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends</h2><p>BTC daalde onder de $62.000, met een zwak herstel. Bitcoin spot ETF’s hebben nettostromen gezien, en de Duitse overheid blijft BTC verkopen.</p>
<p>ETH is gedaald onder $3.400, wat duidt op een slecht marktsentiment.</p>
<p>SOL steeg tegen de trend in en brak door de $150, wat een sterke prestatie laat zien.</p>
<p>Altcoins zijn over het algemeen gedaald en het algemene marktsentiment is relatief laag.</p>
<h3 id="h3-Macroeconomie852071"><a name="Macroeconomie:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie:</h3><p>De drie belangrijkste Amerikaanse aandelenindices sloten gezamenlijk hoger, wat duidt op een goed marktsentiment.</p>
<p>Tesla behaalde zijn langste opeenvolgende dagen van winst sinds medio juli vorig jaar, met indrukwekkende prestaties.</p>
<h3 id="h3-Markt20Hotspots601534"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p><strong>Openbare Keten <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> (SOL):</strong><br>SOL steeg tegen de trend in: <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> presteerde sterk en brak door de $150. De nieuwe module Blinks en de verwachtingen van ETF’s die vorige week werden gelanceerd, hebben de prestaties van Solana nog indrukwekkender gemaakt.</p>
<p>Ecosysteemprojecten zoals RAY, MOBILE, POPCAT, BILLY, enz. hebben een aanzienlijke toename gezien.</p>
<p><strong>Publieke Chain Ton (TON):</strong><br>TON bleef stijgen: TON brak door de $8 grens, slechts één stap verwijderd van de vorige hoogte.</p>
<p>Ecosysteem mini-games: De mini-games op de Ton-keten blijven populair en trekken aanzienlijke marktaandacht.</p>
<p><strong>Re-staking protocol “Pendle Finance (PENDLE)”:</strong><br>Pendle’s opnieuw inzetten van bedrijven is langzaam aan het volwassen worden en levert resultaten op, met een aanzienlijke afname van de TVL en een halvering van zijn hoge positie. PENDLE daalde binnen een dag met bijna 25%.</p>
<p>De prijsdaling van Bitcoin en <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> weerspiegelt de onzekerheid van de markt en zorgen over de algehele markt. De netto uitstroom van Bitcoin spot ETF’s en de voortdurende verkoop door de Duitse regering hebben het negatieve sentiment op de markt versterkt. Op korte termijn kunnen BTC en ETH blijven onder druk staan.</p>
<p>De huidige markt toont een aanzienlijke differentiatie, waarbij mainstream valuta’s zoals BTC en ETH zwak presteren. Ondertussen stijgen publieke ketenprojecten zoals Solana en Ton tegen de trend in. De veranderingen in de macro-economische omgeving en de rotatie van markthotspots zullen blijven zorgen voor een aanzienlijke impact op de cryptomarkt. Beleggers moeten waakzaam blijven, zich richten op markttrends en tijdig hun beleggingsstrategie aanpassen.</p>
<h2 id="h2-Macro20Gedreven20door20andere20grote20aandelen20zoals20Tesla20sloot20de20Wall20Street20index20hoger20Aziatische20aandelenmarkten20stegen20vanwege20verwachte20renteverlagingen20en20de20Japanse20yen20bleef20in20de20buurt20van20een20dieptepunt20van203820jaar625446"><a name="Macro: Gedreven door andere grote aandelen zoals Tesla, sloot de Wall Street index hoger, Aziatische aandelenmarkten stegen vanwege verwachte renteverlagingen, en de Japanse yen bleef in de buurt van een dieptepunt van 38 jaar" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Gedreven door andere grote aandelen zoals Tesla, sloot de Wall Street index hoger, Aziatische aandelenmarkten stegen vanwege verwachte renteverlagingen, en de Japanse yen bleef in de buurt van een dieptepunt van 38 jaar</h2><p>Op 2 juli sloten de belangrijkste aandelenindices van Wall Street hoger vanwege de stijging van de aandelenkoers van Tesla en de stimulans van grote groeiaandelen. Het handelsvolume was echter relatief laag voor de vakantie op 4 juli en de langverwachte vrijgave van de gegevens van het niet-agrarisch loon van juni op vrijdag.</p>
<p>Specifiek stegen de drie belangrijkste indices: de Dow Jones-index steeg met 0,41%, de Standard &amp; Poor’s-index steeg met 0,62% en de Nasdaq-index steeg met 0,84%.</p>
<p>Bij de belangrijkste aandelen daalde AI-chip-leider Nvidia met 1,3%, terwijl andere chip-aandelen verschillende prestaties lieten zien. Apple steeg met 1,6%, terwijl ook Amazon en Alphabet stegen. Tegelijkertijd daalde de opbrengst van Amerikaanse schatkistbonnen in het algemeen.</p>
<p>Volgens gegevens van het Bureau of Labor Statistics van het Amerikaanse Ministerie van Arbeid is het aantal vacatures (een maatstaf voor de vraag naar arbeid) op de laatste dag van mei met 221.000 gestegen tot 8,14 miljoen. De gegevens voor april zijn verlaagd, met een aantal vacatures van 7,919 miljoen in plaats van de eerder gerapporteerde 8,059 miljoen. Economen die door Reuters zijn ondervraagd, schatten dat er in mei 7,91 miljoen vacatures waren.</p>
<p>Na een aanzienlijke daling van het aantal vacatures in de eerste twee maanden, is het aantal vacatures in mei gestegen, maar deze trend is in lijn met het versoepelen van de arbeidsmarkt, wat de weg kan vrijmaken voor de Federal Reserve om dit jaar de rente te verlagen.</p>
<p>Op 3 juli stegen de Aziatische aandelenmarkten op woensdag na een zwak begin van het seizoen op maandag en een daling van 0,5% op dinsdag. Deze stijging was te danken aan de sterke prestaties van de Amerikaanse en wereldwijde aandelenmarkten, gedreven door technologieaandelen en de daling van de opbrengst van Amerikaanse schatkistobligaties. De opmerkingen van voorzitter van de Federal Reserve, Jerome Powell, versterkten de verwachtingen van de markt voor de komende renteverlaging in de VS. De yen bleef in de buurt van het laagste niveau sinds 1986, waardoor handelaren op hun hoede waren voor mogelijke interventie van Japan.</p>
<p>Dit is een positieve mondiale achtergrond waar Aziatische aandelenmarktbeleggers naar uitkijken, hoewel deze situatie mogelijk wordt beïnvloed door een reeks PMI-rapporten van de dienstensector die zijn vrijgegeven door meerdere Aziatische landen, waaronder China, Japan en anderen.</p>
<p>Wat betreft de indices steeg de MSCI Asia Pacific aandelenindex met 0,26%, terwijl de Nikkei-index in Japan met 0,49% steeg en een historisch hoogtepunt in maart naderde. De Chinese aandelenmarkt daalde in de vroege handelssessie, waarbij de blue chip Shanghai en Shenzhen 300 Index met 0,27% daalden. De Hang Seng-index in Hong Kong steeg met 0,3%.</p>
<p>Gegevens tonen aan dat als gevolg van de vertraging in de groei van nieuwe orders, de groeisnelheid van de bedrijvigheid in de dienstensector van China in juni de langzaamste was in acht maanden en het vertrouwen daalde naar het laagste niveau in vier jaar, wat wijst op de behoefte aan meer economische stimuleringsmaatregelen.</p>
<p>Met betrekking tot grondstoffen zijn de olieprijzen gestegen als gevolg van industriële gegevens in de Verenigde Staten, wat de hoop op een solide brandstofvraag tijdens het hoogseizoen voor zomerritten heeft vergroot. Brent ruwe olie-futures stegen met 0,44% tot $86,62 per vat, terwijl West Texas Intermediate ruwe olie-futures in de Verenigde Staten met 0,41% stegen tot $83,15 per vat.</p>
<p>De goudprijs bleef woensdag ongewijzigd omdat beleggers wachtten op de notulen van de laatste vergadering van het Fed-beleidscomité om nieuwe aanwijzingen te vinden over wanneer de Amerikaanse centrale bank zal beginnen met het verlagen van de rente. Spotgoud bleef grotendeels onveranderd op $ 2.329,66 per ounce. Amerikaanse goud futures stegen 0,2% naar $ 2.338,70.</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 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 genoemd. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>