U2lsdmVyZ2F0ZSBzY2hvcnQgY3J5cHRvLWJldGFsaW5nc25ldHdlcmsgZW4gbWVlciBvcA==

2023-03-20, 01:04

<p><img src="https://gimg2.gateimg.com/image/article/1679273618热点追踪 封面.jpg" alt=""></p>
<h2 id="h2-Te20lang20niet20gelezen881570"><a name="Te lang; niet gelezen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Te lang; niet gelezen</h2><p>Silvergate Bank heeft Silvergate Exchange Network gesloten als gevolg van financiële en regelgevende uitdagingen.</p>
<p>De implosie van FTX en zijn zusterbedrijf Alameda Research heeft bijgedragen aan de financiële problemen van Silvergate.</p>
<p>Galaxy Digital, LedgerX, Coinbase, Circle, Paxos en Bitstamp hebben hun zakelijke samenwerking met Silvergate Bank beëindigd. Tegen het einde van februari is de aandelenkoers van Silvergate Capital Corp met 89% gedaald vanaf het hoogste punt ooit in november 2021.</p>
<h2 id="h2-Introductie453694"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De crypto meltdown die begin 2022 begon, blijft chaos veroorzaken in de sector omdat sommige cryptocurrency-gerelateerde projecten hun activiteiten afbouwen. Onlangs kondigde Silvergate Capital Corp aan dat het <a href="https://www.gate.io/es/blog_detail/2280/%E7%AC%AC%E4%B8%80%E8%A1%8C%E6%83%85-silvergate%E9%93%B6%E8%A1%8C%E5%85%B3%E9%97%AD%E5%BC%95%E5%8F%91%E5%85%A8%E7%90%83%E5%B8%82%E5%9C%BA%E6%8A%9B%E5%94%AE-%E5%AF%BC%E8%87%B4%E5%8A%A0%E5%AF%86%E9%A2%86%E5%9F%9F3%E4%BA%BF%E7%BE%8E%E5%85%83%E6%B8%85%E7%AE%97" target="_blank">het stopzetten van Silvergate Exchange Network</a>. Vandaag bespreken we de mogelijke oorzaken van de afbouw.</p>
<h2 id="h2-De20sluiting20van20Silvergate20Exchange20Network20SEN956517"><a name="De sluiting van Silvergate Exchange Network (SEN)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De sluiting van Silvergate Exchange Network (SEN)</h2><p>Op 8 maart 2023 heeft Silvergate Capital Corp, de houdstermaatschappij van Silvergate Exchange Network, <a href="https://ir.silvergate.com/news/news-details/2023/Silvergate-Capital-Corporation-Announces-Intent-to-Wind-Down-Operations-and-Voluntarily-Liquidate-Silvergate-Bank/default.aspx" rel="nofollow noopener noreferrer" target="_blank">aangekondigd dat het SEN stopgezet heeft</a>, zijn cryptocurrency betalingsnetwerk. Hoewel het bedrijf de exacte reden voor zijn actie niet openbaar heeft gemaakt, heeft het verklaard dat het een op risico gebaseerde beslissing is, wat betekent dat de organisatie mogelijk levensvatbaarheids- of liquiditeitsuitdagingen het hoofd moet bieden.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1679274141Silvergate 1.png" alt=""><br>Silvergate Bank- <a href="https://www.coindesk.com/resizer/dGftW-u-990-Yi-qN1MAHjHBlfE=/1056x594/filters:quality(80" rel="nofollow noopener noreferrer" target="_blank">Coindesk</a>:format(webp)/cloudfront-us-east-1.images.arcpublishing.com/coindesk/GNWQ2ZAWD5C4HKPIBBC6KH5FCU.png “Coindesk”)<br>De sluiting van Silvergate Exchange Network (SEN) komt een paar dagen nadat het ratingbureau Moody’s het heeft verlaagd van Ba3 naar Caa1 als gevolg van het niet indienen van zijn jaarverslag bij de Amerikaanse Securities and Exchange Commission (SEC). Silvergate Bank heeft echter gezegd dat alle andere “depositogerelateerde diensten operationeel blijven”.</p>
<p>Lees ook: <a href="https://www.gate.io/th/blog_detail/1695/understanding-how-the-merge-puts-ethereum-in-sec-s-crosshair" target="_blank">Begrijpen hoe de Merge Ethereum in het vizier van de SEC plaatst</a><br>De aankondiging om het Silvergate Exchange Network stop te zetten komt een week nadat Silvergate Capital Corp de SEC heeft geïnformeerd dat het zijn vermogen om te blijven opereren als een lopende zaak aan het ueren was en dat het additionele schuldpapieren met verlies had verkocht. Het benadrukte dat een additionele verkoop van zijn effecten met verlies ertoe zou leiden dat de bank “minder dan gekapitaliseerd” zou worden.</p>
<p>De financiële prestaties van de bank in het derde kwartaal van 2022 laten zien dat het mogelijk financiële moeilijkheden ondervindt. Dit komt doordat de bank in die periode een verlies van $886 miljoen heeft geleden door de verkoop van zijn onderwater effecten. Silvergate Bank heeft ervoor gekozen de effecten te verkopen als gevolg van een daling van 68% in zijn crypto-gerelateerde deposito’s gedurende dezelfde periode.</p>
<p>Opmerkelijk genoeg was de bank van plan om de benodigde fondsen te werven om $9,9 miljoen af te lossen aan BlockFi, een crypto-uitlenende instelling, zoals bevolen door een Amerikaanse faillissementsrechter.</p>
<p>Het stopzetten van het Silvergate Exchange Network (SEN) door Silvergate Bank kan een teken zijn dat het niet langer geïnteresseerd is in enige crypto-gerelateerde activiteiten. Enkele van zijn belangrijke partners in de cryptosector, zoals Coinbase en stablecoin-uitgevers Paxos en Circle, hebben hun bestaande zakelijke relaties met de bank al beëindigd.</p>
<h2 id="h2-Begrijpen20van20het20Silvergate20Exchange20Network20SEN859984"><a name="Begrijpen van het Silvergate Exchange Network (SEN)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Begrijpen van het Silvergate Exchange Network (SEN)</h2><p>Silvergate Exchange Network (SEN) was een crypto-gerelateerde organisatie die de conversie van cryptocurrencies naar fiat-valuta en vice versa faciliteerde tussen crypto-beurzen, institutionele investeerders en andere klanten. Tegen het derde kwartaal van 2022 had SEN meer dan 1.600 klanten, waaronder crypto-beurzen en institutionele investeerders, met een totale storting van meer dan $12 miljard.</p>
<h2 id="h2-De20mogelijke20oorzaken20van20de20stopzetting20van20het20Silvergate20Exchange20Network20SEN20door20Silvergate20Bank683317"><a name="De mogelijke oorzaken van de stopzetting van het Silvergate Exchange Network (SEN) door Silvergate Bank" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De mogelijke oorzaken van de stopzetting van het Silvergate Exchange Network (SEN) door Silvergate Bank</h2><p>Er zijn verschillende factoren die waarschijnlijk hebben bijgedragen aan het stopzetten van het Silvergate Exchange Network (SEN). Deze kunnen onder meer druk van de overheid, de cryptocrash van FTX, verbroken relaties met partners en de aanzienlijke daling van de waarde van de aandelen omvatten.</p>
<h2 id="h2-De20ineenstorting20van20FTX798850"><a name="De ineenstorting van FTX" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De ineenstorting van FTX</h2><p>De huidige problemen van Silvergate Bank begonnen toen de FTX-crypto-uitwisseling en haar zusterbedrijf Alameda Research in het derde kwartaal van 2022 instortten. Na deze crypto-misstap hebben FTX-klanten $8,1 miljard aan deposito’s opgenomen. Om aan deze hoge opname te voldoen, nam Silvergate Bank een lening van het Home Bank Loan-systeem, een federale organisatie die banken voorziet van financiering tegen lage kosten.<br>Lees ook: <a href="https://www.gate.io/blog_detail/2268/uk-crypto-regulation-ftx-collapse" target="_blank">Britain stelt zich in op regulering van de crypto na de ineenstorting van FTX</a></p>
<p><img src="https://gimg2.gateimg.com/image/article/1679274187Silvergate 2.png" alt=""><br>Ineenstorting van FTX- Paybito</p>
<p>Die lening veroorzaakte opschudding onder federale wetgevers die bang waren dat als Silvergate Bank het geleende bedrag niet zou terugbetalen, de Federal Deposit Insurance Corp ernstig zou worden getroffen, wat tot een publieke opschudding zou kunnen leiden. Als gevolg hiervan werd Silvergate verzocht om de lening onmiddellijk terug te betalen.<br>Om die lening terug te betalen, verkocht Silvergate Bank zijn effecten met een totaal verlies van $886 miljoen.</p>
<h2 id="h2-Overheidsdruk283913"><a name="Overheidsdruk" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Overheidsdruk</h2><p>De Silvergate Bank stond ook onder intensief toezicht van de Amerikaanse aanklagers in de fraude van het ministerie van Justitie met betrekking tot haar financiële transacties met FTX en Alameda Research.</p>
<p>Al enige tijd werden de toezichthouders ondervraagd door Silvergate Bank over het niet detecteren van verdachte financiële transacties tussen FTX en haar zusterbedrijf Alameda Research. Op het moment van de ineenstorting had Silvergate $1 miljard aan deposito’s van FTX.</p>
<p>Gezien deze beschuldigingen en andere ontwikkelingen in de cryptosector, heeft Silvergate het nodig geacht om Silvergate Exchange Network (SEN) af te bouwen en vrijwillig te liquideren.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/1804/key-lessons-from-the-collapse-of-ftx-and-the-implosion-of-ftt" target="_blank">Belangrijke lessen uit de ineenstorting van gate.io en de implosie van FTT</a></p>
<h2 id="h2-Constante20daling20van20de20waarde20van20zijn20aandelen644177"><a name="Constante daling van de waarde van zijn aandelen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Constante daling van de waarde van zijn aandelen</h2><p>De waarde van het aandeel van Silvergate staat onder druk sinds de <a href="https://www.gate.io/blog_detail/1792/ftx-event-and-its-domino-effects" target="_blank">ineenstorting van FTX en Alameda Research</a>. Momenteel is de prijs van haar aandelen met ongeveer 65,8% gedaald sinds het begin van het jaar. Nog erger is dat de aandelenkoers met 89% is gedaald ten opzichte van het hoogste punt ooit in november 2021. Deze constante daling in de waarde van haar aandelen en de huidige onstabiele cryptomarkt heeft Silvergate Bank ertoe aangezet om Silvergate Exchange Network (SEN) stop te zetten.</p>
<h2 id="h2-Relatie20met20haar20partners204700"><a name="Relatie met haar partners" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Relatie met haar partners</h2><p>De meeste partners hebben hun zakelijke relaties met Silvergate beëindigd na de bekendmaking dat het de indiening van zijn jaarverslag zou uitstellen. Bijvoorbeeld,<br><strong>Galaxy Digital, LedgerX, Coinbase, Circle, Paxos en Bitstamp</strong> hebben openlijk verklaard dat ze <a href="https://cointelegraph.com/news/circle-paxos-bitstamp-and-galaxy-join-coinbase-in-scaling-back-partnerships-with-silvergate-bank" rel="nofollow noopener noreferrer" target="_blank">hebben hun partnerschappen beëindigd met Silvergate Bank</a>.</p>
<h2 id="h2-De20korte20geschiedenis20van20Silvergate20Bank206677"><a name="De korte geschiedenis van Silvergate Bank" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De korte geschiedenis van Silvergate Bank</h2><p>Silvergate Bank begon in 1988 als een lening- en spaarvereniging in Californië, Verenigde Staten. In 1996 herkapitaliseerden Dennis Frank en Derek J. Eisele Silvergate en veranderden het in een commerciële bank die lening- en bankdiensten biedt, zoals commercieel vastgoed en zakelijke bankrekeningen. Het is één bank die bereid is geweest om samen te werken met cryptocurrency-bedrijven en hun cryptodiensten te ondersteunen.</p>
<h2 id="h2-Conclusie290553"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Op 8 maart 2023 kondigde Silvergate Bank aan dat het zijn Silvergate Exchange Network (SEN) stopzet. Hoewel het de exacte redenen niet heeft gespecificeerd, hebben verschillende factoren bijgedragen aan die beslissing. Deze omvatten de implosie van FTX en Alameda, de daling van de aandelenkoersen en de reguleringsdruk van de overheid.</p>
<h2 id="h2-Veelgestelde20vragen20over20Silvergate20Bank991758"><a name="Veelgestelde vragen over Silvergate Bank" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over Silvergate Bank</h2><p>Is Silvergate een bank?</p>
<p>Silver Gate Bank is een commerciële bank die in 1996 werd opgericht en momenteel actief is in de Verenigde Staten. Aanvankelijk werd het in 1988 opgericht als een lening- en spaarvereniging in Californië. Het biedt verschillende commerciële diensten aan, zoals leningen en onroerend goed.</p>
<p><strong>Hoe groot is Silvergate Bank?</strong></p>
<p>Silvergate Bank is een grote financiële instelling die veel institutionele klanten heeft omdat het verschillende diensten aanbiedt zoals zakelijke spaarrekeningen, geldmarkten, depositocertificaten, kasbeheer, online bankieren en verwerkingsservices. Het werd opgericht in de Verenigde Staten in 1996.</p>
<p><strong>Is Silvergate Bank goed?</strong></p>
<p>Silvergate is een gerenommeerde bank die verschillende klanten, waaronder institutionele beleggers, bedient. Het werd erg populair toen het zijn Silvergate Exchange Network creëerde, waarmee het zijn klanten hielp om cryptocurrency te ruilen voor fiatgeld. Het is altijd in staat geweest om aan zijn financiële verplichtingen aan zijn klanten te voldoen.</p>
<p><strong>Wie is eigenaar van Silvergate Capital?</strong></p>
<p>Martin S. Friedman is de grootste individuele aandeelhouder van Silvergate Capital. Er zijn echter ook enkele andere individuele aandeelhouders, evenals veel institutionele aandeelhouders.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Mashell C.</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel te herposten 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>