VVNEQyBTdGFibGVjb2luLXVpdGdldmVyIHNsdWl0IHZyaWVuZHNjaGFwIG1ldCBDcm9zcyBSaXZlciBCYW5r

2023-03-31, 09:09

<p><img src="https://gimg2.gateimg.com/blog/1679447253155655279redian.jpeg" alt=""></p>
<h2 id="h2-TL20DR797007"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>De ineenstorting van Silicon Bank, Silvergate Bank en Signature Bank heeft een leegte achtergelaten in de banksector, aangezien maar weinig banken de diensten aanbieden die door cryptobedrijven worden vereist.</p>
<p>Bank of New York Mellon and Cross River Bank zijn voorbeelden van banken die beperkte crypto-gerelateerde diensten aanbieden.</p>
<p>Deutsche Bank (DB), Santander (SAN), HSBC (HSBA), Western Alliance, Mercury, Series Financial Multis, Bank Prove en Bridge hebben interesse getoond om de diensten aan te bieden waar cryptobedrijven de voorkeur aan geven.</p>
<p>Landen zoals de Verenigde Staten hebben hun toezicht op regulering verscherpt na een reeks crypto-diefstallen en misdaden, evenals het instorten van crypto-projecten zoals FTX.</p>
<h2 id="h2-Introductie552963"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De ineenstorting van drie belangrijke banken die cryptocurrencies ondersteunden in de Verenigde Staten heeft de manier verstoord waarop cryptoinvesteerders hun zaken doen. De sluiting van Silicon Bank, Silvergate Bank en Signature Bank kort na elkaar heeft de liquiditeit in de cryptosector beïnvloed. Dit komt doordat Silvergate de infrastructuur leverde die de cryptosector dagelijks ondersteunde.</p>
<h2 id="h2-De20getroffen20durfkapitalen359172"><a name="De getroffen durfkapitalen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De getroffen durfkapitalen</h2><p>Het faillissement van deze drie banken betekende dat verschillende tech- en venturebedrijven niet de diensten kunnen krijgen die ze willen. Silicon Valley Bank was bijvoorbeeld een geldschieter voor veel startende bedrijven. Aan de andere kant bankieren de meeste crypto-bedrijven en door durfkapitaal gesteunde start-ups bij Silvergate Bank en Signature Bank. Daarom heeft hun ineenstorting een leegte achtergelaten in de crypto-sector. Als gevolg hiervan moeten deze crypto-bedrijven op zoek naar geschikte banken die voldoen aan hun speciale eisen en voorkeuren.</p>
<p>Belangrijke crypto-bedrijven zoals Finance.US, Kraken en Gemini bankieren bij Silvergate Bank en Signature Bank. Aan de andere kant bankieren digitale activabedrijven, durfkapitalen en technologiebedrijven zoals Circle, Trace Finance, Roku, BlockFi en Roblox bij Silicon Valley Bank (SVB).</p>
<p><img src="https://gimg2.gateimg.com/image/article/1680253626641680253569_.pic.jpg" alt=""><br>Silicon Valley Bank- NPR.org</p>
<p>De sluiting van deze belangrijke financiële instellingen in de Verenigde Staten kan een bewuste zet zijn van de overheid om te voorkomen dat crypto-bedrijven betrouwbare bankdiensten kunnen gebruiken om hun activiteiten te verstoren. Het lijkt er echter op dat er andere banken zijn, zoals Cross River Bank - de in New Jersey gevestigde financiële instelling - die bereid zijn om de cryptosector te bedienen.</p>
<h2 id="h2-Cross20River20Bank20lijkt20een20natuurlijke20stap130405"><a name="Cross River Bank lijkt een natuurlijke stap" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cross River Bank lijkt een natuurlijke stap</h2><p>Na de sluiting van Silvergate Bank en Silicon Valley Bank, Circle, een peer-to-peer betalingstechnologiebedrijf en de uitgever van <a href="/price/usd-coin-usdc" rel="nofollow noopener noreferrer" target="_blank">USD Coin</a>(USDC) heeft samengewerkt met Cross River Bank om ervoor te zorgen dat de stablecoin een 1.1 peg met de Amerikaanse dollar behoudt. Cross River Bank werkt al samen met andere cryptobedrijven, waaronder de Coinbase exchange.</p>
<p>Circle wil doorgaan met het geautomatiseerd slaan en inlossen van USDC. Voor de nieuwe bankpartnerschap had Circle een werkrelatie met Silicon Valley Bank, waar het $3,3 miljard had vastgezet. Helaas ontkoppelde USDC op 11 maart, waardoor Circle $2,34 miljard aan USDC moest verbranden om de koppeling met de Amerikaanse dollar te behouden.</p>
<p>Jeremy Allaire, medeoprichter en CEO van Circle, zei op Twitter dat het bedrijf Cross River Bank heeft gekozen om ervoor te zorgen dat de fondsen van de klanten veilig blijven in USDC. Circle vermijdt in feite fractioneel reservebankieren omdat het zijn stablecoin, USDC, blootstelt aan risico’s.</p>
<p>Bovendien is het belangrijk voor Circle om een partnerschap aan te gaan met een betrouwbare bank om de ontkoppeling van USDC te voorkomen. Onlangs, toen het zijn blootstelling aan Silicon Valley Bank aankondigde, daalde de USDC tot slechts $0,87. De stablecoin heeft echter alweer zijn koppeling hersteld.</p>
<p>Bovendien is het essentieel om te begrijpen dat Circle zijn partnerschap in de banksector niet beperkt tot Cross River Bank. Het heeft ook al een bestaande bancaire relatie met de Bank of New York Mellon (BNY Mellon), die al bewaar-diensten heeft aangeboden voor de activa van Circle. Onlangs heeft Circle aangekondigd dat het het geld dat nog bij Silicon Valley Bank stond, heeft overgeboekt naar Cross River Bank.</p>
<p>Er zijn sterke redenen waarom Circle ervoor heeft gekozen om zaken te doen met Cross River Bank. Ten eerste wordt de bank ondersteund door verschillende durfkapitalisten die geïnteresseerd zijn in digitale activa, zoals KKR, Ribbit Capital, Andreessen Horowitz en Battery Ventures. Het heeft ook werkrelaties met bedrijven die blootgesteld zijn aan crypto, zoals Stripe en Affirm. Bovendien heeft het een sterke ondersteuning van JPMorgan en Pathword, waar het de fondsen van zijn klanten stort.</p>
<h2 id="h2-Wat20is20Cross20River20Bank896970"><a name="Wat is Cross River Bank?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is Cross River Bank?</h2><p>Nu we hebben besproken hoe Cross River Bank crypto-diensten ondersteunt, laten we begrijpen wat het is en wat het biedt.</p>
<p>Cross River Bank is een door de FDIC verzekerde bank, gevestigd in New Jersey, die diverse bankdiensten aanbiedt aan klanten, waaronder cryptobedrijven. Het heeft de nodige infrastructuur om leningen aan te bieden en crypto-naar-fiat conversies te faciliteren. Na de sluiting van Silvergate Bank, Silicon Valley Bank en Signature Bank hebben veel instellingen die cryptodiensten aanbieden ervoor gekozen om partnerschappen met hen aan te gaan.</p>
<h2 id="h2-Andere20banken20die20instellingen20kunnen20ondersteunen20bij20het20omgaan20met20digitale20activa484162"><a name="Andere banken die instellingen kunnen ondersteunen bij het omgaan met digitale activa" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Andere banken die instellingen kunnen ondersteunen bij het omgaan met digitale activa</h2><p>Naast Cross River Bank en Bank of New York Mellon zijn er andere banken die bankdiensten aanbieden aan cryptobedrijven.</p>
<p>Volgens de Digital Currency Group (DCG), een van de grootste crypto-organisaties die op zoek is naar potentiële bankpartners, zijn er veel banken die bereid zijn om cryptogerelateerde diensten aan te bieden. Deze omvatten maar zijn niet beperkt tot Deutsche Bank (DB), Santander (SAN), HSBC (HSBA), Western Alliance, Mercury, Series Financial Multis, Bank Prove en Bridge.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1680253696651680253579_.pic.jpg" alt=""><br>Digital Currency Group - Cryptotimes</p>
<p>Reeds onderhandelen Western Alliance en Bridge Bank met crypto-bedrijven die hun bankdiensten willen, zoals diensten voor derdenoverschrijvingen, geldmarkten en beperkte effectenhandel. Andere crypto-vriendelijke banken zijn First Foundation Bank, Sutton Bank, Quontic Bank, Customers Bank, Evolve Bank &amp; Trust en Cermak.</p>
<h2 id="h2-Regulerend20toezicht486383"><a name="Regulerend toezicht" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Regulerend toezicht</h2><p>Na de ineenstorting van verschillende banken die verschillende crypto-gerelateerde diensten aanboden, is er een toename van het toezicht op regelgeving in de Verenigde Staten. Bijvoorbeeld, de OCC onlangs <a href="https://www.occ.gov/news-issuances/news-releases/2021/nr-occ-2021-121.html" rel="nofollow noopener noreferrer" target="_blank">zei</a> dat nationale banken moeten ‘aantonen dat ze adequate controles hebben voordat ze bepaalde activiteiten met cryptocurrency, gedistribueerd grootboek en stablecoins kunnen uitvoeren.’</p>
<p>Momenteel is er een voorstel om de bewaarregel uit te breiden tot een ‘safe keeping rule’, die vereist ‘het gebruik van een gekwalificeerde bewaarder voor alle klantactiva (inclusief, expliciet, digitale activa), in plaats van alleen voor klantactiva die ‘klanteffecten’ of ‘klantfondsen’ vormen.</p>
<p>De ineenstorting van FTX en de hoge incidentie van crypto-diefstallen en andere misdrijven in 2022 hebben de noodzaak van nauwere regelgevende controle vergroot.</p>
<h2 id="h2-Conclusie939148"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De zich ontwikkelende cryptomarkt heeft aangetoond dat er verschillende banken zijn die bereid zijn om cryptogerelateerde diensten aan te bieden. Dit volgt op het faillissement van drie banken, Silvergate Bank, Silicon Valley Bank en Signature Bank, die crypto-naar-fiat-conversiediensten aanboden. Bijvoorbeeld, Circle heeft samengewerkt met Cross River Bank en Bank of New York Mellon om de benodigde bankdiensten te verkrijgen.</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 enkele beleggingssuggestie.<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>