RGFnZWxpamtzIG5pZXV3cyB8IEJUQydzIHN0aWpnaW5nIGxlaWR0IHRvdCBlZW4gZGFsaW5nIHZhbiBBbHRjb2luczsgSlBNb3JnYW4gQ2hhc2UgaGVlZnQgZGUgcHJvZHVjdGlla29zdGVuIHZhbiBCVEMgaGVyemllbiB0b3QgJDQ1SzsgUGFuY2FrZVN3YXAgaGVlZnQgYWFuZ2Vrb25kaWdkIGJldGFsaW5nIHZhbiBpbnRlcmZhY2Vrb3N

2024-05-17, 03:56

<p><img src="https://gimg2.gateimg.com/image/article/17159181021_10.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20JPMorgan20Chase20heeft20de20BTCproductiekosten20herzien20naar204500020PancakeSwap20heeft20aangekondigd20dat20ze20de20interfacekosten20betalen20voor20Uniswapgebruikers20DTCC20en20Chainlink20hebben20de20pilot20van20fondsgegevenstokenisatie20voltooid677069"><a name="Crypto Dagelijkse Samenvatting: JPMorgan Chase heeft de BTC-productiekosten herzien naar $45.000; PancakeSwap heeft aangekondigd dat ze de interfacekosten betalen voor Uniswap-gebruikers; DTCC en Chainlink hebben de pilot van fondsgegevenstokenisatie voltooid" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: JPMorgan Chase heeft de BTC-productiekosten herzien naar $45.000; <a href="/price/pancakeswap-cake" target="_blank" class="blog_inner_link">PancakeSwap</a> heeft aangekondigd dat ze de interfacekosten betalen voor Uniswap-gebruikers; DTCC en Chainlink hebben de pilot van fondsgegevenstokenisatie voltooid</h2><p>Laten we eerst kijken naar 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 16 mei nog steeds uitstroom van $4,6 miljoen aan fondsen. Ondertussen was de instroom van Fidelity Bitcoin spot ETF (FBTC) $67,1 miljoen, de instroom van Bitwise Bitcoin spot ETF (BITB) $1,4 miljoen en de instroom van ARK 21Shares Bitcoin spot ETF (ARKB) $62 miljoen.</p>
<p>JPMorgan Chase heeft onlangs zijn centrale schatting voor de productiekosten van Bitcoin aangepast van de vorige $42.000 naar $45.000 als gevolg van veranderingen in de rekenkracht voor Bitcoin-mining.</p>
<p>JPMorgan-analist Nikolaos Panigirtzoglou wees in een op donderdag uitgebracht rapport op, “We verwachtten eerder een aanzienlijke afname van rekenkracht na halvering, doordat onrendabele Bitcoin-mijnwerkers het Bitcoin-netwerk verlaten. Ondanks enige vertraging lijkt dit te gebeuren.” Analisten voegden eraan toe dat de huidige rekenkracht en het energieverbruik hun centrale schatting van de productiekosten van Bitcoin rond de $45.000 brengen, ver onder de huidige prijs (ongeveer $65.000).</p>
<p>In februari schatten analisten de kosten voor het produceren van één Bitcoin op $42.000. Daarom schatten ze ook dat, zodra de opwinding veroorzaakt door halvering na april afneemt, het prijsdoel voor Bitcoin $42.000 zal zijn. Panigrtzoglou voegde toe: ‘De schatting van de productiekosten is een functie van rekenkracht en mijnbouwapparatuurefficiëntie, die voortdurend veranderen na halvering.’</p>
<p>Aan de andere kant heeft het runenprotocol geleid tot een tijdelijke stijging van de transactiekosten van Bitcoin, wat heeft gezorgd voor inkomensgroei voor miners. Analisten wezen er echter in het rapport op dat de boost van de runen van korte duur was en dat de gebruikersactiviteit en -uitgaven de afgelopen één of twee weken sterk zijn afgenomen. Dit benadrukt de voortdurende uitdagingen waar Bitcoin miners voor staan bij het behouden van duurzame inkomstenbronnen, vooral in de omgeving na de halvering.</p>
<p>Analisten wijzen erop dat naarmate de enthousiasme voor rune protocollen afneemt en de tijdelijke drijvende kracht van Bitcoin miners verzwakt, de afname in energieverbruik van het netwerk groter is dan de afname in hash rates, wat aangeeft dat niet-winstgevende en inefficiënte miners zich terugtrekken.</p>
<p>De gedecentraliseerde uitwisseling <a href="/price/pancakeswap-cake" rel="nofollow noopener noreferrer" target="_blank">PancakeSwap</a> heeft onlangs plannen aangekondigd om tot $8 miljoen aan kosten te betalen die door handelaren zijn gemaakt op zijn concurrent <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a>.</p>
<p>Volgens het plan ontvangen crypto-handelaren die deelnemen aan PancakeSwap v3 een volledige interfacekosten-teruggave voor <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> v3 handelsvolume in een verhouding van 1:1 van 16 mei tot 15 augustus. Deze stap is te wijten aan Uniswap Labs die de kosten van de meeste uitwisselbare interfaces verhoogt van 0,15% naar 0,25% om de last voor gebruikers te verlichten. De interfacekosten van Uniswap zijn de kosten die handelaren betalen bij het gebruik van de wallet-interface van het protocol en netwerktoepassingen voor het uitvoeren van tokenuitwisselingen.</p>
<p>Om in aanmerking te komen voor een terugbetaling, moeten cryptohandelaren ten minste $5.000 aan verpakte Bitcoin (WBTC) en verpakte <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> WETH-paren verhandeld op het Uniswap Ethereum-platform tussen 1 januari en 31 maart. Uniswap-gebruikers kunnen toegang krijgen tot het Dune-dashboard van PancakeSwap om hun activiteitseisen te controleren en moeten een formulier invullen om in aanmerking te komen voor vergoeding.</p>
<p>De interfacekostenactie van PancakeSwap v3 markeert zijn nieuwste inspanning om dominantie te verwerven ten opzichte van concurrenten. Volgens de gegevens van CoinGecko staat Pancakeswap momenteel op de zesde plaats in DEX op basis van het dagelijkse handelsvolume, net achter het handelsvolume van $700 miljoen van Uniswap V3.</p>
<p>De American Depositary Trust and Clearing Corporation (DTCC) is een samenwerking aangegaan met Chainlink om een proefprogramma te voltooien om gegevens voor traditionele financiële fondsen te tokeniseren, en is met succes een partnerschap aangegaan met verschillende grote Amerikaanse bankbedrijven, waaronder JPMorgan Chase en Bank of New York Mellon.</p>
<p>Volgens het DTCC-rapport heet het pilotproject het Smart Asset Net Worth Pilot Program, dat tot doel heeft het gebruik van Chainlink’s Cross Chain Interoperability Protocol (CCIP) te standaardiseren om NAV-gegevens van fondsactiva tussen blockchains te verstrekken. In het rapport staat: “Door gestructureerde gegevens op de keten te verstrekken en standaardrollen en -processen te creëren, kunnen basisgegevens worden ingebed in verschillende on-chain use cases, zoals getokeniseerde fondsen en ‘bulk consumenten’ slimme contracten die gegevens van meerdere fondsen bevatten.”</p>
<p>De resultaten van dit pilotproject tonen aan dat het tokeniseren van fondsgegevens toekomstige verkenning van de sector kan ondersteunen en ‘tal van downstreamgebruiksscenario’s’ kan ondersteunen, zoals makelaarstoepassingen, meer geautomatiseerde gegevensverspreiding en gemakkelijker toegang tot historische fondsgegevens.</p>
<p>DTCC wees er ook op dat het pilotproject zal helpen bij het opzetten van een beter geautomatiseerd gegevensbeheer en een beperkte impact zal hebben op de bestaande marktpraktijken van traditionele financiële instellingen. Bovendien stelt het project klanten ook in staat om historische gegevens op te halen zonder handmatig gegevens op te slaan en biedt het een bredere API-oplossing voor prijsgegevens.</p>
<h2 id="h2-Markttrends20BTC20heeft20een20dominante20snelheid20van205620DE20prestatie20is20niet20zoals20verwacht447510"><a name="Markttrends: BTC heeft een dominante snelheid van 56%, DE prestatie is niet zoals verwacht" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC heeft een dominante snelheid van 56%, DE prestatie is niet zoals verwacht</h2><p>BTC brak gisteren door de $66.000-grens, maar kende vervolgens een lichte terugval en noteert momenteel $65.350. Deze terugval zorgde voor een aanzienlijke daling in Altcoins, waardoor het overheersingspercentage van BTC verder steeg naar 56%. Op macro-economisch gebied is er een terugval geweest op de Amerikaanse aandelenmarkt en de markt verwacht over het algemeen een grotere kans op een renteverlaging in september.</p>
<h3 id="h3-Markt20Hotspots830352"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>Ton Eco Populair Meme Project NIET Gelanceerd op Gate.io: Ondanks hoge verwachtingen voor de lancering, is de prijsprestatie niet zoals verwacht en is deze bijna gehalveerd sinds de piek. NIET is een volledig circulerende Meme-token, waarbij miners ongeveer 80% in handen hebben en een huidige marktwaarde van ongeveer $760 miljoen, in lijn met de voorspelling van gisteren. De prijsprestatie van dit project verdient verdere aandacht en kan van invloed zijn op het vertrouwen van toekomstige investeerders in Meme-tokens.</p>
<p>Oracle-keten <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a> omhooggeschoten: Er zijn geruchten dat <a href="/price/link-ln" target="_blank" class="blog_inner_link">LINK</a> een partnerschap aangaat met JP Morgan, en dit nieuws kan een drijvende factor worden voor prijsstijgingen. Tegelijkertijd heeft de FTM van de publieke keten ook een stijging gezien, en het projectteam is van plan Sonic in het derde kwartaal te upgraden, wat mogelijk een beloningsplan voor ontwikkelaars kan omvatten. Dit positieve nieuws kan meer aandacht van investeerders trekken naar gerelateerde projecten.</p>
<p>ALEX en STX in het BTC-ecosysteem zijn flink gedaald: ALEX is een DEX-project in het BTC-ecosysteem. Onlangs is de privésleutel van de fondsen gestolen en hebben hackers STX gestolen om te verkopen, wat heeft geleid tot een aanzienlijke daling van de prijzen van gerelateerde tokens. Dit incident dient als waarschuwing voor de beveiligingsproblemen van BTC-ecosysteemprojecten, en investeerders moeten voorzichtig zijn met de beleggingsrisico’s van bijbehorende projecten.</p>
<p>Tegen de achtergrond van de correctie van de BTC-prijs heeft de algemene daling van Altcoins geleid tot een verdere toename van de dominantie van BTC. Investeerders moeten de markttrends nauwlettend volgen, tijdig hun beleggingsstrategieën aanpassen en beleggingsrisico’s voorkomen.</p>
<h2 id="h2-Macro20Nadat20de20Dow20Jonesindex20de20mijlpaal20van204000020bereikte20verloor20de20Amerikaanse20aandelenmarkt20momentum20en20daalde20de20Aziatische20markt20licht226398"><a name="Macro: Nadat de Dow Jones-index de mijlpaal van 40.000 bereikte, verloor de Amerikaanse aandelenmarkt momentum en daalde de Aziatische markt licht" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Nadat de Dow Jones-index de mijlpaal van 40.000 bereikte, verloor de Amerikaanse aandelenmarkt momentum en daalde de Aziatische markt licht</h2><p>Op 16 mei sloot de Amerikaanse aandelenmarkt lager, omdat beleggers hun verwachtingen ten aanzien van renteverlaging begonnen aan te passen toen de Dow Jones-index voor het eerst een historische mijlpaal van 40.000 punten bereikte. Ondanks gegevens die een vertraging van de inflatie laten zien, verdwenen de vroege winsten op de aandelenmarkt en sloten de drie belangrijkste aandelenindices iets lager.</p>
<p>De specifieke prestaties van de drie belangrijkste indices: de Dow Jones-index daalde met 0,10%; De Standard&amp;Poor’s-index daalde met 0,21%; De Nasdaq-index daalde met 0,26%. Ondanks de renteverhoging van de Federal Reserve is de Dow Jones Industrial Average hersteld sinds het dieptepunt in oktober 2022, gedreven door sterke economische groei in de Verenigde Staten.</p>
<p>Volgens gegevens van de FedWatch-tool van de Chicago Mercantile Exchange wedden beleggers erop dat de Federal Reserve dit jaar twee keer de rente zal verlagen en verwachten een kans van 70% op de eerste renteverlaging in september.</p>
<p>De gegevens tonen aan dat de consumentenprijsstijging in april lager was dan verwacht, wat erop wijst dat de inflatie weer een neerwaartse trend heeft ingezet. Op woensdag vestigden alle drie belangrijke Wall Street aandelenindexen historische sluitingsrecords. Donderdag toonden de gegevens echter aan dat het aantal nieuwe aanvragen voor werkloosheidsuitkeringen in de Verenigde Staten vorige week is afgenomen. Hoewel de groei van de werkgelegenheid afneemt, blijft de arbeidsmarkt gespannen.</p>
<p>Op 17 mei daalden Aziatische aandelenmarkten lichtjes en handelaren waren voorzichtig bij het overwegen van het pad van het Amerikaanse monetair beleid. Functionarissen van de Federal Reserve hebben verklaard dat hoewel de inflatie vroege tekenen van vertraging vertoont, de rentetarieven mogelijk hoog moeten blijven gedurende een langere periode.</p>
<p>De gegevens van woensdag lieten zien dat de Amerikaanse consumentenprijsinflatie is afgenomen, waardoor de markt snel de verwachtingen van ten minste twee renteverlagingen dit jaar heeft verwerkt. De laatste rapportage toont echter aan dat de arbeidsmarkt gespannen blijft en dat de gouverneur van de centrale bank voorzichtig is over de inflatie, wat investeerders doet twijfelen aan het monetaire beleid.</p>
<p>Hoewel de gegevens van deze week twee aspecten van goed nieuws bieden voor de Federal Reserve, moeten beleidsmakers nog van mening veranderen dat beleggers erop vertrouwen dat de renteverlagingen dit jaar zullen beginnen.</p>
<p>Met betrekking tot de valutamarkt steeg de euro met ongeveer 1% ten opzichte van de Amerikaanse dollar, met de laatste prijs op $1.08595. De USD/EUR wisselkoers kende zijn grootste wekelijkse daling sinds februari, terwijl de EUR/USD wisselkoers met ongeveer 1% steeg.</p>
<p>In de vroege handelssessie daalde de Japanse yen met 0,23% ten opzichte van de Amerikaanse dollar naar $155,80, waarbij een deel van de winst die eerder deze week was geboekt na een milde Amerikaanse CPI-rapport werd teruggenomen. Aangezien de Bank of Japan een ruim monetair beleid handhaaft, terwijl de stijging van de Amerikaanse rentetarieven fondsen naar Amerikaanse obligaties en dollars trekt, is de yen dit jaar met ongeveer 9,5% gedaald.</p>
<p>Op het gebied van grondstoffen zijn de olieprijzen tijdens de Aziatische handelsuren gestegen en wordt verwacht dat de wereldwijde benchmark Brent-ruwe olieprijs zijn eerste wekelijkse stijging in drie weken zal zien als gevolg van een verbeterde wereldwijde vraag en tekenen van vertragende inflatie in het grootste olieverbruikende land van de Verenigde Staten.</p>
<p>De prijs van Amerikaanse ruwe olie is vrijwel onveranderd gebleven, terwijl de wereldwijde benchmark Brent ruwe olieprijs is gestegen als gevolg van verbeterde wereldwijde vraag en tekenen van vertragende Amerikaanse inflatie. De prijs van ruwe olie in de Verenigde Staten is $79.18 per vat, terwijl Brent ruwe olie met 0.1% is gestegen naar $83.35 per vat.</p>
<p>De prijs van goud blijft hoog op $2.377,25 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 beleggingsaanbevelingen.<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>