RGFnZWxpamtzIG5pZXV3cyB8IEVsIFNhbHZhZG9yIGxhbmNlZXJ0IEJpdGNvaW4gTWluaW5nIFBvb2wsIExhdmEgUG9vbDsgRXIgaXMgZWVuIGRhbGluZyBpbiB6b3dlbCBkZSBpbmtvbXN0ZW4gdmFuIEJpdGNvaW4tbWlqbndlcmtlcnMgYWxzIGRlIGlua29tc3RlbiB1aXQgRVRIIFBsZWRnaW5nIGluIHNlcHRlbWJlci4=

2023-10-05, 08:39

<p><img src="https://gimg2.gateimg.com/image/article/16965064921005.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20El20Salvador20lanceert20Bitcoinminingpool20Lava20Pool20Er20is20een20daling20in20zowel20het20inkomen20van20Bitcoinmijnwerkers20als20het20inkomen20uit20ETHpledging20in20september20BIS20lanceert20een20platform20dat20de20centrale20bank20kan20helpen20bij20het20volgen20van20de20Bitcoinstroom657563"><a name="Crypto Dagelijkse Samenvatting: El Salvador lanceert Bitcoin-miningpool, Lava Pool; Er is een daling in zowel het inkomen van Bitcoin-mijnwerkers als het inkomen uit ETH-pledging in september; BIS lanceert een platform dat de centrale bank kan helpen bij het volgen van de Bitcoin-stroom" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: El Salvador lanceert Bitcoin-miningpool, Lava Pool; Er is een daling in zowel het inkomen van Bitcoin-mijnwerkers als het inkomen uit ETH-pledging in september; BIS lanceert een platform dat de centrale bank kan helpen bij het volgen van de Bitcoin-stroom</h2><p>Volcano Energy, geleid door de regering van El Salvador <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Volcano Energy, een mijnbouwproject, heeft een partnerschap aangegaan met Luxor Technology om het eerste mijnbouwzwembad van het land, Lava Pool, te lanceren. Volcano Energy koos ervoor om samen te werken met Luxor vanwege de voldoende ervaring van de laatstgenoemde in het leveren van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> mijnbouwsoftware en -diensten. Het project slaagde er ook in om marktvolatiliteit te beperken met behulp van een hash rate forwards markt van Luxor, evenals geautomatiseerde risicobeheerstrategieën die worden gebruikt door andere grote Bitcoin mijnbouwoperators.</p>
<p>Volgens gegevens van The Block Pro was er in september een daling te zien in zowel het inkomen van Bitcoin miners als het inkomen uit ETH-staking. Specifiek kromp het inkomen van Bitcoin miners verder tot 753 miljoen dollar, wat een daling betekende van 6,4%. Tegelijkertijd <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> stakinginkomsten daalden ook met 11,2% tot ongeveer $115 miljoen.</p>
<p>De Britse Financial Conduct Authority (FCA) staat op het punt een tweede cryptocurrency sandbox te lanceren, waarbij gevestigde regels voor digitale effecten worden toegepast.</p>
<p>Een op woensdag vrijgegeven onderzoek van de Bank for International Settlements (BIS) suggereert dat nieuwe gedecentraliseerde financiële gegevensplatforms statistieken van gegevens over de cryptocurrency-markt kunnen bevatten en daardoor het toezicht op marktdeelnemers vergemakkelijken. ‘We ontwikkelen een belangrijk nieuw openbaar product voor centrale banken over de hele wereld’, aldus Cecilia Skingsley, hoofd van het BIS Innovation Center, in een verklaring.</p>
<p>Hong Kong Exchanges and Clearing Limited (HKEX) heeft de lancering aangekondigd van HKEX Synapse (Synapse), dat het Shanghai-Shenzhen-Hong Kong Stock Connect transactieafwikkelingsversnellingsplatform is. Dit is een innovatief allesomvattend platform dat de nieuwste technologie gebruikt om meerdere partijen in staat te stellen gezamenlijk het na-afwikkelingsproces af te handelen, met als doel de efficiëntie en transparantie van het na-afwikkelingsproces aanzienlijk te verbeteren. Synapse staat gepland om te worden gelanceerd op 9 oktober 2023, met als doel om DAML smart contract technologie te gebruiken om post-trade workflows te standaardiseren en te vereenvoudigen, operationele efficiëntie en transparantie te verbeteren, en afwikkelingsrisico’s te verminderen.</p>
<p>Immunefi berekent dat hacker aanvallen en fraude $685,5 miljoen aan verliezen hebben veroorzaakt voor het <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> ecosysteem in het derde kwartaal, een stijging van 59,9% ten opzichte van dezelfde periode vorig jaar.</p>
<p>Op basis van een kwantitatieve analyse van de blockchain-financiële sector voorspelt Allied Market Research dat de sector het potentieel heeft om een groei van 60,5% te bereiken. <a href="/price/compound-comp" rel="nofollow noopener noreferrer" target="_blank">Samengesteld</a> jaarlijkse groeipercentage (CAGR), en de omvang van de markt kan tegen 2032 toenemen tot $ 79.3 miljard.</p>
<p>Ripple’s vestiging in Singapore heeft een belangrijke vergunning van de Monetaire Autoriteit van Singapore (MAS) ontvangen, waardoor het digitale betaaltokendiensten in Singapore kan aanbieden, zo meldde het bedrijf.</p>
<h2 id="h2-Huidige20belangrijkste20token20trends596962"><a name="Huidige belangrijkste token trends" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Huidige belangrijkste token trends</h2><h3 id="h3-BTC2289"><a name="BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC</h3><p><img src="https://gimg2.gateimg.com/image/article/169650653010411696495014_.pic.jpg" alt=""><br>Overzicht: Sinds Bitcoin op 17 augustus de daggrafiekpoort bereikte, schommelt BIC al bijna anderhalve maand tussen $25.000 en $28.500. Er zullen handelssignalen zijn wanneer het de drukniveau van $30.000 doorbreekt en het ondersteuningsniveau van $26.000.</p>
<h3 id="h3-ETH348837"><a name="ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ETH</h3><p><img src="https://gimg2.gateimg.com/image/article/169650654710421696495028_.pic.jpg" alt=""><br>Bekijken: <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> is sinds 2023 verankerd aan Bitcoin terwijl het onder Bitcoin loopt, wat een herhaling is van het beeld in 2019 toen de markt aan het herstellen was. Hoewel de tweede lancering van het testnetwerk Holesky van Ethereum succesvol was, is er geen garantie of de Cancun-upgrade, die gepland staat voor het einde van het jaar, kan worden voltooid. Sinds de vervanging van POW door POS staat de Ethereum-gemeenschap voor een centralisatietrend, waarvoor nog geen oplossing is gevonden. Al deze problemen voeden het pessimisme op de markt. De dagelijkse lijn blijft schommelen tussen $ 1530- $ 1750, en er zal een handelssignaal zijn wanneer het de ondersteuningsniveaus van $ 1530- $ 1550 doorbreekt.</p>
<h3 id="h3-AAN838120"><a name="AAN" class="reference-link"></a><span class="header-link octicon octicon-link"></span>AAN</h3><p><img src="https://gimg2.gateimg.com/image/article/169650656410431696495040_.pic.jpg" alt=""><br>Overzicht: Na langdurige consolidaties heeft de dagelijkse lijn van OP een breakout- en retracement-patroon gevormd na de MACD-onderdivergentie, wat erop wijst dat de bearish trend mogelijk ten einde komt en er een bullish trend kan volgen. Als dit het g is, zullen er handelsmogelijkheden zijn wanneer het $1.59 en $1.79 doorbreekt. Als het echter in tegenstelling is tot onze voorspelling om Bitcoin en Ethereum scherp te zien dalen, kan dit duiden op een potentieel bearish markt. In zo’n g moeten we kijken of de prijs kan stoppen met dalen en ergens rond $1.2 kan herstellen, wat een mogelijkheid kan betekenen om activa te verkopen om verlies te stoppen.</p>
<h2 id="h2-Macro20ADPgegevens20geven20aan20dat20de20werkgelegenheidsmarkt20zacht20is20het20nonagrarische20gegevens20dat20deze20vrijdag20wordt20gepubliceerd20wordt20wijdverbreid20opgemerkt804881"><a name="Macro: ADP-gegevens geven aan dat de werkgelegenheidsmarkt zacht is; het non-agrarische gegevens dat deze vrijdag wordt gepubliceerd, wordt wijdverbreid opgemerkt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: ADP-gegevens geven aan dat de werkgelegenheidsmarkt zacht is; het non-agrarische gegevens dat deze vrijdag wordt gepubliceerd, wordt wijdverbreid opgemerkt</h2><p>De ontmoedigende Amerikaanse ADP-werkgelegenheidsgegevens die gisteren zijn vrijgegeven, zijn zeer in strijd met de algemene verwachtingen. Dit heeft echter het effect van tijdelijke verlichting van de neerwaartse druk op risicoactiva.</p>
<p>Allereerst moeten we de definitie van de ADP-werkgelegenheid begrijpen. ADP-werkgelegenheid wordt opgesteld door Amerikaanse automatische gegevensverwerkende bedrijven en wordt beschouwd als relatief gezaghebbende gegevens over de Amerikaanse arbeidsmarkt. De gegevens worden ook wel aangeduid als ‘voorspelling van gegevens over niet-agrarische werkgelegenheid’. Door naar de ADP-werkgelegenheid te kijken, kan de markt over het algemeen voorspellen hoe de gegevens over de Amerikaanse niet-agrarische werkgelegenheid zich zullen gedragen.</p>
<p>Uit gegevens van ADP die gisteren werden vrijgegeven, bleek dat de Verenigde Staten vorige maand een toename van 89.000 particuliere banen zagen, ruim onder de 160.000 die de Dow Jones had voorspeld en onder de opwaarts herziene 180.000 in augustus. Met name de vrijetijds- en horecasector droeg bij aan het grootste deel van de werkgelegenheid in september, wat de daling van het ingehuurde personeel in de professionele en zakelijke dienstverlening, productie, handel en transport compenseerde. Ook het aantal werknemers dat door grote ondernemingen werd ingehuurd, daalde. Het rapport is een bijkomend bewijs dat aantoont dat de arbeidsmarkt een neerwaartse trend blijft doormaken. De arbeidsmarkt heeft lang zijn toevlucht genomen tot het stimuleren van consumentenbestedingen om de economische groei te stimuleren. Onder druk van de hardnekkig hoge inflatie en de stijgende financieringskosten verminderen sommige werkgevers het aantal aanwervingen.</p>
<p>Als we terugkijken naar de historische gegevens, zien we dat de ADP van deze maand de kleinste stijging sinds 2021 heeft gezien, wat wijst op een verzwakkende vraag naar arbeid in verschillende sectoren.</p>
<p>Na de vrijgave van de ADP-gegevens liet CME FedWatch zien dat er een kans van 81,3% was dat de Fed de rentetarieven binnen het bereik van 5,25%-5,50% zou handhaven in november, en een kans van 18,7% op een verhoging van de rentetarieven met 25 basispunten naar 5,50%-5,75%. Er is een kans van 64,3% dat de rentetarieven in december ongewijzigd blijven, een kans van 31,8% op een cumulatieve stijging van 25 basispunten in de rentevoet, en een kans van 3,9% op een cumulatieve stijging van 50 basispunten in de renteverhoging. Swaps laten ook zien dat de Fed minder waarschijnlijk de rentetarieven opnieuw zal verhogen.</p>
<p>Wat dit betreft, merkt JPMorgan Chase op dat los van de relatie tussen de ADP-gegevens en de gegevens over de niet-agrarische lonen, de ADP-gegevens wel een trend van langzamere groei op de arbeidsmarkt in de afgelopen maanden laten zien, wat min of meer in lijn is met wat er op de arbeidsmarkt zou moeten gebeuren. Mike Loewengart, de directeur van JPMorgan Chase &amp; Co., merkte op dat ADP niet per se een betrouwbare voorspeller is van de maandelijkse werkgelegenheidsgegevens van de overheid. Maar als de dalende tendens op de arbeidsmarkt bevestigd wordt door het rapport van vrijdag, zal dit helpen om de angst onder aandelenbeleggers die te maken hebben met stijgende rentetarieven te verminderen.</p>
<p>Ondertussen daalde de Amerikaanse ISM Services PMI in september tot 53,6 van 54,5 eerder, volgens consensus. De gegevens tonen tekenen van afkoeling van de dienstensector, aangezien consumenten steeds kieskeuriger worden naarmate de financieringskosten blijven stijgen, de inflatie hardnekkig hoog blijft en de lonen in een steeds trager tempo toenemen.</p>
<p>Zoals we al hebben aangegeven in onze vorige artikelen, ervaart het huidige macro-financiële klimaat een overgang waarbij strak beleidsbeheer begint los te laten, wat kan leiden tot instabiele prestaties in sommige economische gegevens. De dalende werkgelegenheidsgegevens zullen de Fed wat ademruimte geven en in ieder g een reden zijn om haar havikachtige standpunt te verzwakken.</p>
<p>We zullen nauwlettend toezien op de gegevens over niet-landbouwloon die deze vrijdag worden vrijgegeven. Als de gegevens een minder pessimistisch beeld laten zien, zal dit nuttiger zijn om de markt, inclusief de cryptosector, te stimuleren.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Peter L.</strong>, Gate.io Onderzoeker<br><div>Vertaler: Sally<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen beleggingsadvies.<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 juridische actie worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>