RGFnZWxpamtzIG5pZXV3cyB8IE1hc3RlckNhcmQga2FuIGRlIGFhbmtvb3AgdmFuIE5GVCdzIG9wIEV0aGVyZXVtIG9uZGVyc3RldW5lbiwgUG9sa2Fkb3Qgb250a2VudCBvbnRzbGFnZW4sIENQSS1nZWdldmVucyBvdmVydHJlZmZlbiB2ZXJ3YWNodGluZ2Vu

2023-10-13, 04:45

<p><img src="https://gimg2.gateimg.com/image/article/16971784901013.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20MasterCard20overweegt20ondersteuning20voor20het20kopen20van20NFTs20op20Ethereum20Polkadot20ontkent20ontslagen788220"><a name="Crypto Dagelijkse Samenvatting: MasterCard overweegt ondersteuning voor het kopen van NFT’s op Ethereum; Polkadot ontkent ontslagen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: MasterCard overweegt ondersteuning voor het kopen van NFT’s op Ethereum; <a href="/price/polkadot-dot" target="_blank" class="blog_inner_link">Polkadot</a> ontkent ontslagen</h2><p>Betalingsgigant MasterCard heeft aangekondigd dat het met succes nieuwe functionele oplossingen heeft gedemonstreerd die tokenisatie (of wrapped beacon) van Central Bank Digital Currency (CBDC) op verschillende ketens kunnen ondersteunen, waardoor consumenten meer betalingsopties krijgen. Deze oplossing is ontwikkeld in samenwerking met Cuscal en Mintable als onderdeel van het RBA- en DFCRC-onderzoeksproject, met als doel mogelijke use-cases voor CBDC in Australië te onderzoeken.</p>
<p>In een verificatieomgeving ter plaatse demonstreerde MasterCard hoe de oplossing het mogelijk maakt dat houders van pilot CBDC’s NFT’s kunnen kopen op de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> keten, ‘vergrendel’ het vereiste aantal proefcentrale bank digitale valuta op het pilot CBDC-platform van de Bank of Australia en sla een gelijk aantal proef CBDC verpakte baken tokens op <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> op voordat de transactie wordt voltooid.</p>
<p>Gisteren, volgens The Block, Parity Technologies, een <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> De organisatie voor ecosysteemontwikkeling ontkende geruchten over ontslagen van meer dan 300 werknemers deze week. Het is echter van plan om sommige van zijn bestaande functies over te dragen aan meerdere teams binnen het gedecentraliseerde ecosysteem van Polkadot, wat inderdaad van invloed zal zijn op de personeelsbezetting van het bedrijf. Toch zullen eventuele personeelswijzigingen die verband houden met de overgang van decentralisatie naar diverse financieringsentiteiten binnen het ecosysteem zich binnen enkele maanden voordoen.</p>
<p>Bigtime heeft zijn kortetermijnniveau van gekke FOMO na de FOMO van gisteren. Iedereen moet voorzichtig zijn, of het nu in het veld Game is of op andere velden, zolang er games of applicaties met Fi zijn, hebben ze nauwkeurig gesproken de X2E-modus. Dit type kan alleen worden gebruikt als afleidingsmiddel en niet als doel. Als het als doel wordt gebruikt, zal het uiteindelijk terugkeren naar nul.</p>
<p>Ongetwijfeld gaat het tegen de basisorde en wetten van de economie in, omdat het onhoudbaar is. Daarom zag ik dat na het bereiken van 0,3 gisteren volgens FDV-berekening, de marktwaarde van Bigtime $1,5 miljard heeft bereikt, wat over het algemeen te riskant is. Daarom heb ik een waarschuwing gegeven.</p>
<p>Het X2E-model is onhaalbaar gebleken, tenminste niet als het ultieme doel van het product. Wat we ook doen, we moeten nog steeds terugkeren naar het product zelf. Bijvoorbeeld, in games, moeten we nog steeds goed werk leveren in het spel. Op basis van de speelbaarheid van het spel zelf moeten we gebruikers wat E teruggeven, wat haalbaar is. Behalve de eerste keer, is het gewoon een zwevende wolk.</p>
<p>Volgens de monitoring van Scopescan ontving Curve-oprichter Michael Egorov 11,85 miljoen CRV’s (ongeveer $5,08 miljoen) van het token unlock-contract. Volgens het ontgrendelingsschema kan Michael Egorov 548.600 CRV’s per dag ontvangen (ongeveer $235.000) en 16,7 miljoen CRV’s per maand (ongeveer $7,16 miljoen).</p>
<p>Investeringsinstelling Arca heeft een voorstel ingediend om de Blur transactiekosten te bespreken, die de basis transactiekosten met 1% zullen verhogen voor het Blur marktprotocol. Het wordt aanbevolen om deze kosten te gebruiken voor dagelijkse atische terugkoop en vernietiging van BLUR. Daarnaast heeft Arca een gelaagde tariefstructuur voorgesteld om korting op de kosten te bieden voor gebruikers die BLUR bezitten.</p>
<h2 id="h2-Belangrijkste20trends20van20vandaag20in20tokens827475"><a name="Belangrijkste trends van vandaag in tokens" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijkste trends van vandaag in tokens</h2><h3 id="h3-BTC211195"><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/1697178519BTC.png" alt=""><br>Deze week is het doel van $26.510 voor de daling bereikt. Op korte termijn kan er een kleine opleving plaatsvinden richting het weekend, met een oplevingsdoel van $26.975. De middellangetermijnsteun blijft staan op $26.510 en de neerwaartse trendlijn. Zolang deze niet wordt doorbroken, blijft het bullish perspectief gehandhaafd, met aanhoudende druk op het weerstandsniveau van $28.000.</p>
<h3 id="h3-ETH327137"><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/1697178540ETH.png" alt=""><br>De middellangetermijnstructuur blijft een downtrend tonen. Het aanbevolen instappunt voor de shortpositie bij $1.631 is consequent winstgevend geweest en het maximale doel voor de daling zal $1.465 zijn. Korte termijn handel kan een geleidelijke stijging laten zien en korte termijn winsten kunnen worden gerealiseerd, terwijl langetermijn strategieën kunnen worden aangehouden.</p>
<h3 id="h3-GROOTTIJD453508"><a name="GROOTTIJD" class="reference-link"></a><span class="header-link octicon octicon-link"></span>GROOTTIJD</h3><p><img src="https://gimg2.gateimg.com/image/article/1697178557BIGTIME.png" alt=""><br>Deze week werden posities ingesteld op twee prijsniveaus: $0,07140 en $0,09350. De hoogste afsluiting in de afgelopen drie dagen was $0,3450, met een maximale stijging van 384%. Op korte termijn kan een langere correctieperiode worden verwacht. Een 15-minuten grafiek kan worden gebruikt als verdedigingslijn langs de stijgende trend. De dagelijkse grafiek kan snel dalen naar een sterk ondersteuningsniveau op $0,146. Als de stijgende trend zich voortzet, bestaat de mogelijkheid om de uiteindelijke doelniveaus te bereiken: $0,4409, $0,5712, $0,7049, en het hoogste doel van $1,0875 en $1,17.</p>
<h2 id="h2-Macro20CPIgegevens20overtreffen20verwachtingen20timing20van20renteverlagingen20is20van20cruciaal20belang718547"><a name="Macro: CPI-gegevens overtreffen verwachtingen, timing van renteverlagingen is van cruciaal belang" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: CPI-gegevens overtreffen verwachtingen, timing van renteverlagingen is van cruciaal belang</h2><p>Gisteravond heeft de Verenigde Staten CPI-gegevens vrijgegeven, die de marktverwachtingen qua cijfers hebben overtroffen. De kwartaal CPI-jaarlijkse rente die in september werd geregistreerd, bedroeg 3,7%, de vorige waarde was 3,7% en de voorspelling was 3,6%.</p>
<p>Vanuit het perspectief van de jaarlijkse kern-CPI is er echter een lichte daling geweest. Het aangekondigde percentage is 4,1%, de vorige waarde is 4,3% en de voorspelling is 4,1%. Deze gegevens voldoen nog steeds aan de verwachtingen van de markt. Deze gegevens kunnen niet als slecht of goed worden bestempeld, en een onverwachte opleving kan ook de voortdurende renteverhogingen van de Federal Reserve in het jaar versterken.</p>
<p>Naast de onverwachte stijging van de rendementen op Amerikaanse staatsobligaties als gevolg van de CPI, leidde ook de bijzonder sombere veilingresultaten van het rendement van de 30-jarige Amerikaanse staatsobligatie die door het Amerikaanse ministerie van Financiën in de Amerikaanse handel werden aangekondigd tot een snelle stijging. Het rendement op de Amerikaanse 10-jarige obligatie steeg op een gegeven moment met meer dan 20 basispunten en sloot bijna op 4,7%; het rendement op de Amerikaanse 2-jarige staatsobligatie steeg bijna met 10 basispunten en keerde terug naar boven de 5%-grens, en sloot op 5,07%.</p>
<p>Spot goud werd onderdrukt door een stijgende Amerikaanse dollar en Amerikaanse obligatierendementen, waarmee een vierdaagse reeks winsten werd beëindigd en sloot 0,28% lager op $1868,83 per ounce. Spot zilver sloot 0,93% lager op $21,82 per ounce.</p>
<p>De Amerikaanse aandelenmarkt staat onder druk, met slechte veilingen van 30-jarige Amerikaanse obligaties in combinatie met bezorgdheid over renteverhogingen die terugkeren naar de markt. De drie belangrijkste aandelenindices stonden onder druk en sloten lager, met een daling van 0,51% voor de Dow, 0,63% voor de Nasdaq en 0,63% voor de S&amp;P 500-index.</p>
<p>Wat betreft het al dan niet blijven verhogen van de rente in november, hebben we al gezegd dat het nu niet belangrijk is. Belangrijk is dat we ons moeten richten op de renteverlaging van volgend jaar en wanneer deze zal plaatsvinden. Hierop moeten we ons focussen en overwegen.</p>
<p>Meestal is het nodig om meer gegevens te verzamelen om een ​​volledige voorspelling te kunnen doen. Natuurlijk kan deze voorspelling alleen als referentie worden gebruikt, vooral als het gaat om transacties, omdat niemand 100% nauwkeurig kan voorspellen. Wat we dus doen is een referentie en zeker geen maatstaf voor het meten van nauwkeurigheid.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Byron B.</strong>, Gate.io-onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel te delen op voorwaarde dat Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen bij inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>