RGFnZWxpamtzIG5pZXV3cyB8IEhldCByZW5kZW1lbnQgdmFuIGRlIEFtZXJpa2FhbnNlIDMwLWphcmlnZSBzY2hhdGtpc3Rib24gc3RlZWcgbmFhciA0LDg1NiU7IERlIHJlY2h0YmFuayB3ZWVzIGhldCBiZXJvZXAgdmFuIGRlIEFtZXJpa2FhbnNlIFNFQyB0ZWdlbiBkZSB1aXRzcHJhYWsgaW4gZGUgUmlwcGxlLXphYWsgYWYu

2023-10-04, 08:01

<p><img src="https://gimg2.gateimg.com/image/article/16964066151004.jpg" alt=""></p>
<h2 id="h2-Crypto20Daily20Express20Het20rendement20op20de20Amerikaanse2030jarige20staatsobligatie20steeg20naar20485620de20rechtbank20wees20het20beroep20van20de20Amerikaanse20SEC20tegen20de20uitspraak20in20de20Ripplezaak20af20FCF20Pay20stelt20gebruikers20in20staat20om20BTC20te20gebruiken20om20een20MercedesBenz20te20kopen199522"><a name="Crypto Daily Express: Het rendement op de Amerikaanse 30-jarige staatsobligatie steeg naar 4,856%; de rechtbank wees het beroep van de Amerikaanse SEC tegen de uitspraak in de Ripple-zaak af; FCF Pay stelt gebruikers in staat om BTC te gebruiken om een Mercedes-Benz te kopen." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Express: Het rendement op de Amerikaanse 30-jarige staatsobligatie steeg naar 4,856%; de rechtbank wees het beroep van de Amerikaanse SEC tegen de uitspraak in de Ripple-zaak af; FCF Pay stelt gebruikers in staat om BTC te gebruiken om een Mercedes-Benz te kopen.</h2><p>Het rendement op de Amerikaanse 30-jarige schatkist steeg gisteren naar 4,856% (bij 4,97% bij de publicatie van het artikel), het hoogste niveau sinds 2007.</p>
<p>Analisa Torres, de rechter bij de rechtbank van het district U.S. heeft het verzoek van de SEC om in beroep te gaan tegen de Ripple-uitspraak afgewezen.</p>
<p>Op de eerste dag van het proces van SBF, de oprichter van FTX, vroeg rechter Lewis Kaplan van de federale zuidelijke districtrechtbank van New York zich af of de Amerikaanse overheid ooit enige schikkingsvoorstellen aan SBF had aangeboden. De advocaat die de Amerikaanse overheid vertegenwoordigt, bevestigde dat er geen dergelijke schikkingsvoorstellen aan SBF waren aangeboden.</p>
<p>Volgens Bostic van de Fed is het plan van de Fed voor de volgende fase om de rente tegen het einde van volgend jaar met 25% te verlagen.</p>
<p>Gabor Gurbacs, hoofd digitale activastrategie bij wereldwijd vermogensbeheerbedrijf VanEck, plaatste op sociale media dat de $86 miljard <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a>-gebaseerde portefeuille (per 30 juni 2023) is afgedekt met <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en goud. Bitcoin, goud en grondstoffen vormen ongeveer 5-8% van de korte termijn portefeuille, een structuur die de activa effectief kan beschermen tegen black swan gebeurtenissen (bijv. ineenstorting van banken, centrale banken en overheden).</p>
<p>Volgens de verklaring van een hoge ambtenaar op dinsdag hebben de Singaporese autoriteiten activa ter waarde van meer dan S$2,8 miljard (US$2 miljard) in beslag genomen in een onderzoek naar witwassen van geld. De in beslag genomen eigendommen omvatten 152 onroerend goed, 62 auto’s, duizenden flessen wijn, cryptocurrencies, goudstaven en sieraden.</p>
<p>FCF Pay, een aanbieder van crypto-betalingsdiensten, heeft de lancering van een nieuwe service aangekondigd die zijn gebruikers zal ondersteunen bij de aanschaf van Mercedes-Benz met aangewezen cryptocurrencies, waaronder BTC, ETH. <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a>, XLM, DOGE, FLOKI, en meer.</p>
<p>UBS, een wereldwijd toonaangevende bank, heeft de lancering van haar eerste getokeniseerde variable kapitaalvennootschap (VCC) fonds aangekondigd, met als doel een verscheidenheid aan ‘echte activa’ op de keten te brengen. UBS Asset Management heeft het in-house tokenisatieservice UBS Tokenize benut om een gecontroleerd pilootproject van getokeniseerde geldmarktfondsen te lanceren. Het pilootproject, dat slimme contracten bevat op de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> publieke blockchain maakt het voor UBS Asset Management mogelijk om verschillende activiteiten uit te voeren, waaronder fondsabonnementen en -terugkopen.</p>
<p>Volgens Dune-gegevens heeft Friend.tech in totaal een protocolkostenopbrengst gegenereerd van 10.685,7 ETH, wat de grens van 10.000 ETH heeft overschreden. Bovendien heeft het protocol zijn TVL overschreden van $52 miljoen en heeft het meer dan 300.000 gebruikers verzameld.</p>
<p>Macro: JOLTS toont aan dat het aantal openstaande vacatures in de VS in augustus ruimschoots de verwachtingen heeft overtroffen, wat de angst voor verdere renteverhogingen voedt.</p>
<p>Het feit dat de Amerikaanse dollar index hoog blijft, samen met de ontmoedigende marktgegevens die onlangs zijn vrijgegeven, vergroot de mogelijkheid dat de Fed verdere stappen onderneemt om de al hoge rentetarieven ‘hoger te laten stijgen en langer te laten duren’.</p>
<p>De Job Openings and Labor Turnover Survey (JOLTS) die gisteren door het Amerikaanse Bureau of Labor Statistics is vrijgegeven, toonde aan dat het aantal openstaande posities in augustus steeg naar 9,61 miljoen ten opzichte van een herzien aantal van 8,92 miljoen in juli. Het aantal nieuwe aanstellingen nam licht toe, terwijl het aantal ontslagen relatief klein is.</p>
<p>De werkgelegenheidscijfers die de verwachtingen overtreffen, wat eigenlijk door alle economen die in een enquête zijn geïnterviewd als beter dan verwacht wordt beschouwd, en de sterkere dan verwachte Amerikaanse vacaturegegevens, versterken de waarschijnlijkheid dat de Federal Reserve de rentetarieven ‘hoger en langer zal laten stijgen’. Bostic van de Fed zei dat de Fed nog een lange weg te gaan heeft om de inflatie naar het streefniveau te brengen. Er is zeker geen haast om de rentetarieven opnieuw te verhogen, maar het is ook te vroeg om deze te verlagen of anderszins een signaal van beleidseasing aan te geven. Mester van de Fed merkte op dat de Fed misschien dicht bij zijn rentetarget is gekomen of deze waarschijnlijk heeft bereikt. Hij zei dat hij waarschijnlijk opnieuw een bevestigende stem zou uitbrengen om een renteverhoging te ondersteunen bij de volgende vergadering als de situatie dan geen tekenen van verbetering vertoont.</p>
<p>De stijging van het aantal openstaande banen in de VS in augustus duidt op een tekort aan mankracht, wat een reden zal zijn voor de Federal Reserve om volgende maand de rente te verhogen. Gedreven door de toename van kantoorbanen steeg het rendement van de 10-jarige Amerikaanse schatkistobligatie met 8% tot 4,76% (op het moment van publicatie van het artikel 4,85%) en steeg het rendement van de 30-jarige schatkistobligatie tot 4,87% (op het moment van publicatie van het artikel 4,97%), beide bereikten een 16-jarig hoogtepunt sinds 2007. Tegelijkertijd daalden alle drie belangrijke Amerikaanse aandelenindexen met minstens 1,1%.</p>
<p>Bovendien bereikte de Amerikaanse dollarindex na de bekendmaking van de Amerikaanse vacaturegegevens een maximum van 107,36, wat een nieuw hoogtepunt is sinds november vorig jaar, en sloot uiteindelijk met een stijging van 0,047% op 107,09. Op de Aziatische markt van vandaag (4 oktober) werd de laatste Amerikaanse dollarindex gemeld als 107,12 (10:30 Peking-tijd).</p>
<p>Hoewel veel instellingen verwachten dat de werkgelegenheidsgegevens de Federal Reserve zal aanzetten om dit jaar nog een keer de rente te verhogen, zijn er tegenstrijdige meningen die geloven dat de volgende noodzakelijke stap is om de arbeidsmarkt af te koelen. Bijvoorbeeld, econoom Stuart Paul noemde een probleem waar bedrijven mee te maken hebben bij het aannemen van personeel, namelijk het verschil tussen de bekwaamheid van kandidaten en de eisen van de functie. Dit verschil leidt tot een situatie waarin er steeds meer vacatures zijn, terwijl het aantal aangenomen personeel en de salarisgroei afnemen. Daarom verwachten zij dat de Fed de focus zal verleggen naar het verbeteren van arbeidsmarktindicatoren, aangezien alle gegevens nu wijzen op de mogelijkheid dat de arbeidsmarkt het groeitempo kan vertragen.</p>
<p>Door de huidige rentepolitiek te vergelijken met die in het verleden, hebben we vastgesteld dat de huidige rentepolitiek bijna zijn vooraf ingestelde doel heeft bereikt. De inflatie, gemeten aan de hand van de Consumentenprijsindex (CPI), is gedaald van een piek van ongeveer 9% vorig jaar tot het huidige niveau van ongeveer 3,7%, nadat de Federal Reserve erin slaagde om de rente in de afgelopen 18 maanden met in totaal 5,25% te verhogen. Hoewel de inflatie aanzienlijk is gedaald, moet het nog een eindje gaan voordat het het streefpercentage van 2% bereikt. De instabiele prestaties van een deel van de economische gegevens kunnen worden verklaard door het verschil tussen het tijdstip waarop het beleid van kracht wordt en het tijdstip waarop de gegevens beschikbaar zijn.</p>
<p>Beleggers wordt geadviseerd om de ontwikkeling van de mondiale economische ontwikkeling en financiële beleid te volgen. Hoewel we vooruitzichten zien voor de financiële omgeving om te versoepelen, moeten we nog steeds waakzaam blijven voor eventuele veranderingen op de korte termijn macro-markt en vooral opmerken hoe het beleid de crypto-markt die zeer gevoelig is voor rentetarieven beïnvloedt. Alleen op deze manier kunnen we beter omgaan met uitdagingen en kansen benutten die voortkomen uit veranderingen in de macro-omgeving.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Peter L.</strong>, Gate.io onderzoeker<br><div>Vertaler: Sally 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 opnieuw te plaatsen, mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>