TGUgZWxlemlvbmkgcHJlc2lkZW56aWFsaSBzY2F0ZW5hbm8gUG9seW1hcmtldCwgc3RhIGRpdmVudGFuZG8gdW5hIG51b3ZhIHRlbmRlbnphIGlsIHRyYWRpbmcgc3VnbGkgZXZlbnRpPw==

2024-08-22, 16:26

<p><img src="https://gimg2.gateimg.com/image/article/17243437211690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR308029"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Le elezioni presidenziali statunitensi del 2024 sono piene di colpi di scena, con un forte senso di argomento, che ha scatenato un gran numero di giocatori che si riversano su Polymarket per predire i risultati delle elezioni. Attualmente, l’importo totale delle scommesse ha superato i 680 milioni di dollari.</p>
<p>Polymarket si distingue nel mercato estremamente competitivo principalmente per la sua efficiente operatività basata sul <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> blockchain, bassi costi di transazione e compatibilità con i metodi di pagamento tradizionali.</p>
<p>Polymarket, un progetto che predice il mercato e il trading degli eventi, si trova ad affrontare sfide e limitazioni, come la regolamentazione legale, la manipolazione del mercato e i rischi di sicurezza dei contratti intelligenti.</p>
<h2 id="h2-Introduzione804365"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Recentemente, con il tema caldo delle elezioni presidenziali degli Stati Uniti che si riscalda, molti utenti hanno iniziato a scommettere sui risultati delle elezioni e l’accordo sul mercato delle previsioni Polymarket è rapidamente diventato popolare, diventando un nuovo punto focale del mercato.</p>
<p>Il seguente testo si concentrerà su Polymarket, rivelando lo stato di sviluppo e le opportunità per la partecipazione nei mercati di previsione e trading degli eventi.</p>
<h2 id="h2-Le20scommesse20sulle20elezioni20presidenziali20si20infiammano20Polymarket20guadagna20popolarit645970"><a name="Le scommesse sulle elezioni presidenziali si infiammano, Polymarket guadagna popolarità" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le scommesse sulle elezioni presidenziali si infiammano, Polymarket guadagna popolarità</h2><p>Come noto mercato di previsione on-chain di Polygon, Polymerket ha rapidamente guadagnato popolarità nelle recenti discussioni sulle elezioni statunitensi e sta diventando un importante campo di prova per i giochi di intelligenza collettiva.</p>
<p>Al contrario, se la previsione è sbagliata e Trump non riesce a vincere le elezioni, gli utenti che detengono quote “No” non dovranno pagare commissioni aggiuntive. Tuttavia, le loro quote “Yes” precedentemente acquistate diventeranno invalide, il che significa che non riceveranno alcun rendimento.<img src="https://gimg2.gateimg.com/image/article/17243438091.jpg" alt=""><br>Origine: Polymarket</p>
<p>Secondo le regole della piattaforma, gli utenti scelgono di acquistare quote “sì” o “no” per scommettere sui risultati delle elezioni, utilizzando il prezzo (probabilità) per riflettere il giudizio di probabilità del consenso di mercato. Nel mercato delle previsioni della “Vincitore delle elezioni presidenziali 2024” nel grafico sopra, il 52,7% di “Sì” può essere interpretato come la stima attuale del mercato del tasso di vittoria di Trump pari al 52,7%. Se l’utente approva il tasso di vittoria, acquisterà “Sì”. Se Trump vince, guadagnerà 47,3 centesimi per azione. Al contrario, se la previsione è errata e Trump non riesce a vincere le elezioni, gli utenti che detengono quote “No” non dovranno pagare commissioni aggiuntive, ma le loro azioni precedentemente acquistate di “Sì” diventeranno invalide, il che significa che non riceveranno alcun rendimento.</p>
<p>Non è difficile scoprire che questo meccanismo motiva gli utenti a fare previsioni accurate basate sul giudizio personale e le informazioni di mercato per perseguire potenziali rendimenti o correre rischi. Non solo riflette la capacità di decisione dei partecipanti al mercato, ma dimostra anche come il mercato delle previsioni regoli dinamicamente le aspettative per gli eventi futuri basandosi sull’intelligenza collettiva.</p>
<p>La corsa attuale alle elezioni presidenziali è diventata molto più calda rispetto ad altri giochi a causa di notizie come lo sparo di Trump e il ritiro di Biden, e i scommettitori di mercato hanno ripetutamente aggiustato le loro scommesse man mano che la situazione si evolve.</p>
<p>Secondo le statistiche di Dune Analyst, il tasso di vittoria della campagna presidenziale di Trump è arrivato fino al 71% dopo essere stato colpito. Successivamente, con il ritiro di Biden, il tasso di vittoria dell’attuale Vice Presidente Harris come candidato presidenziale è continuato a salire ed ora ha leggermente superato quello di Trump.<img src="https://gimg2.gateimg.com/image/article/17243438352.jpg" alt=""><br>Origine: Analista di Dune</p>
<p>Naturalmente, i giocatori su Polymarket possono non solo indovinare l’esito base delle elezioni, ma anche la possibilità di Biden di ritirarsi dalla corsa, prevedere il popolare candidato vicepresidente repubblicano J.D. Vance e il vocabolario che potrebbe essere coinvolto nella conversazione di Trump con Musk. Queste previsioni arricchiscono notevolmente le dimensioni delle discussioni sulle elezioni e mostrano le prospettive diverse e la creatività della base degli utenti.</p>
<p>Gli eventi di scommesse su Polymarket non sono limitati alle elezioni presidenziali, ma includono anche diversi argomenti come criptovalute, sport e cultura popolare, ad esempio prevedere il paese con il maggior numero di medaglie olimpiche, prevedere le performance al botteghino dei film, prevedere i risultati della Premier League e prevedere il numero di tagli ai tassi di interesse della Federal Reserve. Finché si tratta di un evento di attualità, possono essere create scommesse per indovinare il gioco.</p>
<h2 id="h2-Come20Polymarket20diventa20popolare513469"><a name="Come Polymarket diventa popolare?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come Polymarket diventa popolare?</h2><p>Sin dalla sua fondazione nel 2020, Polymarket ha rapidamente guadagnato terreno nei mercati predittivi grazie alla sua innovativa tecnologia blockchain e al suo modello decentralizzato.</p>
<p>In quel momento, la pandemia globale infuriava, il mondo era in preda al panico, i canali di diffusione delle informazioni erano bloccati e la situazione reale era difficile da riflettere accuratamente. Così, il fondatore, Shayne Coplan, si è ispirato a ‘L’applicazione della conoscenza nella società’ di Hayek e ha ritenuto che gli incentivi economici dovrebbero essere applicati per prevedere i mercati al fine di riflettere veramente le opinioni o i punti di vista delle persone su un certo evento.</p>
<p>Ha fatto riferimento e migliorato il primo mercato delle previsioni Augur basato su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, con il primo tema di scommessa che riguarda l’orario di riapertura della città di New York durante la pandemia.</p>
<p>Vitalik Buterin ha espresso anche un punto di vista ottimista sul mercato delle previsioni di quell’anno: “Prevedo che nei prossimi anni il mercato delle previsioni diventerà una tecnologia applicativa sempre più importante per Ethereum. Le elezioni US del 2020 sono solo l’inizio e il mercato delle previsioni attirerà sempre più attenzione, non solo per le elezioni, ma anche per le previsioni sulle condizioni, le decisioni e altre applicazioni dell’ecosistema.”</p>
<p>Dopo anni di profonda coltivazione, la piattaforma è diventata finalmente popolare nel maggio di quest’anno grazie a un gran numero di utenti che scommettevano sull’esito delle elezioni presidenziali degli Stati Uniti. Il volume di trading è continuato ad aumentare. Come mostrato nella figura qui sotto, il volume di trading ha superato i 100 milioni di dollari a giugno e si è avvicinato ai 400 milioni di dollari in luglio. Si prevede che supererà 1 miliardo di dollari entro la fine dell’anno.<br><img src="https://gimg2.gateimg.com/image/article/17243438753.jpg" alt=""><br>Fonte: Analista di Dune</p>
<p>Questa significativa crescita non ha solo attirato l’attenzione degli esperti di campagne, degli analisti politici e delle figure pubbliche come Trump, ma ha anche conquistato il favore degli investitori, tra cui Founders Fund e il co-fondatore di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Vitalik Buterin, con un finanziamento cumulativo di 74 milioni di dollari.<img src="https://gimg2.gateimg.com/image/article/17243438904.jpg" alt=""><br>Origine: ROOTDATA</p>
<p>Polymarket si distingue nel mercato estremamente competitivo principalmente grazie alla sua efficiente operatività basata sulla blockchain di Polygon, ai bassi costi di transazione e alla compatibilità con i metodi di pagamento tradizionali (come ad esempio consentire agli utenti di utilizzare carte bancarie o di credito per acquistare USDC per effettuare scommesse tramite MoonPay).</p>
<p>Inoltre, la piattaforma ha attirato con successo molti investitori al dettaglio attraverso strategie di marketing estensive, compresa una partnership con il canale Reddit WallStreetBets.</p>
<p>È importante notare che l’accordo non ha ancora esplicitamente stabilito l’emissione di token, e continueremo a monitorare questo.</p>
<h2 id="h2-La20follia20dei20MEME20svanisce20il20trading20di20eventi20diventer20una20nuova20tendenza20sulla20catena511502"><a name="La follia dei MEME svanisce, il trading di eventi diventerà una nuova tendenza sulla catena?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La follia dei MEME svanisce, il trading di eventi diventerà una nuova tendenza sulla catena?</h2><p>Il vantaggio principale dei protocolli di trading di eventi rappresentati da Polymarket rispetto alle piattaforme tradizionali è il suo meccanismo di mercato decentralizzato e l’esecuzione trasparente dei contratti intelligenti.</p>
<p>Per i MEME che si concentrano nel cogliere opportunità di vendita, informazioni riservate e una grande quantità di informazioni inefficaci, la partecipazione degli utenti nella previsione degli eventi è più interessante, relativamente equa e pura. Questo è anche un motivo importante per cui il mercato delle previsioni sta diventando sempre più attivo.</p>
<p>Gli utenti possono effettuare scommesse su vari eventi sulla piattaforma, tra cui elezioni politiche, eventi sportivi, trend cripto, ecc. I risultati delle scommesse sono determinati dalla saggezza collettiva e dal consenso dei partecipanti al mercato e vengono automaticamente regolati tramite smart contract. Questo modello di scommesse “tutto o niente” motiva gli utenti a condurre ricerche più approfondite e fare previsioni più accurate, contribuendo così a creare giochi più intelligenti e discussioni sociali, arricchendo notevolmente l’adozione pratica della tecnologia cripto.</p>
<p>Tuttavia, progetti come Polymarket che prevedono il trading di mercati ed eventi affrontano anche alcune sfide e limitazioni.</p>
<ol>
<li><p>Rischi legali e normativi: Polymarket, una attività di gioco d’azzardo, è soggetta a rigide restrizioni normative in molte giurisdizioni. La CFTC lo ha multato per 1,4 milioni di dollari e ha richiesto di interrompere gradualmente i suoi servizi negli Stati Uniti. Attualmente, vi sono ancora numerosi utenti americani che partecipano alle scommesse tramite questa piattaforma, e questa limitazione giurisdizionale rappresenta il più grande ostacolo all’adozione pratica di tali piattaforme.<img src="https://gimg2.gateimg.com/image/article/17243439305.jpg" alt=""><br>Fonte: CFTC</p>
</li><li><p>La mancanza di liquidità porta a errori di gioco: nonostante l’aumento del volume di scambi durante eventi popolari come le elezioni negli Stati Uniti, la mancanza di liquidità in altri mercati di nicchia può impedire il corretto meccanismo di scoperta dei prezzi, portando a dispute e perdite non necessarie.</p>
</li><li><p>Fiducia e equità degli utenti: l’influenza dei fondi dei partecipanti al mercato, dell’opinione pubblica e di altri fattori può portare alla manipolazione dei prezzi, e alcuni eventi possono comportare differenze di opinioni degli utenti a causa di differenze nei criteri di valutazione. Pertanto, stabilire un ambiente di mercato equo è una questione chiave che Polymarket deve affrontare.</p>
</li><li><p>Rischio della concorrenza tra pari: Con il boom del mercato delle previsioni, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> L’ecosistema Drift Protocol del mercato delle previsioni B.E.T, il Protocollo di previsione dell’ecosistema Sui Karma Protocol e altri sono stati lanciati uno dopo l’altro, intensificando la concorrenza nel settore.</p>
</li></ol>
<p>In breve, Polymarket è diventato un importante indicatore dell’opinione pubblica nelle elezioni presidenziali, e ci si aspetta che la piattaforma utilizzi questa opportunità per espandere i suoi argomenti di previsione e aprire spazi di mercato in questo campo. L’esplosione di Polymarket non solo riflette il forte interesse dell’attuale generazione più giovane negli eventi politici, ma dimostra anche che il mercato predittivo, come un nuovo modo di aggregazione delle informazioni e di scambio di punti di vista, sta gradualmente cambiando le tradizionali discussioni politiche e la realtà della <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a>.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Carl Y.</strong>, Ricercatore Gate.io<br><div>Traduttore: Joy Z.<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti di questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>