Z2F0ZUxpdmUgQU1BIFJlY2FwLVR1cnRzYXQ=

2023-12-29, 03:05

<p><img src="https://gimg2.gateimg.com/image/article/1703817440blog.jpg" alt=""></p>
<h2 id="h2-Per20favore20presentaci20Tursat20e20la20sua20posizione668697"><a name="Per favore, presentaci Tursat e la sua posizione." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Per favore, presentaci Tursat e la sua posizione.</h2><p><strong> Peter da Turtsat: </strong><br>Turtsat è una piattaforma aperta guidata dalla comunità per gli Ordinals e la nostra missione è essere il <a href="/price/gitcoin-gtc" rel="nofollow noopener noreferrer" target="_blank">Gitcoin</a> dell’ecosistema degli Ordinals, dove tutti costruiscono, donano e influenzano gli Ordinals tramite Turtsat.</p>
<p>Turtsat ha costruito un protocollo di donazione PSBT di base che abbassa efficacemente la barriera alla partecipazione e incoraggia più sviluppatori e membri della comunità a partecipare all’ecosistema di Ordinals. Questo protocollo non solo rende lo sviluppo di Ordinals più inclusivo, ma crea anche una più ampia gamma di opportunità per i partecipanti a beneficiare dell’ecosistema.</p>
<p>Allo stesso tempo, Turtsat sta costruendo una grande comunità di Tartarughe, con membri della comunità provenienti da Cina, Stati Uniti, Corea del Sud, India e molte altre regioni nazionali, che trasformeranno il mondo plasmato dagli Ordinals. Collegando la comunità e collaborando con organizzazioni influenti, lavoreremo insieme per guidare il futuro del protocollo Ordinals e <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ecosistema.</p>
<h2 id="h2-Per20favore20parlateci20dello20sviluppo20passato20e20dei20futuri20piani20di20Turtsat408008"><a name="Per favore, parlateci dello sviluppo passato e dei futuri piani di Turtsat." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Per favore, parlateci dello sviluppo passato e dei futuri piani di Turtsat.</h2><p><strong>Peter Da Turtsat：</strong><br>Turtsat è nata all’avvento del protocollo Ordinals ed è cresciuta con l’ecosistema BRC20. Dall’avvio del nostro primo progetto nel Q3 2023, abbiamo continuato a lanciare 7 progetti nella categoria infrastrutturale degli Ordinals, tra cui il protocollo degli asset BRC20 Chamcha-$CHAX, il ponte cross-chain BRC20 Multbit-$MUBI, la piattaforma di aggregazione Nhubs-$NHUB e la piattaforma di prestiti degli Ordinals $DOVA.</p>
<p>È ovvio per tutti che il lancio di successo di questi progetti contribuirà allo sviluppo dell’ecosistema di Ordinals, mentre molti utenti partecipanti hanno anche ottenuto considerevoli profitti da questi progetti, e credo che molti dei nostri amici abbiano appreso della nostra piattaforma Turtsat attraverso questi progetti e si siano uniti alla comunità delle Tartarughe.</p>
<p>Allo stesso tempo, la nostra cooperazione ecologica e lo sviluppo non si sono mai fermati, che si tratti del supporto tecnico iniziale da parte di Unisat, OKX, ecc., o dello sviluppo ecologico della cooperazione con Galxy, Port3 e altre piattaforme, e la cooperazione ecologica di Ordinals con DWF Labs, ecc., sempre più famose organizzazioni influenti sono gradualmente coinvolte nella cooperazione con Turtsat, e promuovono congiuntamente lo sviluppo ecologico di Ordinals. Sempre più famosi influencer stanno gradualmente partecipando alla cooperazione con Turtsat, e promuovendo congiuntamente i passi avanti ecologici di Ordinals.</p>
<p>Turtsat è molto grato per il supporto di questi partner ecologici e degli utenti, ricordando sempre l’intenzione originale di andare avanti. In futuro, la pianificazione di Turtsat sarà divisa in tre fasi principali:<br>Continuare a introdurre e lanciare più progetti di alta qualità di Ordinals, e questo processo sarà gradualmente aperto alla comunità.</p>
<p>Attorno alla costruzione e allo sviluppo dell’ecosistema Ordinals, mano nella mano con i nostri partner per fornire supporto completo e aiuto per i progetti open source o i costruttori di Ordinals.</p>
<p>Arricchire l’infrastruttura di Turtsat, fornire agli utenti e agli sviluppatori più strumenti che possono essere applicati all’ecosistema Ordinal, per aiutarli a partecipare alla costruzione dell’ecosistema Ordinal in modo più facile.</p>
<h2 id="h2-Per20favore20parlati20del20token20della20piattaforma20Turtsat20TURT493709"><a name="Per favore, parlati del token della piattaforma Turtsat $TURT." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Per favore, parlati del token della piattaforma Turtsat $TURT.</h2><p><strong>Peter da Turtsat:</strong><br>$TURT è un token di piattaforma con attributi MEME emesso dalla piattaforma Turtsat su BRC20, con un’offerta totale costante di 1 miliardo. Di questi, il 7,5% è stato distribuito tramite airdrop agli utenti Ordinals, il 7,5% è stato utilizzato per la donazione privata anticipata di Turtsat e l’80% rimanente è stato distribuito alla comunità delle Tartarughe tramite donazione pubblica in una fase iniziale, ad eccezione del 5% riservato allo sviluppo futuro.</p>
<p>$TURT ha ora realizzato la circolazione su doppia catena BRC20 e ERC20. Chiunque può scambiare i token $TURT BRC20 e ERC20 in entrambe le direzioni tramite il ponte cross-chain Multibit.</p>
<p>Attualmente, oltre all’attributo MEME, i token $TURT possono anche partecipare al pooling di Turtsat. Gli utenti possono mettere in gioco i token $TURT per ottenere i token $EGGS e poi utilizzare i token $EGGS per ottenere la qualifica di Whitelist per il progetto di lancio della piattaforma Turtsat.</p>
<p>In futuro, con lo sviluppo della piattaforma Turtsat, $TURT sarà applicabile anche a ulteriori scenari d’uso. Tra cui, ma non limitati a: eco-governance, votazione per il lancio di progetti, riscatto di pacchetti regalo cooperativi, ecc.</p>
<h2 id="h2-Come20dovrebbero20partecipare20gli20utenti20a20Turtsat20nella20fase20attuale763280"><a name="Come dovrebbero partecipare gli utenti a Turtsat nella fase attuale?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come dovrebbero partecipare gli utenti a Turtsat nella fase attuale?</h2><p><strong>Peter Da Turtsat:</strong><br>Per gli utenti della community, se desideri partecipare alle donazioni per il lancio del progetto sulla piattaforma Turtsat, potresti avere bisogno di qualificarti prima per la whitelist delle donazioni per il lancio del progetto.</p>
<p>In genere abbiamo due fasi di lancio per Alpha Whitelist e Beta Whitelist. Alpha Whitelist può essere riscattata utilizzando $EGGS, e abbiamo una finestra di riscatto WL aperta 24 ore prima di ogni lancio. Diventare nostro Ambasciatore della Comunità delle Tartarughe ti consentirà anche di ottenere opportunità di partecipazione assegnate dalla piattaforma, e puoi ottenere anche Beta Whitelist tramite eventi della comunità, estrazioni di KOL, ecc.</p>
<p>I fondatori e i costruttori di progetti open source che desiderano candidarsi per il lancio dei loro progetti su Turtsat possono creare una domanda direttamente sul nostro sito ufficiale tramite “Apply”, oppure possono contattarci tramite il nostro account Twitter o Telegram ufficiale.</p>
<h2 id="h2-Quali20vantaggi20porter20la20partnership20con20Gateio20a20TurtSat20e20ai20suoi20utenti40921"><a name="Quali vantaggi porterà la partnership con Gate.io a TurtSat e ai suoi utenti?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quali vantaggi porterà la partnership con Gate.io a TurtSat e ai suoi utenti?</h2><p><strong> Peter From Turtsat: </strong><br>Gate.io è un noto leader del settore dei top CEX, con un gran numero di utenti e un’ampia influenza, Turtsat è molto onorata di poter stabilire una collaborazione con Gate, che sarà importante e di vasta portata per lo sviluppo della piattaforma Turtsat.</p>
<p>Ciò accelererà la diffusione dell’influenza di Turtsat e lo sviluppo della costruzione ecologica, e sarà anche in grado di aiutare $TURT ad ottenere una migliore liquidità al di fuori dell’ecosistema, e gli utenti potranno ottenere più comodità e opportunità di espansione del valore. Incoraggiamo gli utenti della comunità Turtle a fare trading di $TURT su Gate e diamo il benvenuto anche a nuovi partner che partecipino all’ecosistema TurtSat e si uniscano a noi nella costruzione, donazione e influenza degli Ordinali.</p>
<div class="blog-details-info"><br><div>Autore:<strong> GateLive</strong>, Team Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce suggerimenti di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del diritto d'autore.<br></div><p></p><br></div></div></div>