UGVyY2jDqSBpbCB0b2tlbiBTY2FsbG9wIChTQ0EpLCBsYSBzdGVsbGEgZGkgRGVGaSBzdWxsYSBibG9ja2NoYWluLCBzdGEgY29udGludWFtZW50ZSBjYWRlbmRvPw==

2025-03-27, 07:07

<p><img src="https://gimg2.gateimg.com/image/article/1743059002Trading.webp" alt=""><br>Scallop è un protocollo di finanza decentralizzata (DeFi) basato sulla blockchain Sui, con servizi di prestito peer-to-peer al suo cuore, noto come il Money Market di prossima generazione nell’ecosistema Sui. Come blockchain Layer 1 ad alte prestazioni, Sui fornisce a Scallop una solida base tecnica con vantaggi come commissioni di transazione basse, elevata capacità di transazione e liquidazione rapida.</p>
<p>Come primo progetto DeFi finanziato ufficialmente dalla Fondazione Sui, Scallop occupa una posizione di rilievo nell’ecosistema Sui, con il suo Valore Totale Bloccato (TVL) in rapida crescita, diventando uno dei principali protocolli di prestito su Sui. Tuttavia, nonostante l’enorme potenziale del progetto, il prezzo del suo token nativo $SCA è continuamente in calo, attirando l’attenzione diffusa della comunità. Questo articolo approfondirà le funzionalità principali di Scallop, esplorerà le possibili ragioni del calo del suo token $SCA e fornirà indicazioni di analisi per gli investitori.</p>
<h2 id="h2-La20funzione20principale20di20Scallop20la20pietra20angolare20dellecosistema20Sui20in20DeFi884574"><a name="La funzione principale di Scallop: la pietra angolare dell’ecosistema Sui in DeFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La funzione principale di Scallop: la pietra angolare dell’ecosistema Sui in DeFi</h2><p>L’obiettivo di design di Scallop è fornire agli utenti servizi finanziari efficienti e sicuri. Le sue funzioni principali includono: gli utenti possono depositare asset crittografati nel protocollo per guadagnare interessi, o prendere in prestito USDC, USDT, SUI e altre criptovalute mediante la collettarizzazione di asset; dopo il deposito, gli utenti riceveranno sCoin (Scallop Market Coins) che rappresentano i loro asset, che possono essere utilizzati per prestiti flash a costo zero e altre operazioni; i prestiti flash supportano l’indebitamento a breve termine senza la necessità di pre-collateralizzazione, rendendoli ideali per l’arbitraggio o il trading veloce.</p>
<p>Inoltre, Scallop utilizza il linguaggio di programmazione Move di Sui per sviluppare smart contract, enfatizzando la sicurezza a livello istituzionale e fornendo strumenti SDK per migliorare la componibilità, rendendo più facile ai developer costruire applicazioni finanziarie più complesse. Scallop ha emesso un’offerta totale di 250 milioni di token $SCA per la governance del protocollo e incentivare la partecipazione degli utenti.</p>
<h2 id="h2-Token20SCA20perch20continui20a20cadere20Analisi20delle20ragioni20multidimensionale527144"><a name="Token $SCA perché continui a cadere? Analisi delle ragioni multidimensionale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Token $SCA perché continui a cadere? Analisi delle ragioni multidimensionale</h2><p>Nonostante l’impressionante performance di Scallop in termini di tecnologia ed ecosistema, il continuo declino del prezzo di $SCA è sconcertante. Ecco più motivi che potrebbero aver portato al calo:</p>
<p><img src="https://gimg2.gateimg.com/image/article/17430591982.png" alt="SCA"></p>
<p>Tendenza complessiva del mercato: pressione sui token in un mercato ribassista<br>Il mercato delle criptovalute è volatile, con le tendenze di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> (BTC) ed <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> (ETH) che spesso fanno da apripista. Se il mercato è in fase ribassista, è difficile per token di piccole e medie dimensioni come $SCA restare da soli, mentre Sui, come ecosistema emergente, potrebbe essere più suscettibile all’effetto amplificatore del sentimento di mercato sui suoi token.</p>
<p>Fondamentali del progetto: Preoccupazioni nascoste riguardo al TVL e all’attività degli utenti<br>Uno degli indicatori principali dei progetti DeFi è il TVL. Se l’importo bloccato di Scallop stagna, la partecipazione degli utenti diminuisce, o c’è una domanda di prestito insufficiente (ad esempio, l’importo dei prestiti è molto inferiore all’importo dei depositi), il mercato potrebbe avere dubbi sul suo potenziale a lungo termine, influenzando così le prestazioni del prezzo di $SCA.</p>
<p>Economia del Token: Rischio di Pressione Vendita del Mining di Liquidità<br>L’offerta totale di $SCA è di 250 milioni, di cui il 45% è allocato per il mining di liquidità. Se il tasso di rilascio del token è troppo veloce o manca di meccanismi di blocco, le vendite di ricompense dei partecipanti precoci potrebbero creare una pressione sostenuta. Inoltre, se il token di governance veSCA non riesce a incentivare efficacemente il mantenimento a lungo termine, potrebbe anche aumentare la pressione delle vendite.</p>
<p>Pressione competitiva: Forte concorrenza nel mercato DeFi<br>Nel settore dei prestiti DeFi, Scallop deve competere con protocolli maturi come <a href="/price/aave-aave" target="_blank" class="blog_inner_link">Aave</a>, <a href="/price/compound-comp" target="_blank" class="blog_inner_link">Compound</a> e altri progetti all’interno dell’ecosistema Sui. Se non è in grado di offrire rendimenti più elevati, commissioni più basse o caratteristiche uniche, gli utenti e i fondi potrebbero fluire verso altre piattaforme, indebolendo la domanda di $SCA.</p>
<p>Attività della community e sentiment del mercato: l’effetto amplificatore del feedback negativo. Attività della community, promozione del progetto e sentiment del mercato sono cruciali per i prezzi dei token. Se il progresso dello sviluppo di Scallop è lento, le funzionalità promesse non vengono consegnate, o sorgono preoccupazioni riguardo alle vulnerabilità della sicurezza, gli investitori potrebbero optare per la vendita, e le discussioni pessimistiche sulla piattaforma X potrebbero ulteriormente amplificare il calo.</p>
<h2 id="h2-Come20giudicare20il20futuro20trend20di20SCA683092"><a name="Come giudicare il futuro trend di $SCA?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come giudicare il futuro trend di $SCA?</h2><p>Come componente core DeFi dell’ecosistema Sui, Scallop ha il potenziale per essere efficiente, sicuro e user-friendly, ma il calo dei prezzi di $SCA riflette l’interazione complessa del mercato, del progetto e dell’ambiente esterno. Per valutare la sua tendenza futura, gli investitori possono concentrarsi sui seguenti punti: controllare il TVL di Scallop e l’attività degli utenti attraverso piattaforme come DeFiLlama per comprendere i fondamentali del progetto; prestare attenzione al piano di sblocco dei token di $SCA per determinare se un gran numero di token entrerà presto sul mercato; sfogliare le discussioni della community della piattaforma X per cogliere il sentiment attuale del mercato.</p>
<h2 id="h2-Conclusione20Opportunit20e20Sfide20di20Scallop20e20SCA780665"><a name="Conclusione: Opportunità e Sfide di Scallop e $SCA" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione: Opportunità e Sfide di Scallop e $SCA</h2><p>I tentativi innovativi di Scallop sull’Sui on-chain hanno portato nuove possibilità al campo DeFi, ma il calo del prezzo di $SCA espone anche le sfide che deve affrontare. Che siano fluttuazioni di mercato, pressioni competitive o aggiustamenti nell’economia del token, Scallop deve continuare a lavorare sulla tecnologia e sulla costruzione della comunità per ravvivare le performance del prezzo di $SCA.</p>
<div class="blog-details-info"><br><div>Autore: Rooick Z., Ricercatore presso Gate.io<div class="info-tips"><em>Questo articolo rappresenta solo le opinioni dell'autore e non costituisce alcun consiglio di trading. Gli investimenti comportano rischi, quindi le decisioni dovrebbero essere prese con cautela.<br></em><div><em></em>Questo contenuto è originale e il copyright è di Gate.io. Si prega di indicare l'autore e la fonte se è necessario ristampare, altrimenti saranno perseguite le responsabilità legali.<br></div><p></p><br></div></div></div>