R2F0ZSBQb2RjYXN0IHwgRXBpYyBHYW1lcyAkMmJuIE1ldGF2ZXJzZSwgRXRoZXJldW0gUG9TIGZ1c2llIGluIGp1bGksIFRlcnJhJ3MgJDE3Nk0gQml0Y29pbiBpbnZlc3RlcmluZw==

<p><a href="https://gimg2.gateimg.com/image/article/16478560300317Solice_en.jpg" rel="nofollow noopener noreferrer" target="_blank"><img src="https://gimg2.gateimg.com/image/article/16478560300317Solice_en.jpg" alt=""></a></p>
<p>Deze aflevering wordt u aangeboden door <a href="https://www.gate.io/" target="_blank">Gate.io </a>en Solice (<a href="https://www.gate.io/article/26081?ch=loa26081twi#giveaway" target="_blank">Airdrop</a>). <a href="/price/terra-luna" target="_blank" class="blog_inner_link">Terra</a> blijft accumuleren en bereikt een totaalbedrag van meer dan 39K aan BTC, met als doel zijn strategie te volgen om een reserve van 10 miljoen <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> op te bouwen; <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> PoS Test gaf vrij goede resultaten en de samenvoeging lijkt nog meer te naderen; Epic Games, het softwarehuis van Fortnite, bereikte een samenwerking met Sony en KIRKBI om toe te treden tot de metaverse. Gevolgd door een Deep Dive in Meta’s plannen om het bedrijf nieuw leven in te blazen door het creëren van een eigen cryptocurrency: de Zuck Bucks.</p>
<hr>
<h3 id="h3-In20de20Headlines20van20vandaag803202"><a name="In de Headlines van vandaag:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>In de Headlines van vandaag:</h3><p>Terra’s <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Koopgolf &amp; Kromme oorlog met MakerDAO | <a href="https://www.coinspeaker.com/terra-[Bitcoin](https://www.gate.io/trade/BTC_USDT" target="_blank">1</a> | <a href="https://decrypt.co/97286/terras-new-stablecoin-pool-makes-waves-in-defi" rel="nofollow noopener noreferrer" target="_blank">2</a> | <a href="https://agora.terra.money/t/ust-goes-interchain-the-4pool-and-redacted-cartel/5648" rel="nofollow noopener noreferrer" target="_blank">3</a>. “3”) |</p>
<p>CME voegt referentiekoersen toe voor Solana, Cardano, <a href="/price/polygon-matic" target="_blank" class="blog_inner_link">Polygon</a> en andere Altcoins | <a href="https://decrypt.co/97328/cme-reference-rates-indices-solana-cardano-polygon-altcoins" rel="nofollow noopener noreferrer" target="_blank">1</a> | <a href="https://news.[Bitcoin](https://www.gate.io/trade/BTC_USDT" target="_blank">2</a> |</p>
<p>HSBC start metaversiefonds voor private banking-klanten in Azië | <a href="https://www.coindesk.com/business/2022/04/06/hsbc-starts-metaverse-fund-for-private-banking-clients-in-asia/" rel="nofollow noopener noreferrer" target="_blank">1</a> | <a href="https://www.reuters.com/technology/hsbc-launches-metaverse-portfolio-wealthy-asian-clients-2022-04-06/" rel="nofollow noopener noreferrer" target="_blank">2</a> |</p>
<p>Ethereum PoS Test voorspelt dat de samenvoeging in juli zal plaatsvinden | <a href="http://https://fortune.com/2022/04/11/ethereum-test-merge-blockchain/" rel="nofollow noopener noreferrer" target="_blank">1</a> |</p>
<p>Epic Games investeert 2 miljard dollar in de Metaverse. “ “)1 | <a href="https://decrypt.co/97484/epic-games-2b-raise-metaverse-crypto-nfts-blockchain" rel="nofollow noopener noreferrer" target="_blank">2</a> | <a href="https://www.ft.com/content/24d4378a-6977-4ed8-be63-23c9bf9df366" rel="nofollow noopener noreferrer" target="_blank">3</a> |</p>
<p>Sponsor: Solice (<a href="https://www.gate.io/article/26081?ch=loa26081twi#giveaway" target="_blank">Airdrop</a>)</p>
<p>Deep Dive: Kan Crypto de inkomstendaling van Meta redden? | <a href="https://finance.yahoo.com/news/zuck-bucks-latest-digital-currency-063358181.html?guccounter=1&amp;guce_referrer=aHR0cHM6Ly93d3cucmVkZGl0LmNvbS8&amp;guce_referrer_sig=AQAAAJIIde9HNNH0by82J3H-_TzKdMBsEW0COBeAZvyNqKqjeMhPeqDSZtQqnuFE3rZWxzPyLORoVIAlbDpQJg5o837Myf37uEx_kx7eX_bF2vpg0IA6o08ZpqEIJEgZ8-cnuiYC-ifWDJ8V3UxxXQMzbGmiGd3SHhjESlHR1w_AwI8t" rel="nofollow noopener noreferrer" target="_blank">1</a> | <a href="https://www.theguardian.com/technology/2022/apr/07/meta-plans-zuck-bucks-virtual-coins-for-facebook-and-instagram-users" rel="nofollow noopener noreferrer" target="_blank">2</a> | <a href="https://www.theguardian.com/technology/2022/apr/07/meta-plans-zuck-bucks-virtual-coins-for-facebook-and-instagram-users" rel="nofollow noopener noreferrer" target="_blank">3</a> | <a href="https://www.washingtonpost.com/technology/2022/01/28/facebook-cryptocurrency-diem/" rel="nofollow noopener noreferrer" target="_blank">4</a> |</p>
<p>Luister naar de aflevering: <a href="https://www.gate.io/podcast/21" rel="nofollow noopener noreferrer" target="_blank">https://www.gate.io/podcast/21</a><br>                             <a href="https://gateio.buzzsprout.com/1825729/10428692-epic-games-2bn-metaverse-ethereum-pos-merge-in-july-terra-s-176m-" rel="nofollow noopener noreferrer" target="_blank">https://gateio.buzzsprout.com/1825729/10428692-epic-games-2bn-metaverse-ethereum-pos-merge-in-july-terra-s-176m-</a><a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>-investering</p>
<h3 id="h3-Introduction794500"><a name="Introduction:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduction:</h3><p>Welcome back to the Altcoin News Podcasts, this is the show to get a neutral perspective on some of the latest headlines in DeFi, Metaverse, NFTs, and Big Tech. Brought to you by Gate.io, a centralized exchange with a neutral stance on current events and uphold privacy &amp; security.</p>
<p>The information presented in this podcast is to help you stay up-to-date on the latest happening in the crypto space, and nothing presented hereby is financial advice. The news that I cover in this podcast will have the original source at your discretion. Stick by this podcast as I show you how to stay vigilant and learn to do your own research.</p>
<p>Now, without further ado.</p>
<h3 id="h3-Terras202020Bitcoin2020Koopgolf20amp20Kromme20oorlog20met20MakerDAO20202020120202020202202020202032020320532238"><a name="Terra’s   Bitcoin  Koopgolf &amp; Kromme oorlog met MakerDAO |   1  |   2  |   3 . “3”) |" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Terra’s <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Koopgolf &amp; Kromme oorlog met MakerDAO | <a href="https://www.coinspeaker.com/terra-[Bitcoin](https://www.gate.io/trade/BTC_USDT" target="_blank">1</a> | <a href="https://decrypt.co/97286/terras-new-stablecoin-pool-makes-waves-in-defi" rel="nofollow noopener noreferrer" target="_blank">2</a> | <a href="https://agora.terra.money/t/ust-goes-interchain-the-4pool-and-redacted-cartel/5648" rel="nofollow noopener noreferrer" target="_blank">3</a>. “3”) |</h3><p>LFG, oftewel de Lunar Foundation Guard heeft zojuist nog eens $176 miljoen aan <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin] buitgemaakt(https://www.gate.io/trade/BTC_USDT). eerder deze zondag. Dit gebeurt als de [BTC-prijs</a> blijft onder druk staan en gleed tijdens het weekend onder het niveau van $42.000.</p>
<p>Vorige week heeft Terraform Labs voor $ 100 miljoen <a href="/price/avalanche-avax" target="_blank" class="blog_inner_link">Avalanche</a> (AVAX) gekocht om zijn reserves te diversifiëren. Terraform Labs oprichter Do Kwon zei dat de reden om te kiezen voor avalanche is vanwege de snelle groei en bredere fanbase.</p>
<p>Als gevolg van deze verhuizing zullen verschillende toepassingen die op Terra worden gelanceerd in de toekomst ook beschikbaar zijn op Avalanche. Bovendien zullen Avalanche-gebruikers UST kunnen verhandelen tegen de AVAX-tokens, rechtstreeks op de Avalanche-blockchain.</p>
<p>Terra heeft in totaal 39.897,98 [Bitcoin] verzameld (<a href="https://www.gate.io/trade/BTC_USDT" rel="nofollow noopener noreferrer" target="_blank">https://www.gate.io/trade/BTC_USDT</a>) ter waarde van $1,7 miljard in de afgelopen maand als onderdeel van haar strategie om een BTC-reserve van $10 miljard op te bouwen voor haar UST stablecoin.</p>
<p>Op 1 april introduceerde Terra iets dat de “4pool” wordt genoemd in wat een duidelijke zet lijkt om UST en een andere snelgroeiende algoritmische stablecoin genaamd <a href="/price/frax-frax" target="_blank" class="blog_inner_link">FRAX</a> de leidende spelers in deze niche te maken.</p>
<p>Dit wordt door sommige liefhebbers van DeFi “Curve War” genoemd, aangezien Curve Finance een slagveld is geworden voor welk project de diepste liquiditeit kan verschaffen aan zijn respectieve pool. De prijs voor de diepste liquiditeit is natuurlijk de tokenbeloning.</p>
<p>Voor stablecoins is Curve vooral belangrijk omdat het ook de diepe liquiditeit biedt die nodig is voor het handhaven van de dollarkoppeling van een token. stablecoins met een lage liquiditeit kunnen gemakkelijk worden verstoord als een walvis besluit een enorme hoeveelheid van het token te kopen of te verkopen.</p>
<p>Momenteel heet de grootste stablecoin-pool “3pool”. Het biedt superdiepe liquiditeit voor USDC, USDT en DAI. Diepe liquiditeit betekent in dit g 3,2 miljard dollar.</p>
<p>Terra’s binnenkort te lanceren 4pool is zeer vergelijkbaar en omvat UST, FRAX, USDT en USDC. En om mensen aan te trekken, zullen ze ook proberen die tokenbeloningen op Curve maximaal te benutten.</p>
<p>Door DAI te elimineren en te proberen de totale beloning voor degenen die liquiditeit verschaffen aan de nieuwe pool te maximaliseren, zullen fondsen die hadden kunnen bijdragen aan de diepte van 3pool niet aankomen, waardoor DAI mogelijk wordt verstoord.</p>
<p>De vraag is nu hoe MakerDAO zal reageren.</p>
<h3 id="h3-CME20Adds20Reference20Rates20for20Solana20Cardano20Polygon20and20Other20Altcoins202020201202020202022020203145"><a name="CME Adds Reference Rates for Solana, Cardano, Polygon and Other Altcoins |   1  |   2  |" class="reference-link"></a><span class="header-link octicon octicon-link"></span>CME Adds Reference Rates for Solana, Cardano, Polygon and Other Altcoins | <a href="https://decrypt.co/97328/cme-reference-rates-indices-solana-cardano-polygon-altcoins" rel="nofollow noopener noreferrer" target="_blank">1</a> | <a href="https://news.[Bitcoin](https://www.gate.io/trade/BTC_USDT" target="_blank">2</a> |</h3><p>CME Group is adding 11 more cryptocurrencies to the firm’s existing <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> and ethereum reference rates. Crypto reference rates like the CME CF Reference Rates are often used as a benchmark for exchange-traded funds (ETFs) and other financial products.</p>
<p>The new reference rates will include index pricing for <a href="/price/algorand-algo" target="_blank" class="blog_inner_link">Algorand</a> (ALGO), <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Cash (BCH), Cardano, Chainlink (LINK), Cosmos (ATOM), <a href="https://www.gate.io/trade/LTC_USDT" target="_blank">Litecoin</a> (LTC), Polkadot, Polygon (MATIC), Solana, <a href="/price/stellar-xlm" target="_blank" class="blog_inner_link">Stellar</a> Lumens (XLM) and <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> (UNI). Each coin will leverage two exchanges, CME Group’s announcement discloses.</p>
<p>The reference rates and indices themselves are not tradable investment products. As the name suggests, a reference rate is price data for an asset. But having that data available is an important prerequisite for offering products like ETFs and futures contracts.</p>
<p>Tim McCourt, CME’s head of equity and FX products, said in a press release: “These new benchmarks, which capture 90% of the total investable <a href="/price" target="_blank" class="blog_inner_link">cryptocurrency market</a> cap today, are designed to allow traders, institutions and other users to confidently and more accurately manage cryptocurrency price risk, price portfolios or create structured products like ETFs.”</p>
<p>Right now, CME offers <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> and <a href="https://www.gate.io/futures_trade/USDT/ETH_USDT" target="_blank">Ethereum futures</a>, as well as futures contracts for micro <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> and micro Ethereum, which can be purchased in denominations one-tenth the size of one BTC or ETH.</p>
<h3 id="h3-HSBC20start20Metaverse20Fonds20voor20Private20Banking20klanten20in20Azi202020201202020202022020688634"><a name="HSBC start Metaverse Fonds voor Private Banking klanten in Azië |   1  |   2  |" class="reference-link"></a><span class="header-link octicon octicon-link"></span>HSBC start Metaverse Fonds voor Private Banking klanten in Azië | <a href="https://www.coindesk.com/business/2022/04/06/hsbc-starts-metaverse-fund-for-private-banking-clients-in-asia/" rel="nofollow noopener noreferrer" target="_blank">1</a> | <a href="https://www.reuters.com/technology/hsbc-launches-metaverse-portfolio-wealthy-asian-clients-2022-04-06/" rel="nofollow noopener noreferrer" target="_blank">2</a> |</h3><p>HSBC Holdings heeft een fonds gelanceerd om beleggingsmogelijkheden in de metaverse te benutten voor haar rijke klanten in Hongkong en Singapore nu financiële dienstverleners de nieuwe virtuele realiteit van Silicon Valley aanboren.</p>
<p>De strategie is gericht op het benutten van groeikansen die wereldwijd voortvloeien uit de ontwikkeling van het metaverse ecosysteem in het komende decennium, aldus de bank in een verklaring, waaraan zij toevoegt dat de “metaverse naar verwachting de volgende iteratie van het internet zal worden”.</p>
<p>De metaverse bestaat uit een netwerk van virtuele omgevingen die via verschillende apparaten toegankelijk zijn en waar gebruikers kunnen werken, socialiseren en spelen. Het is duidelijker in beeld gekomen sinds Facebook (FB.O) vorig jaar zijn naam veranderde in Meta om zijn inzet voor de sector weer te geven.</p>
<p>In maart zei HSBC dat het de eerste wereldwijde bank was die The Sandbox-metaverse betrad, toen het een stuk grond kocht om zich in te laten met sport-, e-sport- en gamefans. De totale markt voor de metaverse economie zou tegen 2030 wel eens 13 biljoen dollar kunnen bedragen, aldus Citi in een rapport van vorige week.</p>
<p>De portefeuille zal actief worden beheerd, met een focus op vijf kerngebieden: infrastructuur, informatica, virtualisatie, ervaring en ontdekking, en menselijke interface, aldus de bank.</p>
<p>De strategie zal exclusief zijn voor de vermogende en zeer vermogende professionele klanten en geaccrediteerde beleggers van HSBC in Azië. Het zal worden beheerd door HSBC Asset Management.</p>
<h3 id="h3-Ethereum20PoS20Test20Predicts20The20Merge20To20Occur20In20July2020202012020419315"><a name="Ethereum PoS Test Predicts The Merge To Occur In July |   1  |" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ethereum PoS Test Predicts The Merge To Occur In July | <a href="http://https://fortune.com/2022/04/11/ethereum-test-merge-blockchain/" rel="nofollow noopener noreferrer" target="_blank">1</a> |</h3><p>Ethereum’s main problem is transaction cost. When the network starts to be overused, then the price’s fees increase and that creates a notable problem for all the users.</p>
<p>Ethereum developers, in order to solve this problem, have promised a major update that would drastically decrease the amount of energy required for confirming transactions, making the blockchain more eco-friendly.</p>
<p>Currently, the network relies on the PoW (Proof-Of-Work) technology, which means that validators need to solve mathematical puzzles, an activity that requires a lot of energy, before confirming a transaction. The process causes a huge energy expenditure that causes a notable environmental impact.</p>
<p>The upgrade would grant Ethereum a switch to the PoS (Proof-Of-Stake) chain, which should minimize the fees and decrease the amount of energy required for validating a transaction. Under the PoS chain, validators would be able to confirm transactions based on how many Ether they stake or contribute to the network, making the PoW obsolete.</p>
<p>In order to rapidly switch to the new chain, Ethereum developers ran on Monday a test which gave pretty good results with a few minor issues. They launched a small number of validators in order to analyze their behavior during the entire process until the final merge.</p>
<p>Given the fact that the test worked properly, the dev team decided to run it again on April 22 and, in the meantime, to launch small tests to understand what should be improved. The merge is the update that Ethereum supporters are more excited about, considering the fact that all the projects built on the network would experience a huge improvement and it’s also expected to increase institutional investments.</p>
<p>Tim Beiko, Ethereum Developer, predicts that the merge will occur in July, even if there isn’t a deadline yet, which will probably be set after the test that is going to run almost at the end of April.</p>
<h3 id="h3-Epic20Games20220Miljard20Metaverse20Investering2020202020120202020220202020203202019042"><a name="Epic Games $2 Miljard Metaverse Investering |    1 |   2  |   3  |" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Epic Games $2 Miljard Metaverse Investering |<a href="https://www.epicgames.com/site/en-US/news/sony-and-kirkbi-invest-in-epic-games-to-build-the-future-of-digital-entertainment" rel="nofollow noopener noreferrer" target="_blank"> </a>1 | <a href="https://decrypt.co/97484/epic-games-2b-raise-metaverse-crypto-nfts-blockchain" rel="nofollow noopener noreferrer" target="_blank">2</a> | <a href="https://www.ft.com/content/24d4378a-6977-4ed8-be63-23c9bf9df366" rel="nofollow noopener noreferrer" target="_blank">3</a> |</h3><p>Epic Games, het bekende gamebedrijf achter Gears of War, Fortnite &amp; Unreal Engine, heeft aangekondigd zich aan te sluiten bij de Metaverse. Het besluit gaat gepaard met een overeenkomst van 2 miljard dollar tussen bestaande investeerders Sony Group Corporation en KIRKBI, de familie-holding achter The LEGO Group.</p>
<p>Elke partij heeft bijgedragen met respectievelijk 1 miljard dollar en als gevolg van de overeenkomst heeft het Japanse bedrijf momenteel een belang van 4,9% en KIRKBI 3% van het bedrijf, een deal die Epic Games waardeert op 31,5 miljard dollar.</p>
<p>KIRKBI heeft besloten samen te werken met Epic Games om een wereld met LEGO-thema te bouwen die vooral gericht is op kinderen, terwijl de visie van Sony veel meer gericht is op de gamersgemeenschap.</p>
<p>Ook al hebben ze een gemeenschappelijk doel, hun ambitie is om zowel gamers als makers nieuwe manieren van virtueel entertainment te bieden en een ruimte te creëren waar mensen met elkaar kunnen communiceren en hun tijd samen kunnen doorbrengen, zoals Kenichiro Yoshida, CEO en president van Sony, verklaarde.</p>
<p>Alle drie de bedrijven zijn ervan overtuigd dat Epic opnieuw een uitstekend product kan aanbieden, gebouwd met de Unreal Engine en ondersteund door de technologieën van Sony, dat op gelijke voet staat met Fortnite, een battle royale-spel met meer dan 30 miljoen geregistreerde spelers.</p>
<p>Dat Epic Games een Metaverse wil bouwen, blijkt uit het succes van het concert van Travis Scott dat alle Fortnite-spelers een digitaal evenement bood dat door meer dan 12 miljoen gebruikers werd bekeken. Een record dat het vorige record van het muziekevenement van Marshmello overtrof.</p>
<p>Deze evenementen die het spelbedrijf aan zijn gebruikers heeft aangeboden, kunnen worden beschouwd als een eerste inzicht in wat er kan gebeuren in de metaverse: een ruimte waar mensen unieke momenten kunnen delen en toegang hebben tot exclusieve functies die de huidige technologie niet kan bieden.</p>
<p>Het is nog onduidelijk welke rol cryptocurrencies en NFT’s gaan spelen in de Metaverse van Epic Games en of het ze gaat opnemen in een microtransactiedienst of niet. Toch heeft het bedrijf al verklaard dat het openstaat voor de nieuwe technologieën en dat het ervan overtuigd is dat de metaverse het potentieel heeft om een miljardenindustrie te worden die niet in handen zou moeten zijn van één enkel bedrijf, maar eerder een open ruimte waarin bedrijven kunnen samenwerken.</p>
<hr>
<h3 id="h3-Sponsor2020Solice162496"><a name="Sponsor | Solice" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sponsor | Solice</h3><p>Before I continue with today’s deep dives, I must tell you about today’s sponsor, Solice, a VR Metaverse built on the <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> blockchain, striving to deliver a high-quality immersive experience by providing users an environment where users can play, build, own, socialize and monetize their virtual experiences across multiple platforms.</p>
<p>While the Solice community has been in chaos for weeks brought by its first and highly anticipated land sale, the team announced at the beginning of this month that the soft launch would initiate shortly after the land sale ended.</p>
<p>Solice first introduced soft launch in December, 2021, when they successfully closed $4.36 million in a seed and private sale led by Three Arrows Capital, Animoca Brands and Defiance Capital. The Solice Metaverse will have its soft launch (limited spots) for early adopters to play and enjoy the metaverse. The first version of the soft launch will include VR compatibility giving users the immersive metaverse experience.</p>
<p>Solice provides an infrastructure to support the metaverse. The Solice metaverse supports multiple platforms that remove the barrier of different hardware, software, and operating s. This allows more users to invite and connect with their friends and family to increase the possibilities for exponential growth of the user base.</p>
<p>Solice is such a comprehensive and ambitious metaverse project with a huge pool of target users, from gamers (P2E aspect), to DeFi users (staking), to businesses (buy or build and then rent out ad spaces) which forms great adoption for Solice metaverse as a whole.</p>
<p>Will you be the next user of Solice? Get started with the Gate.io podcast airdrop. 75 winners will share 1,500 SLC tokens from Apr 14 to Apr 21. Stay tuned!</p>
<hr>
<h3 id="h3-DD2020Kan20Crypto20de20inkomstendaling20van20Meta20redden2020202012020202020220202020203202020202042020472998"><a name="DD | Kan Crypto de inkomstendaling van Meta redden? |   1  |   2  |   3  |   4  |" class="reference-link"></a><span class="header-link octicon octicon-link"></span>DD | Kan Crypto de inkomstendaling van Meta redden? | <a href="https://finance.yahoo.com/news/zuck-bucks-latest-digital-currency-063358181.html?guccounter=1&amp;guce_referrer=aHR0cHM6Ly93d3cucmVkZGl0LmNvbS8&amp;guce_referrer_sig=AQAAAJIIde9HNNH0by82J3H-_TzKdMBsEW0COBeAZvyNqKqjeMhPeqDSZtQqnuFE3rZWxzPyLORoVIAlbDpQJg5o837Myf37uEx_kx7eX_bF2vpg0IA6o08ZpqEIJEgZ8-cnuiYC-ifWDJ8V3UxxXQMzbGmiGd3SHhjESlHR1w_AwI8t" rel="nofollow noopener noreferrer" target="_blank">1</a> | <a href="https://www.theguardian.com/technology/2022/apr/07/meta-plans-zuck-bucks-virtual-coins-for-facebook-and-instagram-users" rel="nofollow noopener noreferrer" target="_blank">2</a> | <a href="https://www.theguardian.com/technology/2022/apr/07/meta-plans-zuck-bucks-virtual-coins-for-facebook-and-instagram-users" rel="nofollow noopener noreferrer" target="_blank">3</a> | <a href="https://www.washingtonpost.com/technology/2022/01/28/facebook-cryptocurrency-diem/" rel="nofollow noopener noreferrer" target="_blank">4</a> |</h3><p>De inkomsten van Meta beven.<br>Naarmate de sociale mediaruimte zich verder ontwikkelt in de richting van nieuwe vormen van digitale aanpak, neemt de concurrentie toe en zien kolossen als Facebook hun inkomsten dalen.</p>
<p>Facebook heeft zijn gemeenschap nog geen nieuwe diensten aangeboden of zich aangepast aan de behoeften van de gebruikers; en dit veroorzaakte een groot verlies van zowel de geloofwaardigheid van het bedrijf als de financiële inzendingen. Velen zijn hun sociale activiteit gaan verleggen naar andere platforms zoals TikTok en daarom is Zuckerberg gaan kijken naar nieuwe inkomstenmogelijkheden. Momenteel is de winst van Facebook voornamelijk gebaseerd op advertenties: volgens The Guardian verdiende het sociale mediaplatform in 2021 118 miljard dollar dankzij de enorme gemeenschap van zowel Facebook als Instagram, die momenteel samen goed zijn voor ongeveer 4,9 miljard actieve gebruikers.</p>
<p>Crypto kan Meta’s volgende winstbron zijn.<br>Zuckerberg wil de inkomsten van Meta minder afhankelijk maken van advertentiebronnen, daarom is hij begonnen met het onderzoeken van nieuwe methoden om zijn gemeenschap te gelde te maken. Een daarvan is de adoptie van cryptocurrency, een strategie die het bestuur van Meta al een paar jaar omarmt, maar die nog niet echt is geconcretiseerd.</p>
<p>In-platform betaalmethode is geen nieuw soort dienst die Zuckerberg wil ontwikkelen. In feite lanceerde hij al in 2009 op zijn sociale mediaplatform de Facebook Credits, een virtuele betaalmethode voor het kopen van games, apps enzovoort. Helaas werd het project na vier jaar stopgezet omdat het de toenemende vraag en de hoge kosten voor het omrekenen van vreemde valuta niet aankon. Maar daar hield de droom niet op.</p>
<p>Zuck Bucks: Meta’s virtuele valuta.<br>In 2019 probeerde Meta een eigen digitale munt te ontwikkelen met de naam Libra, maar het project mislukte omdat het op grote weerstand stuitte van Washington en andere financiële instellingen die het idee van de stablecoin als een bedreiging voor de consumentenbescherming en potentiële financiële risico’s beschouwden. De tegenstand hield Zuckerberg echter niet tegen en twee jaar later veranderde hij zijn project in Diem door het Congres te verzekeren dat de token werd gekoppeld aan de Amerikaanse dollar om grote stabiliteit te bieden.</p>
<p>Toch is de CEO van Meta nog niet klaar om op te geven, en onlangs hebben geruchten aangekondigd dat er een nieuw cryptocurrency-project in ontwikkeling is dat, volgens wat Zuckerberg heeft verklaard, niet zal worden gebouwd op de blockchain-technologie, maar eerder rechtstreeks zal worden gekoppeld aan het beheer van het bedrijf. Een initiatief dat vergelijkbaar is met de eigen valuta, Robux genaamd, die Roblox Corporation in zijn populaire onlinespel heeft ingevoerd.</p>
<p>De betrokkenheid van Meta in de cryptoruimte lijkt zich snel te verspreiden; het bedrijf richt zijn inspanningen op de integratie van NFT’s op Facebook en Instagram, een stap die zelfs Twitter al heeft omarmd. Het bedrijf van Zuckerberg droomt echter groter: het hoofddoel is een eigen Metaverse te bouwen waar mensen een digitaal leven kunnen leiden dat wordt gekenmerkt door dagelijkse activiteiten, virtuele communicatie en een nieuwe aankoopmethode die wordt gekenmerkt door de eigen munt die het bedrijf wil ontwikkelen: de Zuck Bucks. Meta lijkt blockchaintechnologie en cryptocurrencies te beschouwen als mogelijkheden om zijn inkomsten te verbeteren.</p>
<p>De Blockchain-technologie schrikt beleggers van Meta af.<br>Zelfs als het bedrijf zich richt op digitale tokens, zijn veel beleggers nog sceptisch over het project. Op 2 februari, nadat Meta onthulde dat haar uitgaven voor het bouwen van de Metaverse hadden geleid tot een enorme daling van de winst in het vierde kwartaal, verkochten veel durfkapitalisten hun aandelen en daalde de koers van het bedrijf met 30% sinds het begin van het jaar, met een verlies van meer dan 220 miljard dollar.</p>
<p>Crypto wordt mainstream en dat is de reden voor Meta’s betrokkenheid bij de ruimte. Het bedrijf gelooft dat het aanbieden van blockchaintechnologie aan zijn gebruikers hen kan overtuigen om zijn diensten te blijven gebruiken en zijn positie onder de meest trending sociale mediaplatforms te consolideren. Volgens PewResearch heeft 16% van de Amerikanen gezegd dat zij hebben geïnvesteerd en gehandeld in cryptocurrency, een aantal dat wereldwijd nog toeneemt.</p>
<p>De plannen van Meta houden niet op bij de ontwikkeling van de gecentraliseerde munt Zuck Bucks, in feite is de visie van het bedrijf gericht op nog meer betaalmethoden. Volgens bedrijfsmemo’s wil Meta’s ook “social tokens” en “reputation tokens” introduceren, die worden uitgedeeld aan gebruikers als beloning voor hun betrokkenheid en leendiensten voor kleine bedrijfsactiviteiten.</p>
<p>Ondanks interne spanningen blijft het bedrijf zijn plannen volgen, met als doel een van de eerste techbedrijven te zijn die de nieuwe techruimte omarmt, vooruitlopend op strategische stappen die concurrenten als Apple en Google mogelijk van plan zijn te nemen. Meta wil zich omvormen tot een bedrijf dat niet langer het dagelijkse leven van zijn gemeenschap controleert, maar wil de gemeenschap meer macht en moderatierechten bieden.</p>
<p>Beluister de aflevering:<br>Epic Games $2bn Metaverse, Ethereum PoS samenvoegen in juli, Terra’s $176M <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Investering</p>