R2F0ZS5pbyBHbG9iYWwgUmVjcnVpdG1lbnQgUHJvZ3JhbV8gRWwgU2FsdmFkb3JfcyBPZmZpY2nDq2xlIEJUQyBXYWxsZXQgaGVlZnQgNCBtaWxqb2VuIG5pZXV3ZSBnZWJydWlrZXJzIGFhbmdldHJva2tlbl8gTm9nIGVlbiBCaXRjb2luIEVURiBhZmdld2V6ZW4gZG9vciBTRUNfIElyYW4gZ2FhdCBuYXRpb25hbGUgY3J5cHRvY3VycmU

<div style="text-align:center;">
	<span style="font-family:&quot;"><strong>Gate.io Wekelijkse Nieuwsbrief | Markttrends? Wereldwijde krantenkoppen? Wij dekken u.</strong><br />
<br />
</span><span style="font-family:&quot;"></span><img onerror="this.className=`errimg`" src="https://gimg.gateimg.com/image/article/1635500648twi_WeeklyNewsletter_en.jpg" width="600" height="299" alt="" /> 
</div>
<div style="text-align:center;">
	<br />
</div>
<strong>TL;DR? Luister onderweg!</strong><br />
<br />
<strong> Wekelijks bijgewerkt op </strong><a href="https://gateio.buzzsprout.com/?ch=buzzs" target="_blank"> <span style="color:#337FE5;"> <strong> Buzzsprout</strong></span> </a> <strong> , </strong><a href="https://podcasts.apple.com/us/podcast/altcoin-news-podcast-gate-io/id1593354040/?ch=podcastapple" target="_blank"> <span style="color:#337FE5;"> <strong> Apple Podcasts</strong></span> </a> <strong> , </strong><a href="https://open.spotify.com/show/0ju1qUjJseVxH57XXDKZPS/?ch=spotify" target="_blank"> <span style="color:#337FE5;"> <strong> Spotify</strong></span> </a> <strong> , en</strong><a href="https://podcasts.google.com/feed/aHR0cHM6Ly9mZWVkcy5idXp6c3Byb3V0LmNvbS8xODI1NzI5LnJzcw==/?ch=podcastwnl" target="_blank"> <span style="color:#337FE5;"> <strong> Google Podcasts</strong></span> </a> <strong> .</strong><br />
<br />
<strong>Gate.io Aankondiging</strong><br />
<br />
<strong> Gate.io Global Recruitment Program:</strong><br />
<br />
De geboorte van <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> heeft een hele nieuwe wereld doen ontstaan. Gate.io gelooft dat door wetenschappelijke, intelligente en toonaangevende blockchain toepassingen, we de wereldeconomie, sociale ontwikkeling en de vooruitgang van mensenlevens kunnen bevorderen. Om in zo'n complexe sector actief te zijn, zijn gelijkgestemde collega's nodig. We verwelkomen blockchain-talenten van over de hele wereld om zich bij Gate.io aan te sluiten en samen te werken om veilige en innovatieve blockchain-diensten te leveren aan onze wereldwijde klanten en partners.<a href="https://www.gate.io/article/23179?ch=banner_Global%20Recruitment" target="_blank"><span style="color:#337FE5;"> Meer informatie</span></a> <br />
<br />
<strong> TA Highlight</strong><br />
<br />
De eerste vijf dagen van deze week hadden relatief zwak gepresteerd, en op de 5e dag nam de cryptocurrency markt opnieuw een grote duik.<br />
<br />
<a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> daalde deze donderdag opnieuw sterk, en tegen vrijdag was de spotprijs van <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> onder de $40.000 gezakt. En de ethereum spotprijs daalde tot onder $3.000.<br />
<br />
Deze daling is geen technische aanpassing, maar een beleidsschok. Deze daling is marktbreed en kan tot volgende week duren. De markt bevindt zich momenteel in een staat van extreme paniek, en de opleving kan zwak zijn wanneer de markt weer in de retracement range komt.<br />
<br />
<strong>Crypto Alerts</strong><br />
<br />
<strong> De tweet van Musk kan duiden op een staat van chaos in de Metaverse</strong><br />
<br />
Elon Musk tweette een korte video van 10 seconden met de tekst "Ik vocht in de metaverse gevangenis yard waar ik veel tijd besteedde aan het maken van screenshots van NFT", wat suggereert dat de huidige metaverse en NFT markten ongeorganiseerd zijn.<br />
<br />
<strong>El Salvador's <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> wallet onboards 4M users with Netki partnership</strong><br />
<br />
El Salvador, het eerste land dat <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> (BTC) een wettig betaalmiddel maakt, heeft 4 miljoen gebruikers aan boord gebracht voor zijn door de overheid gesteunde BTC wallet Chivo in samenwerking met digitale identiteitsleverancier Netki, aldus een aankondiging.<br />
<br />
Chivo heeft ertoe bijgedragen dat El Salvador het eerste land is dat het gebruik van <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> even gemakkelijk maakt als fiat. Naast het wereldwijd overmaken van geld worden Chivo wallets gebruikt voor dagelijkse transacties in restaurants, cafetaria's, winkelcentra en elke andere detailhandel.<br />
<br />
De regering heeft ook honderden <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> geldautomaten in het hele land geplaatst, waarmee miljoenen aan grensoverschrijdende overboekingen worden gefaciliteerd. Chivo is erin geslaagd te doen wat banken in decennia niet hebben gekund.<br />
<br />
<strong>Cathie Wood zegt dat <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> het eerste wereldwijde particuliere digitale valutasysteem is</strong><br />
<br />
Tijdens een top die werd georganiseerd door het Global Wealth Management Forum, verklaarde de oprichter, CEO en chief investment officer van Ark Invest dat <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> het eerste wereldwijde particuliere digitale valutasysteem is, dat is gebaseerd op regels.<br />
<br />
Hij verwijst naar het voorbeeld van China, waar de meerderheid van de mijnbouwers al is vertrokken naar cryptovriendelijke kusten als gevolg van de overheidsmaatregelen. Wood vermeldde ook dat sommige delen van de wereld hun houding tegenover digitale activa nog moeten opwarmen, hoewel hun houding niet zo hard is als die van de Chinese regering.<br />
<br />
Ark Invest heeft naar verluidt via het ARK Fintech Innovation exchange-traded fund [ETF] van het bedrijf bijna 6,9 miljoen aandelen gekocht van het speciale overnamebedrijf of SPAC, dat fuseert met Circle, voor $ 70,6 miljoen.<br />
<br />
<strong>Verlaten TON cryptoproject zou kunnen terugkeren naar Telegram</strong><br />
<br />
De ooit grootse cryptoplannen van de Russische sociale mediagigant Telegram zijn misschien dood en begraven, maar ontwikkelaars die werken aan een netwerk op basis van het verlaten Telegram Open Network (TON) komen dichter bij de lancering van hun eigen versie van TON.<br />
<br />
Het TON-platform, dat gebruik zou maken van een munt genaamd de gram, zou 's werelds eerste echte altcoin worden die door grote technologiebedrijven wordt beheerd - voordat een interventie van Amerikaanse toezichthouders te elfder ure het platform deed ontsporen.<br />
<br />
En nu, uit de as van het verlaten netwerk, zijn enkele ontwikkelaars die verbonden waren aan het project van de firma verder gaan werken aan een afsplitsing die zij Free of Open TON noemden - en die sindsdien de naam Toncoin hebben gekregen.<br />
<br />
Een ontwikkelaar, Oleg Andreev, werd door Forbes geciteerd als verklarend dat het netwerk werd gebouwd op een manier die het zou laten integreren in het Telegram-platform - en interoperabel zou zijn met cryptobeurzen. Hij voegde eraan toe dat het betalingssysteem kan worden gebruikt in de gamewereld om in-game items en valuta te kopen en op contentplatforms.<br />
<br />
<strong> Marktupdates</strong><br />
<br />
<strong> SEC verwerpt Spot <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> ETF-voorstel van First Trust SkyBridge</strong><br />
<br />
De beslissing van de SEC komt ongeveer vier weken nadat zij het voorstel van beleggingsonderneming Kryptoin om een spot <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> ETF te noteren, verwierp. De commissie had eerder spot <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> ETF-voorstellen van VanEck en WisdomTree afgewezen.<br />
<br />
De uiteindelijke afwijzing die donderdag werd ingediend voor de voorgestelde First Trust SkyBridge <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> ETF Trust komt niet als een verrassing, gezien het precedent dat de SEC heeft geschapen voor een voorkeur voor ETF's die de<a href="https://www.gate.io/futures_trade/USDT/BTC_USDT" target="_blank"> bitcoin futures </a>markt volgen, in plaats van de activa zelf.<br />
<br />
Twee van dergelijke<a href="https://www.gate.io/futures_trade/USDT/BTC_USDT" target="_blank"> bitcoin futures </a>ETF's, de ProShares <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Strategy ETF (BITO) en de Valkyrie <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Strategy ETF (BTF), begonnen in oktober met de handel.<br />
<br />
<strong>Prada, Adidas lanceren NFT-project op Polygon</strong><br />
<br />
Het Italiaanse luxe modehuis Prada en sportkledinggigant Adidas, die zich onlangs in de metaverse hebben gewaagd, hebben hun krachten gebundeld om een nieuw niet-fungibel token (NFT)-project te lanceren dat is gebouwd op het Polygon-netwerk. Via het project kunnen fans hun eigen ontwerpen bijdragen.<br />
<br />
Prada en Adidas Originals zeiden dat ze een collectie NFT's ontworpen door de digitale kunstenaar Zach Lieberman zullen veilen op SuperRare tussen 28 en 31 januari. De opbrengst van de NFT-verkoop gaat naar een goed doel dat kunstenaars en makers ondersteunt.<br />
<br />
Vanaf 24 januari kunnen fans zich registreren met een digitale portemonnee om NFT's te maken en te slaan door een foto in te sturen met behulp van een filter dat is ontworpen door de digitale kunstenaar Lieberman. Het project zal dan 3.000 medewerkers kiezen die ook IP-rechten hebben op hun individuele NFT's en later die week kunnen deelnemen aan de dropping.<br />
<br />
<strong>Grayscale tapt Bloomberg voor lancering Future of Finance Index temidden van ETF-push</strong><br />
<br />
Grayscale Investments, 's werelds grootste beheerder van crypto-activa, en Bloomberg werken samen om een nieuwe op digitale activa gebaseerde index te lanceren.<br />
<br />
De Bloomberg Grayscale Future of Finance Index (BGFOF) volgt 22 bedrijven die verband houden met verschillende crypto-gerelateerde aandelen en andere bedrijven in de bredere fintech-ruimte, aldus een persverklaring die woensdag werd vrijgegeven.<br />
<br />
De index zal niet rechtstreeks beleggen in digitale activa of hun derivaten, maar zal indirecte blootstelling bieden aan crypto-gerelateerde aandelen. Deze crypto-gerelateerde aandelen worden elk kwartaal opnieuw gebalanceerd en bestrijken marktsegmenten zoals onder meer beurzen, vermogensbeheer, mijnbouw en blockchaintechnologie.<br />
<br />
<strong>E-commerce-reus Mercado Libre investeert in cryptobedrijven Paxos, 2TM</strong><br />
<br />
Latijns-Amerika's grootste e-commercebedrijf naar marktwaarde, heeft geïnvesteerd in 2TM, de holdingmaatschappij voor Brazilië's grootste cryptobeurs Mercado <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>, en blockchaininfrastructuurbedrijf Paxos.<br />
<br />
De relatie tussen Mercado Libre en Paxos is niet nieuw. In december 2021 integreerde de e-commerce gigant de blockchain infrastructuur van Paxos om gebruikers van zijn digitale portemonnee, Mercado Pago, in staat te stellen <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>, ether en de stablecoin Pax dollar (USDP) te kopen en te verkopen in Brazilië, met een minimaal vereist bedrag van 1 Braziliaanse real.<br />
<br />
Mercado <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> haalde in 2021 250 miljoen dollar op en bereikte een waardering van 2,2 miljard dollar. Met een aanwezigheid in Brazilië is het van plan uit te breiden naar Argentinië, Chili, Colombia en Mexico, hetzij organisch, hetzij via overnames.<br />
<br />
<strong>Global Headlines<br />
</strong> <br />
<strong> Irans centrale bank lanceert binnenkort nationale cryptocurrency in een proeffase</strong><br />
<br />
De centrale bank van Iran (CBI) is van plan binnenkort een proeffase voor digitale valuta uit te rollen. Volgens een topambtenaar van de CBI zal de digitale munt het land ten goede komen door financiële inconsistenties te helpen oplossen en decentralisatie te brengen. Iran werkt sinds 2018 aan de digitale munt.<br />
<br />
De digitale munt van de Iraanse Centrale Bank (CBDC) zal de digitale Rial worden genoemd en zal worden gekoppeld aan de Rial, de munteenheid van het land.<br />
<br />
Tot dusver is de CBDC ontwikkeld met behulp van de open-source Hyperledger Fabric technologie, het blockchain raamwerk dat aanvankelijk werd ontwikkeld door IBM en Digital Asset, een in New York gevestigde startup voor de industrie. De Hyperledger Fabric is nu code die wordt gehost door de Linux Foundation, die ook het Hyperledger blockchain consortium leidt.<br />
<br />
<strong>EU moet energie-intensieve manier van cryptomining verbieden, zegt toezichthouder</strong><br />
<br />
Erik Thedéen, vice-voorzitter van de Europese Autoriteit voor effecten en markten, vertelde de Financial Times dat <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> mining een "nationale kwestie" is geworden voor zijn geboorteland Zweden en waarschuwde dat cryptocurrencies een risico vormen voor het halen van de klimaatveranderingsdoelstellingen in de overeenkomst van Parijs.<br />
<br />
<a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> en ether, de twee grootste cryptocurrencies qua volume, vertrouwen beide op een proof of work-model, waarbij alle deelnemers aan het digitale grootboek van de blockchain transacties moeten verifiëren. Miners, die uitgestrekte datacentra vol snelle computers gebruiken om complexe puzzels op te lossen, worden beloond voor het registreren van transacties met nieuw geslagen munten.<br />
<br />
"De oplossing is het verbieden van bewijzen van werk", aldus Thedéen, die ook directeur-generaal is van de Zweedse financiële toezichthouder en voorzitter van duurzame financiering voor het internationale orgaan Iosco. "Proof of stake" heeft een aanzienlijk lager energieprofiel.<br />
<br />
<strong>Indiase premier roept op tot wereldwijde samenwerking inzake cryptocurrency</strong><br />
<br />
Vergelijkt cryptocurrency met verstoringen van de toeleveringsketen, inflatie en klimaatverandering. Modi zei dat "het soort technologie waarmee cryptocurrency wordt geassocieerd, ervoor zorgt dat beslissingen van één land ontoereikend zijn om de uitdagingen van cryptocurrency aan te gaan. We moeten gezamenlijk nadenken."<br />
<br />
De Indiase regering moet haar eigen regelgevingskader voor crypto-activa nog formuleren en heeft al besloten om regelgevingsmaatregelen elders te bestuderen en na te gaan hoe de wereldwijde normen voor cryptocurrencies zich ontwikkelen. Het ministerie van Financiën heeft de Bank voor Internationale Betalingen (BIB) de hand gereikt om zijn wetgeving op te stellen.<br />
<br />
Het wetsontwerp van het land inzake cryptocurrency wordt waarschijnlijk pas wet nadat de begrotingszitting van dit jaar in april is afgelopen. Het wetsvoorstel is naar verluidt geëvolueerd van een verbod op alle particuliere cryptocurrencies terwijl het "bepaalde uitzonderingen toestaat om de onderliggende technologie" te bevorderen, naar het toestaan van het gebruik van cryptocurrency als activa, maar het verbieden van het gebruik ervan als valuta of betaling.<br />
<br />
<strong>Rusland stelt verbod op gebruik en ontginning van cryptocurrencies voor</strong><br />
<br />
De centrale bank van Rusland heeft donderdag voorgesteld het gebruik en de ontginning van cryptocurrencies op Russisch grondgebied te verbieden, onder verwijzing naar bedreigingen voor de financiële stabiliteit, het welzijn van de burgers en de soevereiniteit op het gebied van monetair beleid.<br />
<br />
De maatregel is de laatste in een wereldwijde aanpak van cryptocurrency's, nu regeringen van Azië tot de Verenigde Staten zich zorgen maken dat particulier geëxploiteerde en zeer volatiele digitale valuta hun controle over financiële en monetaire systemen kunnen ondermijnen.<br />
<br />
Rusland is 's werelds derde grootste speler in <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> mining, achter de Verenigde Staten en Kazachstan, hoewel het laatste land mogelijk een uittocht van mijnwerkers zal meemaken uit vrees voor strengere regelgeving na onrust eerder deze maand.<br />
<br />
De centrale bank, die van plan is haar eigen digitale roebel uit te geven, zei dat de verspreiding van crypto-activa de soevereiniteit van het monetaire beleid zou beperken, waarbij hogere rentetarieven nodig zijn om de inflatie te beteugelen.<br />
<br />
<br />
<strong>Gate.io Weekly Blogs:</strong><br />
<a href="https://www.gate.io/blog_detail/448/trend-of-bitcoin" target="_blank"> <span style="color:#337FE5;"> TREND OF BITCOIN</span><br />
</a> <a href="https://www.gate.io/blog_detail/456/defi-1.0-to-3.0-what-is-next" target="_blank"> <span style="color:#337FE5;"> DeFi 1.0 to 3.0 ：What is next？</span><br />
<span style="color:#337FE5;"> </span> </a> <a href="https://www.gate.io/blog_detail/439/-Crypto-Events-Not-to-Miss-in-2022" target="_blank"> <span style="color:#337FE5;"> Crypto Events Not to Miss in 2022</span><br />
</a> <a href="https://www.gate.io/blog_detail/452/what-are-memecoins-and-can-they-make-you-rich" target="_blank"> <span style="color:#337FE5;"> Wat zijn memecoins, en kunnen ze u rijk maken?</span><br />
</a> <a href="https://www.gate.io/blog_detail/451/%E6%88%91%E4%BB%AC%E6%9C%89%E5%8F%AF%E8%83%BD%E7%9F%A5%E9%81%93%E6%AF%94%E7%89%B9%E5%B8%81%E9%B2%B8%E9%B1%BC%E7%9A%84%E8%BA%AB%E4%BB%BD%E5%90%97-" target="_blank"><span style="color:#337FE5;">Houders van BTC walvissen: Is het mogelijk om te weten wie ze zijn?</span><br />
</a> <a href="https://www.gate.io/blog_detail/454/the-gamestop-nft-marketplace-what-is-known-and-why-now" target="_blank"><span style="color:#337FE5;">De Gamestop NFT Marktplaats - Wat is bekend en waarom nu</span><br />
</a> <br />
<br />
Auteur: <strong>Byron. B &amp; Charles. F &amp; Peter. L</strong> (Gate.io Researchers)<br />
* Het artikel geeft alleen de visie van de onderzoeker weer en vormt geen beleggingsadvies.<br />
* Gate.io behoudt zich alle rechten voor op dit artikel. Reposting van het artikel is toegestaan mits verwezen wordt naar Gate.io. In alle andere gevallen zullen gerechtelijke stappen worden ondernomen wegens schending van het auteursrecht.