RGFnZWxpamtzIG5pZXV3cyB8IEF1c3RyYWxpw6sgdmVyc3Rlcmt0IGNyeXB0by1yZWd1bGVyaW5nLCBGZXJyYXJpIGFjY2VwdGVlcnQgY3J5cHRvLWJldGFsaW5nZW4sIEFYUyBlbiBBUEUgb250Z3JlbmRlbGVuIGRlemUgd2VlayBncm90ZSBob2V2ZWVsaGVkZW4=

2023-10-16, 04:51

<p><img src="https://gimg2.gateimg.com/image/article/16974345861016.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20Australi20Verhoogt20Regulering20van20Beurzen20Ferrari20Accepteert20Betalingen20met20Crypto155128"><a name="Crypto Dagelijks Overzicht: Australië Verhoogt Regulering van Beurzen, Ferrari Accepteert Betalingen met Crypto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: Australië Verhoogt Regulering van Beurzen, Ferrari Accepteert Betalingen met Crypto</h2><p>Het Australische ministerie van Financiën verklaarde in een consultatiedocument met de titel “Regulatory Digital Asset Platforms” dat maandag werd vrijgegeven dat personen die digitale activaplatforms van meer dan AUD 5 miljoen ($ 3,2 miljoen) of AUD 1500 bezitten, een vergunning moeten krijgen van de Australian Securities and Investments Commission (ASIC). Het raadplegingsdocument stelt voor om crypto-handelsplatforms te reguleren onder de bestaande wetten voor financiële diensten, in plaats van nieuwe cryptocurrency-specifieke regels te ontwikkelen.</p>
<p>De markt zegt dat de goedkeuring van spot ETF’s in feite gegarandeerd is, het hangt ervan af wanneer het wordt vrijgegeven.</p>
<p>Fox Business-journalist Eleanor Terrett verklaarde op haar sociale mediaplatform dat Grayscale heeft verklaard dat de Amerikaanse SEC heeft besloten geen hoger beroep aan te vragen, waarbij werd gesteld: “de termijn van 45 dagen voor het aanvragen van een nieuw proces onder de regels van de federale beroepsprocedure is verstreken. De rechtbank zal de definitieve autorisatie binnen 7 dagen afgeven. Het team van Grayscale staat klaar om GBTC in het ETF om te zetten zodra het is goedgekeurd door de SEC.”</p>
<p>De huidige negatieve premietarief van de Gray <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Het negatieve premiepercentage van Trust Fund (GBTC) bedraagt 15,88%. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Trust Fund (EETH) is 25.54%.</p>
<p>Anthony Scaramucci, oprichter van Skybridge Capital, verklaarde onlangs in een interview dat hoewel de Federal Reserve er momenteel goed uitziet, het besturingssysteem fundamenteel is ingestort.</p>
<p>Anthony Scaramucci stelde een alternatieve oplossing voor met een gedefinieerde schaarste van onveranderlijke activa, en afgezien van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> heeft geen enkel activum dergelijke kenmerken. Hij gelooft dat Bitcoin zich ontwikkelt tot een waardevollere manier om waarde op te slaan dan goud. En er wordt voorspeld dat in het g van de ineenstorting van het Amerikaanse financiële systeem, de marktwaarde van Bitcoin $15 biljoen zal bereiken.</p>
<p>Gisteren verklaarde de marketing- en businessdirecteur van Ferrari (RACE.MI) volgens Reuters dat zijn luxueuze sportwagenbedrijf in de Verenigde Staten begonnen is met het accepteren van cryptocurrency-betalingen en het plan zal uitbreiden naar Europa op basis van klantvereisten. Momenteel werkt cryptocurrency aan het verminderen van zijn ecologische voetafdruk door de invoering van nieuwe software en het verhogen van het gebruik van hernieuwbare energie.</p>
<p>Paolo Ardoino, die op het punt staat te worden <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> De CEO van , verklaarde op sociale media dat ‘Tether’s Real World Eco (RWE) binnenkort zal worden gelanceerd.’</p>
<p>Paolo Ardoino verklaarde in een interview met The Block dat hoewel Tether’s USDT stablecoin “een belangrijk product blijft en het bedrijf zich stevig zal concentreren op zijn groei, het bedrijf ook uitbreidt naar nieuwe gebieden. <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> zal binnenkort een nieuw platform aankondigen dat gebruikmaakt van Tether’s ervaring in het bouwen van financiële technologie en zich richt op real-world activa (RWA’s).”</p>
<p>Op 16 oktober toonde Token Unlocks-gegevens aan dat vier projecten deze week eenmalige token-ontgrendeling zullen ondergaan, met een totale waarde van meer dan $87,8 miljoen. Onder hen zullen AXS en APE een eenmalige grote ontgrendeling ervaren:</p>
<p>Om 0:00 (UTC) op 16 oktober, <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a> zal 7,29 miljoen FLOW’s ontgrendelen, ter waarde van ongeveer 3,23 miljoen dollar, wat overeenkomt met 0,7% van de circulerende voorraad;</p>
<p>Om 0:00 (UTC) op 17 oktober, <a href="/price/apecoin-ape" rel="nofollow noopener noreferrer" target="_blank">ApeCoin</a> zal 15,6 miljoen APEs ontgrendelen, ter waarde van ongeveer $16,6 miljoen, wat overeenkomt met 4,23% van de circulerende voorraad;</p>
<p>Om 13:10 (UTC) op 20 oktober zal Axis Infinity 1513 AXS ontgrendelen, ter waarde van ongeveer $64,59 miljoen, wat overeenkomt met 11,5% van de circulerende voorraad;</p>
<p>Op 22 oktober om 0:00 uur (UTC) zal SPACE ID 18,49 miljoen ID’s ontgrendelen, ter waarde van ongeveer $3,41 miljoen, wat overeenkomt met 6,46% van de omloopvoorziening.</p>
<h2 id="h2-Belangrijkste20Token20Trends20van20Vandaag86131"><a name="Belangrijkste Token Trends van Vandaag" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijkste Token Trends van Vandaag</h2><h3 id="h3-BTC440855"><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/1697434619btc.png" alt=""><br>Ondanks het einde van het derde kwartaal vormt Bitcoin nog steeds een kop- en schouderpatroon. Het heeft onlangs het ondersteuningsniveau van $28.000 getest met een tweede retracement, waarbij het precies terugstuiterde van het eerder genoemde retracementniveau van $26.510 van vorige week. Op korte termijn wordt verwacht dat er een periode van consolidatie zal zijn voordat er een voortdurende stijging plaatsvindt. De doelen voor deze week zijn $27.283 en $28.125.</p>
<h3 id="h3-ETH157253"><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/1697434640ETH.png" alt=""><br>De middellange termijnstructuur van <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> is persistent bearish. Degenen die de aanbevolen shortpositie op het niveau van $1.631 hebben gevolgd, zijn consequent winstgevend geweest. Op korte termijn is een geleidelijk herstel waarschijnlijk omdat de bredere markt tekenen vertoont van een langzaam herstel. De aanhoudende daling van de gasprijzen duidt erop dat chips de vraag naar andere openbare blockchains verdunnen. Het korte termijn doel blijft op $1.631.</p>
<h3 id="h3-BIGTIME846211"><a name="BIGTIME" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BIGTIME</h3><p><img src="https://gimg2.gateimg.com/image/article/1697434659BIGTIME.png" alt=""><br>De invoerpunten van vorige week op $0.07140 en $0.09350 hebben geleid tot een hoogtepunt van $0.3450, wat een aanzienlijke winst betekent van 384%. Korte termijn strategieën kunnen winstgevend uitstappen op deze hoge niveaus, terwijl medium tot lange termijn strategieën posities kunnen blijven vasthouden en trailing stop-loss kunnen gebruiken om winsten veilig te stellen.</p>
<p>Op korte termijn is er een uurlijkse driehoekige consolidatie gaande, met indicaties van een oplossing rond de vroege uren van 17 oktober (Beijing Standard Time). De ondersteuningsprijs op middellange termijn wordt geschat op $0.18350, waarbij geen verdere daling onder dit niveau wordt verwacht. Het handelsvolume neemt af en er wordt verwacht dat er aan het einde van deze maand een tweede golf van bullish bewegingen zal plaatsvinden.</p>
<p>We laten ons inspireren door GMT en MANA (aangezien GMT in 2022 een leider in de blockchain-gamingindustrie werd en de oprichter van MANA ook de CEO van Bigtime is). GMT bereikte zijn aanvankelijke piek van $ 0,8420 in slechts twee weken en keerde vervolgens terug naar $ 0,598.</p>
<p>GMT bereikte uiteindelijk een hoogtepunt van $3.1311, wat een 311-voudige stijging markeert vanaf de openingsprijs van $0.01, met een marktkapitalisatie van $2 miljard. Deze verbazingwekkende 311-voudige stijging kostte slechts 23 dagen om te bereiken (tijdens een niet-stierenmarkt periode).</p>
<p>MANA daarentegen vertoonde een patroon van geleidelijke stijgingen en terugtrekkingen. Het steeg aanvankelijk van $0.0582 naar zijn eerste doel van $1.5792, wat een waardestijging van 2.717% betekent en een piekmarktkapitalisatie van $9 miljard bereikte, waardoor er aanzienlijke ruimte was voor speculatie in de Metaverse-sector.</p>
<p>Als we de marktkapitalisatie van Bigtime vergelijken met de piekwaarden van GMT en MANA, is de huidige marktkapitalisatie van Bigtime slechts $40 miljoen. In een rustige marktomgeving met beperkte concurrentie is er aanzienlijk potentieel voor Bigtime om een marktkapitalisatiebubbel te bereiken die 50 keer hoger is dan de piek van GMT ($12.25) of zelfs 132 keer hoger dan de piek van MANA ($32.34).</p>
<p>In de blockchain-gamingindustrie, ongeacht of deze een dual-coin- of triple-coin-model volgt, moet er nog een volledig gevestigd driehoekig gebalanceerd tokenmodel worden gezien. Gezien de ervaringen van GMT en MANA, die beide op hun hoogtepunt aanzienlijke bubbels doormaakten, is het duidelijk dat de markt rijp is voor winstnemingen. Als u vandaag een market maker was, zou u er dan voor kiezen om een project in te stappen met een marktkapitalisatie van $ 40 miljoen, $ 400 miljoen of $ 4 miljard?</p>
<h2 id="h2-Macro20De20escalatie20van20het20IsralischPalestijnse20conflict20kan20een20grotere20impact20hebben20en20de20Federal20Reserve20heeft20zijn20renteverhogingsdoel20voltooid378697"><a name="Macro: De escalatie van het Israëlisch-Palestijnse conflict kan een grotere impact hebben, en de Federal Reserve heeft zijn renteverhogingsdoel voltooid" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De escalatie van het Israëlisch-Palestijnse conflict kan een grotere impact hebben, en de Federal Reserve heeft zijn renteverhogingsdoel voltooid</h2><p>Het conflict tussen Palestina en Israël heeft geleid tot meer dan 4.100 doden aan beide zijden; Het nieuws zei dat de Verenigde Staten en Israël bespreken de mogelijke bezoek van Biden aan Israël; De Iraanse minister van Buitenlandse Zaken heeft voor het eerst sinds het huidige conflict tussen Israël en Palestina Hamas-leiders ontmoet; Iran waarschuwt dat als Israël doorgaat met zijn acties in Gaza, het zal moeten ingrijpen; De Israëlische strijdkrachten stellen dat het leger overal in het Midden-Oosten kan opereren ter beveiliging van Israël. De Rafah-grens tussen Gaza en Egypte is om 9.00 uur lokale tijd geopend; De Verenigde Staten en Iran hebben gecommuniceerd via <a href="/price/secret-scrt" rel="nofollow noopener noreferrer" target="_blank">Geheim</a> kanalen; Antony Blinken zal op maandag opnieuw Israël bezoeken.</p>
<p>Antony Blinken bezocht achtereenvolgens de landen in het Midden-Oosten, maar het is nog steeds moeilijk voor deze landen om Hamas te veroordelen. Op dit moment is het conflict in Libanon nog steeds onder controle, en Hizbullah lanceert af en toe raketten om hen ervan te weerhouden zich formeel bij de oorlog aan te sluiten. Echter, uit de publieke opinie van Arabische landen, steunt iedereen Palestina, en we moeten in de gaten houden of dit verder escaleert. Zodra de oorlog in het Midden-Oosten escaleert, zal dit onvermijdelijk een enorme impact hebben op de financiële wereld.</p>
<p>De scherpe stijging van goud van vorige week is een voorbeeld. Het volgende punt voor goud is om terug te keren naar 2000 punten, en het risico-aversiesentiment heeft de stijging van goud verergerd. Echter, goud heeft de stijging van Bitcoin niet aangedreven, en de reden is simpel. Bitcoin bevindt zich momenteel in een bear market fase, en incrementele fondsen en gebruikers hebben een redelijk triggerpunt nodig, dus het is moeilijk om omhoog te trekken zonder een grote hoeveelheid kapitaalinterventie. Maar als de oorlog voortduurt, zal wereldwijde terreur en paniek zich verspreiden, en zullen meer mensen zeker aandacht schenken aan Bitcoin.</p>
<p>Federal Reserve Huck verklaarde dat de Federal Reserve mogelijk klaar is met het verhogen van de rente, wat een langere periode van een hoge rentestand ondersteunt. De economische groei zal volgend jaar vertragen, maar een recessie wordt niet verwacht. Na de toespraak van Huck van de Fed verminderden swapcontracten de waarschijnlijkheid van de Fed om dit jaar de rente te verhogen.</p>
<p>Naast Huck hebben we gemerkt dat er ook meldingen zijn dat er geen renteverhogingen zullen zijn. Craig Torres, een journalist die de Federal Reserve volgt op Bloomberg, meldde dat de Federal Reserve de rente niet langer zal verhogen in november, maar het einde van de renteverhogingscyclus niet zal aankondigen.</p>
<p>Op dit moment is de mogelijkheid om de rente in november te verhogen zeer laag, maar het kan ons niet schelen of we ze moeten verhogen. Dit is herhaaldelijk genoemd, maar het is niet belangrijk voor ons. Waar we ons zorgen over moeten maken, is wanneer we volgend jaar de rente moeten verlagen.</p>
<p>Volgens de gegevens van de ‘Federal Reserve Observation’ van CME is de waarschijnlijkheid dat de Federal Reserve de rentetarieven in november ongewijzigd houdt op het niveau van 5,25% - 5,50% 93,8%, en de waarschijnlijkheid dat de rentetarieven met 25 basispunten worden verhoogd naar het niveau van 5,50% - 5,75% is 6,2%.</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 mening van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel wordt toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>