RGFnZWxpamtzIG5pZXV3cyB8IFNFQyB2ZXJ0cmFhZ3QgYWFudnJhYWcgdm9vciBTcG90IEJUQyBFVEYncywgQ2VsZXN0aWEgc3RhcnQgQWlyZHJvcCwgT3ByaWNodGVyIHZhbiBPcmRpbmFscyBzdGVsdCBCUkMyMCBhbHRlcm5hdGlldmUgb3Bsb3NzaW5nIHZvb3I=

2023-09-27, 03:55

<p><img src="https://gimg2.gateimg.com/image/article/16957930050927.jpg" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20SEC20heeft20de20aanvraag20voor20een20Spot20Bitcoin20ETF20uitgesteld20Celestia20start20een20airdrop17264"><a name="Crypto Daily Digest: SEC heeft de aanvraag voor een Spot Bitcoin ETF uitgesteld; Celestia start een airdrop" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: SEC heeft de aanvraag voor een Spot <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF uitgesteld; Celestia start een airdrop</h2><p>Bloomberg ETF-analist James Seyfart plaatste op sociale media dat de Amerikaanse Securities and Exchange Commission (SEC) zojuist de beoordelingstijd voor de Ark 21Shares spot heeft verlengd. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF-aanvraag, die oorspronkelijk werd goedgekeurd op 11 november. De SEC heeft ook een aanvraag van indexfondsreus Global X uitgesteld om spot Bitcoin ETF-producten te noteren, die oorspronkelijk was goedgekeurd op 7 oktober.</p>
<p>Op 21 september verklaarde Gary Gensler, de voorzitter van de SEC, dat vanwege de mogelijkheid dat de Amerikaanse federale overheid aan het einde van deze maand wordt stilgelegd, de regelgevende activiteiten van de SEC ernstig beperkt zullen zijn en mogelijk niet in staat zullen zijn om sommige basisfuncties uit te voeren.</p>
<p>Onlangs heeft de Federal Reserve een rapport uitgebracht op haar officiële website getiteld ‘Tokenisatie: Overzicht en Impact op Financiële Stabiliteit’, waarin wordt gesproken over de mogelijke voordelen van tokenisatie en de risico’s voor financiële stabiliteit. Het rapport concludeert dat de omvang van tokenisatie momenteel zeer klein is, maar dat er veel projecten in ontwikkeling zijn met verschillende soorten referentie-activa, wat aangeeft dat tokenisatie een groter onderdeel van het ecosysteem van digitale activa kan worden.</p>
<p>Eén van de voordelen van tokenisatie is dat het de toegangsbarrières tot andere markten met een hoge drempel verlaagt en de liquiditeit van die markt verhoogt. De financiële stabiliteitsrisico’s van tokenisatie hebben voornamelijk te maken met de verbinding die wordt gelegd tussen het ecosysteem van digitale activa en het traditionele financiële systeem. Getokeniseerde activa kunnen schokken of fluctuaties van de ene markt naar de andere overbrengen.</p>
<p>Op dit moment is de RWA-track ongetwijfeld de grootste toonaangevende track, en MKR blijft stijgen. MakerDAO heeft opnieuw zijn RWA-activa verhoogd met $50 miljoen via BlockTower Andromeda, voornamelijk belegd in kortlopende Amerikaanse schatkistobligaties, met een jaarlijkse rentevoet van 4,5%. De totale activa van de huidige overeenkomst RWA bereiken $3.008 miljard.</p>
<p>Oprichter Casey Rodarmor van Ordinals stelde een nieuw protocol voor, Runes, gebaseerd op Bitcoin-netwerken, als een mogelijk alternatief voor BRC20. Casey Rodarmor verklaarde dat alternatieve tokenprotocollen zoals Runes geen grote hoeveelheid “afval UTXO” op het Bitcoin-netwerk zullen achterlaten zoals BRC20-tokens.</p>
<p>Gisteren kondigde het modulaire blockchain-platform Celestia aan dat de airdrop is gelanceerd.</p>
<p>7.579 ontwikkelaars en 576.653 on-chain adressen zullen de mogelijkheid hebben om zich vanaf het eerste blok bij Celestia aan te sluiten. Gerechtigde deelnemers kunnen vóór 12:00 (UTC) op 17 oktober 2023 tot 60 miljoen TIAs (de inheemse activa van Celestia) ontvangen.</p>
<p>Een derde van het totale airdrop volume is toegewezen aan 7.579 ontwikkelaars, waaronder publieke producten en kritieke protocol-infrastructuur, Eth Research, en modulaire DA-laagse publieke bijdragers (zoals Avail, EigenLayer, en <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>).</p>
<p>Twee derde van het totale aantal airdrops wordt toegewezen aan 576.653 on-chain adressen, waaronder 20 miljoen TIAs die worden toegewezen aan de meest actieve gebruikers van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Rollups; 20 miljoen TIAs werden toegewezen aan de stakers en IBC-relais van <a href="/price/cosmos-hub-atom" rel="nofollow noopener noreferrer" target="_blank">Cosmos Hub</a> en <a href="/price/osmosis-osmo" rel="nofollow noopener noreferrer" target="_blank">Osmose</a>. Het inheemse activum TIA van Celestia is een belangrijk onderdeel voor ontwikkelaars die hun eerste modulaire blockchain-netwerk bouwen.</p>
<h2 id="h2-Belangrijkste20trends20van20vandaag20in20tokens494034"><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-BTC224904"><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/1695793044BTC.png" alt=""><br>Vorige week werd de voltooiing van een vraagherstel vanaf de top waargenomen. Na een lichte opleving na de doorbraak van de bovengrens van het bereik gisteren, wordt verwacht dat de korte termijn blijft fluctueren binnen het bereik tot het einde van deze week. Een conservatieve short-strategie suggereert om short te gaan na het doorbreken van $25.210 en te mikken op $24.225, met behulp van een risico-rendementstrategie voor instappen bij oplevingen.</p>
<h3 id="h3-TRB768389"><a name="TRB" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TRB</h3><p><img src="https://gimg2.gateimg.com/image/article/1695793063TRB.png" alt=""><br>In de afgelopen maand is TRB gestegen van een dieptepunt van $9,47 tot een hoogtepunt van $46,93, een stijging van 497%. Na consolidatie op zijn hoogtepunt bereikte het vanochtend een nieuw hoogtepunt van $46,93. Het is aanbevolen om long te gaan met doelen op $59,01, $65,23, $70,37 en $77,39.</p>
<h3 id="h3-MKR723765"><a name="MKR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>MKR</h3><p><img src="https://gimg2.gateimg.com/image/article/1695793082MKR.png" alt=""><br>Er is een groot bullish head and shoulders patroon ontstaan in de lange termijn structuur. Na het doorbreken van de algehele neerwaartse trend eerder deze maand, heeft de korte termijn positionering al een winst opgeleverd van 7,92%. Het wordt aanbevolen om de longpositie aan te houden en te kijken naar doelen van $1.453, $1.479, $1.505 en $1.588.</p>
<h2 id="h2-Macro20Amerikaanse20aandelen20zijn20zwak20de20Federal20Reserve20blijft20havikachtig20en20er20wordt20verwacht20dat20de20renteverlaging20volgend20jaar20plaatsvindt42710"><a name="Macro: Amerikaanse aandelen zijn zwak, de Federal Reserve blijft havikachtig, en er wordt verwacht dat de renteverlaging volgend jaar plaatsvindt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Amerikaanse aandelen zijn zwak, de Federal Reserve blijft havikachtig, en er wordt verwacht dat de renteverlaging volgend jaar plaatsvindt</h2><p>De Amerikaanse dollar index bleef sterk, steeg verder boven 106 en bereikte een nieuw 10 maanden hoogtepunt, en sloot uiteindelijk 0,217% hoger op 106,19. Het rendement op de 10-jarige Amerikaanse staatsobligaties schommelde op een hoog niveau en sloot uiteindelijk op 4,544%.</p>
<p>Spotgoud bleef onder druk staan, daalde onder de 1900-grens voor de eerste keer sinds 23 augustus, en sloot uiteindelijk met een daling van 0,78% op $1900,74 per ounce. Spotzilver miste de 23-grens en sloot uiteindelijk met een daling van 1,12% op $22,85 per ounce.</p>
<p>De drie belangrijkste Amerikaanse aandelenindices openden laag en daalden verder, waarbij de Dow met 1,14% sloot, de Nasdaq met 1,5% daalde en de S&amp;P 500-index met 1,47% daalde. De Nasdaq China Golden Dragon-index daalde met 0,8%, terwijl JD.com en PDD Holdings Inc. meer dan 2% daalden. Apple sloot meer dan 2% lager, terwijl Amazon, dat wordt aangeklaagd wegens antitrust, bijna 4% daalde. Faraday wordt verwacht in de toekomst nog eens 17% te dalen, met een cumulatieve daling van 37% deze week.</p>
<p>Terwijl de Amerikaanse aandelenmarkt zwak is, heeft de Federal Reserve niet de intentie om de markt terug te trekken en blijven ambtenaren spreken zonder rekening te houden met de gevolgen. Voorzitter van de Federal Reserve Bank van Minneapolis, Neel Kashkari, verwacht dit jaar de rente weer te verhogen en daarna ongewijzigd te laten. Bovendien gelooft hij dat er een 40% kans is dat de Federal Reserve de rente fors moet verhogen om de inflatie te beteugelen. De kans op een zachte landing in de Verenigde Staten is 60%.</p>
<p>Vanwege het tekort aan huisvestingsmiddelen concurreren kopers erom en zijn de huizenprijzen in de VS voor de zesde achtereenvolgende maand gestegen. In juli steeg de Amerikaanse huizenprijsindex met 0,6% op maandbasis. Als gevolg van zorgen over stijgende prijzen en het politieke klimaat noteerde de index van het consumentenvertrouwen van de Amerikaanse Kamer van Koophandel in september echter 103, de tweede achtereenvolgende maand van daling, lager dan de verwachte 105,5.</p>
<p>Met betrekking tot het incident met de Amerikaanse regeringsshutdown hebben ratingbureaus geleidelijk hun mening geuit. Moody’s heeft verklaard dat een gedeeltelijke shutdown van de Amerikaanse overheid een negatieve invloed zal hebben op de kredietpositie ervan en dat er niet veel tijd is voor het Congres om de billijke uitgavenwet goed te keuren voordat de deadline voor de regeringsshutdown op zaterdag verstrijkt. Momenteel is de rating van de Amerikaanse overheid door Moody’s AAA.</p>
<p>Het ratingbureau verklaarde dat in de context van het toenemende begrotingstekort en verslechterende schuldenlastcapaciteit, die de begrotingskracht naar beneden halen, de regeringssluiting “zal aantonen dat politieke polarisatie aanzienlijke beperkingen op fiscale besluitvorming verergert.”</p>
<p>Al in augustus van dit jaar heeft Fitch Ratings de kredietwaardigheid van de Verenigde Staten verlaagd van de hoogste AAA naar AA+, waarbij werd opgemerkt dat het bestuur van de VS is ‘aangetast’ en er werd verwacht dat de Amerikaanse fiscale situatie in de komende drie jaar zal verslechteren.</p>
<p>We hebben al in de afgelopen dagen gezegd dat het niet uitmaakt hoe havikachtig de Federal Reserve of belangrijke voorzitters zijn, we zouden het niet moeten geloven. We zouden alleen moeten geloven in echte gegevens en dingen. Als de 9% leenkosten langdurig worden gehandhaafd, zal dit zeker economische druk met zich meebrengen.</p>
<p>Het is daarom essentieel om volgend jaar te beginnen met het verlagen van de rente, en het gaat niet alleen om twee renteverlagingen. Als de Federal Reserve volhardt, zal er geen economische recessie zijn. Daarom moeten we als gebruikers in de cryptowereld optimistisch zijn dat zowel een recessie als een renteverlaging op lange termijn positief zullen zijn voor de cryptobranche.</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 beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Herplaatsing van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische stappen worden ondernomen vanwege auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>