RGFnZWxpamtzIG5pZXV3cyB8IEJCaXRWTSBicmVuZ3QgZWVuIHdoaXRlcGFwZXIgdWl0IGRpZSBoZXQgQlRDLWVjb3N5c3RlZW0ga2FuIHZlcmFuZGVyZW4sIERlIFNCRi16YWFrIGJvZWt0IG5pZXV3ZSB2b29ydWl0Z2FuZywgRGUgcmVrZW5pbmdlbiBkaWUgdmVyYmFuZCBob3VkZW4gbWV0IGRlIHRlcnJvcmlzdGlzY2hlIG9yZ2FuaXN

2023-10-11, 04:42

<p><img src="https://gimg2.gateimg.com/image/article/16970056241011.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20BitVM20publiceert20Whitepaper20SBFzaken20maken20nieuwe20vorderingen255100"><a name="Crypto Dagelijkse Samenvatting: BitVM publiceert Whitepaper, SBF-zaken maken nieuwe vorderingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: BitVM publiceert Whitepaper, SBF-zaken maken nieuwe vorderingen</h2><p>Gisteren, de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> het ecosysteem borrelde vanwege de release van het BitVM white paper. ZeroSync-ontwikkelaar Robin Linus kondigde het BitVM-voorstel aan, dat bijna elke berekening kan implementeren en deze berekening kan gebruiken om uit te voeren wat er op de Bitcoin-keten gebeurt. BitVM heeft een zeer interessante deur geopend voor de ontwikkeling van Bitcoin-toepassingen.</p>
<p>Het kan bijna alle willekeurige berekeningen uitvoeren en deze berekeningen gebruiken om uit te voeren wat er met <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> op de keten gebeurt. Dit vereist helemaal geen verandering in de consensus van Bitcoin. Het trucje is om alle logica uit de keten te halen en als de andere partij beweert dat het resultaat oneerlijk is, kunnen ze enkele stappen van de berekening op de keten betwisten. Kortom, BitVM brengt elke Turing-volledige berekening op een uitvoerbare manier naar Bitcoin zelf.</p>
<p>Justitie heeft lange armen! De misdaden die je vandaag hebt gepleegd, zullen in de toekomst zeker de straf krijgen die je verdient. De FTX-zaak heeft nieuwe informatieopenbaarmaking en voortgang ondergaan. Bloomberg meldde dat voormalig CEO van Alameda Research, Caroline Ellison, getuigde in de zaak tegen Sam Bankman-Fried. Ellison vertelde de juryleden dat zij, Bankman Fried en anderen FTX-klanten en investeerders, evenals de geldschieters van Alameda Research, hebben misleid.</p>
<p>Ellison verklaarde dat ‘Alameda miljarden dollars van FTX-klanten heeft genomen en deze voor zijn eigen investering heeft gebruikt’ en de kredietverstrekkers heeft terugbetaald. ‘Uiteindelijk hebben we ongeveer 14 miljard dollar genomen, waarvan we een deel hebben kunnen terugbetalen,’ getuigde ze. Ellison wees naar Bankman Fried op de verdedigingsbank en zei: ‘Hij was oorspronkelijk de CEO en eigenaar van Alameda, en hij gaf me de opdracht om deze misdaden te plegen.’ Ellison verklaarde dat deze misdaden samen met Sam werden gepleegd.</p>
<h2 id="h2-Belangrijkste20trends20in20tokens20van20vandaag342645"><a name="Belangrijkste trends in tokens van vandaag" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijkste trends in tokens van vandaag</h2><h3 id="h3-BTC253829"><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/1697005651BTC.png" alt=""><br>Het handelsvolume van vandaag is sterk afgenomen en de doorbraak op korte termijn op $ 27.282 werd gevolgd door een voortdurende daling. Verwacht wordt dat deze week een terugval naar het niveau van $ 26.920 kan zien, wat aangeeft dat er behoefte is aan aanzienlijke consolidatie. Het sterke ondersteuningsniveau om te behouden is $ 25.280. Houd de mogelijkheid in de gaten dat Bitcoin op middellange termijn een onafhankelijke trend heeft.</p>
<h3 id="h3-ETH663577"><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/1697005671ETH.png" alt=""><br>Er is een middellange trend van het doorbreken van de bodem, en degenen die shortposities hebben ingenomen op het niveau van $1.631 blijven winst maken. Het maximale doel voor een neerwaartse beweging wordt verwacht op $1.465, en het handelsvolume op korte termijn blijft verzwakken. Een conservatieve strategie kan inhouden dat winst wordt genomen, en voor degenen die op hogere prijzen willen instappen, is het raadzaam om het ondersteuningsniveau van $1.590 nauwlettend in de gaten te houden.</p>
<h3 id="h3-MKR689500"><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/1697005689MKR.png" alt=""><br>Als een toonaangevende munt in de RWA-sector is MKR op korte termijn onder de kritieke ondersteuningsniveau van $1.370 gezakt en moet mogelijk terugkeren naar de sterke nekondersteuning van $1.305. Als u een positieve kijk heeft op dit project, wordt het aanbevolen om een langetermijnstrategie te hanteren. De langetermijndoelen blijven hetzelfde: $2.294, $6.319, $9.367 en $14.308.</p>
<h2 id="h2-Macro20De20Federal20Reserve20heeft20de20neiging20om20dovish20te20zijn20het20IsralischPalestijns20conflict20kan20een20bredere20impact20hebben891283"><a name="Macro: De Federal Reserve heeft de neiging om dovish te zijn, het Israëlisch-Palestijns conflict kan een bredere impact hebben" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De Federal Reserve heeft de neiging om dovish te zijn, het Israëlisch-Palestijns conflict kan een bredere impact hebben</h2><p>Onlangs zijn er frequent duifachtige opmerkingen geweest van functionarissen van de Federal Reserve, wat een goede zaak is voor de markt. Als renteverhogingen vroegtijdig kunnen worden gestopt, zullen waarschijnlijk begin volgend jaar vroeg renteverlagingen worden doorgevoerd.</p>
<p>Bostek zei: ‘Ik denk niet dat we de rente nog verder moeten verhogen, maar als het vooruitzicht verandert, kunnen verdere renteverhogingen nodig zijn.’</p>
<p>Kashkari zei: ‘Als de economie veerkrachtiger wordt, kan het nodig zijn om de rente verder te verhogen. De mogelijke toename van opbrengsten kan betekenen dat de Federal Reserve zijn acties moet verminderen, maar als dit de verwachting van de markt is met betrekking tot de acties van de Fed, dan zullen we volharden in het vervullen ervan.’</p>
<p>Waller zei: “Het is erg handig om te putten uit de Taylor-regel bij het overwegen van de vereiste passende monetaire beleidsreactie om de inflatie terug te brengen naar 2%.”</p>
<p>Uit de opbrengstgegevens blijkt dat verdere renteverhogingen niet worden ondersteund. Het rendement van Amerikaanse staatsobligaties daalde scherp op dinsdag, en het rendement van tweejarige staatsobligaties gevoelig voor het rentebeleid sloot op het laagste niveau in meer dan een maand, omdat handelaren in rentefutures van federale fondsen geloofden dat de Federal Reserve waarschijnlijk de rente niet opnieuw zou verhogen. Het rendement van tweejarige Amerikaanse staatsobligaties daalde met 9,5 basispunten naar 4,982% van 5,077% op vrijdag.</p>
<p>Volgens de marktgegevens van Dow Jones om 15.00 uur Eastern Time bereikte het rendement het laagste slotniveau sinds 8 september. Het rendement van de 10-jarige schatkistobligatie daalde met 12,9 basispunten naar 4,654% vanaf 4,783% op vrijdag en bereikte het laagste slotniveau sinds 29 september. Het rendement van de 30-jarige schatkistobligatie daalde met 11,3 basispunten naar 4,828% vanaf 4,941% op vrijdag.</p>
<p>De World Gold Council brengt maandelijks een rapport uit, waarin wordt vermeld dat naarmate de Amerikaanse economie actief blijft en de obligatierendementen blijven stijgen, goud mogelijk voortdurende volatiliteit kan ondervinden in de komende weken. Vanwege de kwetsbare aandelenmarkt, stijgende recessierisico’s, schommelingen in de inflatie en de aanhoudende interesse van de centrale bank in goud, geloven we echter niet dat er een aanzienlijke neerwaartse trend in de goudprijzen zal zijn. Als de markt overdreven kort wordt, kan dit een koopkans zijn voor sommige beleggers.</p>
<p>Afgelopen nacht slaagde spotgoud er niet in om verdere winsten te behalen en sloot 0,05% lager op $1.860,46 per ounce. Sommige analisten geloven dat de opleving op Europese en Amerikaanse aandelenmarkten de goudprijzen heeft beïnvloed. Spotzilver sloot 0,24% lager op $21,83 per ounce. De drie belangrijkste Amerikaanse aandelenindices sloten gezamenlijk hoger, waarbij de Dow Jones-index met 0,4% steeg, de Nasdaq met 0,58% en de S&amp;P 500-index met 0,51%.</p>
<p>Wat betreft het recente Palestijns-Israëlisch conflict, zei de hoofdeconoom van het IMF Internationaal Monetair Fonds dat het nog te vroeg is om te bepalen of de oorlog tussen Israël en Hamas grote economische gevolgen zal hebben.</p>
<p>Pierre Olivier Gourinchas verklaarde dat de conflicten schokken in de energievoorziening kunnen veroorzaken, waardoor de olieprijzen stijgen, de inflatie verergert en de economische groei afneemt. Uit onderzoek van het IMF blijkt dat voor elke stijging van de olieprijs met 10% de wereldwijde economische groei met 0,15 procentpunt afneemt. Hoewel de olieprijzen sinds het begin van de oorlog zijn gestegen, zei Gourinchas dat de stijging van de olieprijzen mogelijk niet zal aanhouden. Hij zei op de jaarlijkse bijeenkomst van het IMF in Marrakech, Marokko: “Ik denk dat we voorzichtig moeten zijn. Ik denk dat het nog te vroeg is om de potentiële impact echt in te schatten.”</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 opvattingen van de onderzoeker en vormt geen beleggingsadviezen.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>