V2VrZWxpamtzIFdlYjMtb25kZXJ6b2VrIHwgTWFzdGVyY2FyZCBrb210IGRpY2h0ZXIgYmlqIGRlIHJlbGVhc2UgdmFuIE11bHRpLVRva2VuIE5ldHdvcmsgKE1UTiksIFNsb3dhYWtzZSB3ZXRnZXZlcnMgc3RlbW1lbiB2b29yIHZlcmxhZ2luZyB2YW4gZGUgYmVsYXN0aW5nIG9wIGNyeXB0by1pbmtvbXN0ZW4=

2023-06-30, 01:18

[//]:content-type-MARKDOWN-DONOT-DELETE
![](https://gimg2.gateimg.com/image/article/168388743720230512-182447.jpeg)

## Wekelijks Trendoverzicht

In de afgelopen week hebben de meeste top 100 cryptocurrencies gematigde prijsstijgingen doorgemaakt, wat wijst op het vertragen van de recente intense stijgende trend in de markt. Deze waarderingsfluctuaties variëren van 0,65% tot 18,16%. Op dit moment bedraagt de totale marktkapitalisatie van de cryptomarkt $1,17 biljoen.
![](https://gimg2.gateimg.com/image/article/16880877761.png)
(Data met dank aan CoinmarketCap)

## Cryptomarkt

🔥 Vroeg op maandag bereikte BCH een nieuw jaarrecord, waardoor de rally met meer dan 100% werd uitgebreid sinds het werd toegevoegd aan de lijst van vier cryptocurrencies ondersteund door EDX Markets. BCH bereikte zijn hoogtepunt sinds mei 2022. Meer informatie: [Bitcoin Cash (BCH): Een opleving](https://www.gate.io/blog_detail/2822/bitcoin-cash-bch-resurgence "Bitcoin Cash (BCH): Een heropleving”

🔥 Mastercard nadert de onvermijdelijke lancering van zijn Multi-Token Network (MTN) product, wat een historisch keerpunt markeert voor het groeiende bereik van het bedrijf in de digitale financiën en blockchain technologie ruimte. MTN is bedoeld om de beveiliging, schaalbaarheid en interoperabiliteit van blockchain ecosystemen te vergroten.

🔥 De Blockchain Association heeft verklaard dat volgens de federale wet SEC-voorzitter Gary Gensler een stap terug moet doen uit de digitale activaruimte, bewerend dat Gensler "buiten zijn door het congres verleende grenzen stapt".

🔥 Internationaal vermogensbeheerbedrijf Fidelity Investments heeft zijn aanvraag voor een plek opniek ingediend [Bitcoin](/price/bitcoin-btc) ETF ondanks de mislukte aanvraag van het voorgaande jaar. Tot op heden is geen enkele instelling die een BTC ETF heeft aangevraagd succesvol geweest.

## Regelgevingsbeleid

🔥 Europa: Slowaakse wetgevers hebben onlangs gestemd om wetgeving door te voeren om de handel en het bezit van cryptocurrency te reguleren en belasten tegen een lager tarief dan eerder beschreven. Het is bedoeld om het belastingtarief van cryptocurrencies die ten minste een jaar worden aangehouden te verlagen van de huidige tarieven van 19% of 25% naar 7%.

🔥 VK: Het VK crypto-wetsvoorstel heeft nu officieel het laatste stadium bereikt en wacht momenteel op de goedkeuring van koning Charles III, of koninklijke instemming, wat de laatste stap is die nodig is voor het wetsvoorstel om wet te worden, waardoor de regelgevende benadering van cryptocurrencies in het VK wordt hertekend.

## Macro-economie

HSBC, een Britse bankreus, heeft verklaard dat recessie waarschuwingen “rood knipperen” voor verschillende landen en dat fiscale en monetaire beleidslijnen “uit de pas lopen” met de aandelen- en obligatiemarkten. Als gevolg hiervan heeft HSBC gewaarschuwd voor de mogelijkheid van een Amerikaanse recessie later dit jaar, wat onvermijdelijk de weg zal effenen voor een Europese recessie in 2024.

🔥 De Chinese premier Li Qiang verklaarde tijdens de opening van de plenaire vergadering van het jaarlijkse World Economic Forum's Annual Meeting of the New Champions dat de groei van China nog steeds op koers ligt om het jaarlijkse groeidoel van ongeveer 5% te halen. Li Qiang zei: "Op basis van wat we dit jaar kunnen zien, vertoont de Chinese economie duidelijk een momentum van herstel en verbetering."

## Crypto Markt Highlights

⭐️Activa uit het Synthetic Issuer-ecosysteem hebben enorme waardestijgingen gezien, wat de totale waardering van het ecosysteem de afgelopen week met 10% heeft doen stijgen. Diverse activa die hebben bijgedragen aan deze groei hebben op weekbasis een stijging tot wel 28% gezien, waarbij Mirror Protocol (MIR) de kroon spant met een stijging van 28%. Daarna volgde op de voet ... [Synthetix Netwerk](/price/synthetix-network-snx) (SNX), dat in de afgelopen zeven dagen met 15,8% in waarde is gestegen, waarvan 11,3% in de afgelopen 24 uur is gewonnen.

⭐️ [Meer informatie: Wat is Synthetix?](https://www.gate.io/de/blog_detail/974/what-is-synthetix-snx-crypto-meets-traditional-finance " Learn more: What is Synthetix?")![](https://gimg2.gateimg.com/image/article/16880877932.png)
(MIR Prijsgegevens met dank aan CoinGecko)

## BTC & ETH Wekelijkse Prestatie

### Bitcoin (BTC)

![](https://gimg2.gateimg.com/image/article/16880878083.png)
(Gegevens met dank aan TradingView)

Op 27 juni probeerden kopers Bitcoin boven de bovenliggende weerstandszone van $ 31k te katapulteren, maar de beren weigerden te wijken en dwongen de prijs in een nauwe bandbreedte tussen $ 31k en $ 29,5k. Als gevolg hiervan is het waarschijnlijk dat de beren zullen proberen de prijs onder de bodem van $ 29,5k te laten zakken. Als de beren echter blijven verdedigen op dit niveau, kan dit wijzen op langdurige prijssterkte en levensduur van het huidige prijsbereik. Bovendien geven de stijgende 20-daagse exponentiële voortschrijdend gemiddelde (EMA) van $ 28.696 en de relatieve sterkte-index (RSI) in positief gebied verder aan dat de weg van de minste weerstand naar boven is.

Als er positieve momentum volgt en kopers door de weerstand van $31k breken, is het mogelijk dat BTC zijn opwaartse trend voortzet. Beren kunnen echter proberen elke beweging boven $32.400 te vertragen. Het eerste teken van aanzienlijke prijszwakte zou een sluiting onder $29,5k zijn, wat een terugtrekking richting de 20-daagse EMA kan veroorzaken. Als dit niveau breekt, kan BTC zich in een range bevinden tussen $31k en $24,8k.

### Ether (ETH)

![](https://gimg2.gateimg.com/image/article/16880878204.png)
(Data Met Dank Aan TradingView)

Op het dagelijkse tijdsbestek, [Ethereum](/price/ethereum-eth) handelt in een smal bereik tussen $1.936 en $1.861. Dit heeft de beren ertoe aangezet om te proberen de prijs onder de voortschrijdende gemiddelden te laten zakken, wat een mogelijke daling richting de sterke ondersteuning van $1.700 zou kunnen veroorzaken. Als de prijs echter stuitert van de voortschrijdende gemiddelden, zou dit wijzen op een hevige verdediging van de stieren, wat een mogelijke doorbraak van het weerstandsniveau van $1.937 en een mogelijke rally richting het psychologische niveau van $2.000 zou kunnen aangeven.

## Web3 Project Trend

Deze week zijn er zeer kleine stijgingen en dalingen geweest in waardering en volume over alle belangrijke activacategorieën, variërend van hoogtepunten van +0,2% en dieptepunten van -9,6%, die waarschijnlijk allemaal kunnen worden toegeschreven aan de vertraging van het positieve momentum dat in eerdere weken prijsrally's in de hele markt heeft veroorzaakt. Echter, individuele activa in elke klasse hebben indrukwekkende prijsrally's gezien, waarvan vele meer dan 80%.

| Project categorie | 7d Verandering | Top 3 stijgers | Reactie |
| --- | --- | --- | --- |
| Laag 1 | +0.2% | BCH, UNQ, INJ | Geïsoleerde gevallen zoals BCH zijn met meer dan 80% gestegen, wat de Layer-1 sector heeft ondersteund. |
| Laag 2 | -5.1% | LAI, ARB, CTSI | Er zijn matige prijsdalingen geweest in het Layer 2 ecosysteem, met LAI als enige uitzondering en steeg met 86% deze week. |
| DeFi | +0.2% | COMP, SRM, PENDLE | DeFi heeft een matige versterking gezien, waarbij veel activa indrukwekkende prijsstijgingen vertonen, maar de meerderheid heeft verwaarloosbare prijsstijgingen of -dalingen gezien. |
| NFT | -3,3% | ALU, GST-ETH, SIDUS | De NFT-sector is de afgelopen week blijven stagneren, wat heeft geleid tot een voortdurende daling van de sectorwaarde. |
| MEME | -3,1% | SWOLE, 3D3D, TURBO | De MEME sector heeft de afgelopen week een afname van momentum gezien, waarbij een meerderheid van de activa kleine verliezen vertoont. |
| LSD | -0.5% | MAG, STINJ, MSOL | De LSD-sector heeft te maken gehad met matige prijsstijgingen en -dalingen die geen merkbare invloed op de sector hebben gehad. |
| BRC-20 | -9.6% | MAXI, MOON, SATS | Verschillende activa hebben deze week een indrukwekkende groei gezien tot wel 1012%, terwijl de meerderheid verliezen heeft gezien tot wel 96%, wat de waardering van de sector verder heeft verlaagd. |

<div class="blog-details-info">
<div>Auteur: Gate.io Onderzoeker: <strong>Matthew Webster-Dowsing</strong>
<div class="info-tips">*Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen beleggingsadvies.
<div>*Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle andere gevallen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.
</div><p></p>
</div></div></div>