44CQR3VpZGEgYWxsYSByaWNlcmNh44CRSW50ZXJwcmV0YXppb25lIGRlbCBudW92byBuYXJyYXRpdm8gTkZUIGRpIEJpdGNvaW4gUHJvdG9jb2wgT3JkaW5hbHPvvZxUb2tlbiBCUkMtMjDvvZxCaXRjb2luIFN0YW1wcyAoUGFydGUgMSk=

2023-05-10, 03:44

<p><img src="https://gimg2.gateimg.com/blog/1679447454770827393baogao.jpeg" alt=""></p>
<p>🌟 Dal lancio del protocollo di implementazione di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> NFT Ordinals il 14 dicembre 2022, al 5 maggio di quest’anno sono stati coniati più di 3,7 milioni di NFT basati sul protocollo. Galaxy Research prevede che le dimensioni del mercato degli NFT Bitcoin si espanderanno fino a 4,5 miliardi di dollari entro il 2025. L’ecosistema Bitcoin NFT è diventato una nuova narrativa, incluso il nuovo esperimento “BRC-20” basato sul protocollo Ordinals, che crea anche un nuovo standard di token e un gameplay ecologico.</p>
<p>Quali sono i rischi e le opportunità di Bitcoin NFT? Quali sono le controversie sul protocollo Ordinals? Quali sono i progetti interessanti nell’ecosistema Ordinals? Cos’è BRC-20, che è diventato improvvisamente popolare di recente? In questo articolo di ricerca, ti sveleremo tutto uno per uno.</p>
<p>Selezione di fonti di informazione sulla ricerca di Bitcoin NFT nell’indice.<br><img src="https://gimg2.gateimg.com/image/article/168368908211.jpg" alt=""></p>
<h2 id="h2-Panoramica20di20Bitcoin20NFT198206"><a name="Panoramica di Bitcoin NFT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Panoramica di Bitcoin NFT</h2><p>1、【Inglese】Galaxy Research: entro il 2025, le dimensioni del mercato NFT di Bitcoin raggiungeranno i 4,5 miliardi di dollari (04/03/2023)</p>
<p>Introduzione: Da dicembre 2022, sono state forgiati oltre 200.000 incisioni sulla rete Bitcoin. Il 27 febbraio 2023, Yuga Labs ha annunciato il lancio della serie di NFT TwelveFold basata su Bitcoin, la prima nuova serie di NFT emessa su Bitcoin. Secondo Galaxy Research, entro il 2025 le dimensioni del mercato dei NFT di Bitcoin si espanderanno fino a 4,5 miliardi di dollari.</p>
<p>Le incisioni ampliano lo spazio di progettazione di Bitcoin, aggiungendo una notevole capacità di archiviazione dati e una potente garanzia di disponibilità, aprendo varie casistiche, tra cui nuove tecnologie decentralizzate o estensioni di Bitcoin. Nuovi casi d’uso, che spingono l’interesse e l’adozione di Bitcoin, si verificheranno sia nel mercato NFT che in altri mercati; le incisioni riducono il requisito di spazio del blocco, favorendo la sicurezza e il mercato dei costi di Bitcoin. I minatori otterranno maggiori entrate dalle incisioni, favorendo il passaggio dalle sovvenzioni del blocco alle commissioni di transazione; l’infrastruttura di mercato che supporta gli NFT di Bitcoin sarà completata nel secondo trimestre del 2023, e nuovi portafogli, mercati e altri strumenti saranno ampiamente utilizzati in breve tempo.</p>
<p>L’emergere dei NFT di Bitcoin è una vera rinascita narrativa, che metterà alla prova le concezioni esistenti degli utenti e degli investitori sul valore di Bitcoin come valuta, strato di regolamento e protocollo applicativo; le iscrizioni diventeranno il luogo di residenza per collezioni di alto valore, soddisfacendo progetti artistici di alta qualità e 1 su 1 di valore. I PFP tradizionali e le collezioni ad alta tiratura rimarranno principalmente su catene come Ethereum; il coinvolgimento di Yuga spingerà altri artisti a partecipare, il che potrebbe a sua volta stimolare i principali mercati NFT come OpenSea.</p>
<p>Gli investimenti a rischio si stanno posizionando, ma potrebbero rimanere delusi. Sebbene ci siano opportunità e potenziali di crescita per le incisioni, la tecnologia di mercato altamente decentralizzata e open source di Bitcoin porterà a molte opportunità mancate per la monetizzazione degli strumenti; Bitcoin non ha contratti intelligenti e non può eseguire royalty. Una tendenza più ampia nell’ecosistema degli NFT è la mancanza di royalty o l’assoluta mancanza di esecuzione; ci potrebbero essere molte transazioni di seconda mano nel mercato delle incisioni. Sebbene il costo dell’incisione sia elevato, trasferire un’incisione non comporta costi più elevati rispetto ad altre transazioni. Il costo di trasferimento degli NFT su Bitcoin è inferiore rispetto a Ethereum, quindi gli utenti potrebbero essere più propensi a negoziare attivamente le incisioni; 【originale in inglese】</p>
<p>Le soluzioni di scalabilità di Bitcoin diventeranno sempre più importanti. Con l’aumento significativo delle commissioni di transazione sulla blockchain, le transazioni di Bitcoin che dipendono da soluzioni di pagamento di secondo livello come la rete Lightning saranno cruciali. Il prossimo protocollo di creazione di asset basato sulla rete Lightning, Taro, potrebbe spostare alcune attività legate agli NFT su L2. Taro può beneficiare dell’effetto del numero d’ordine e offrire alternative praticabili per diverse categorie di utenti, aumentando così le opportunità di guadagno dei nodi di instradamento della rete Lightning e offrendo una maggiore scalabilità all’intero ecosistema di Bitcoin.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16836894252.jpg" alt=""></p>
<ol>
<li>Confronto tra Bitcoin NFT ed <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> NFT: vantaggi, svantaggi e sfide (20/02/2023)<br>Introduzione: La popolarità di Bitcoin NFT non diminuisce e il numero di incisioni sta per superare i 150.000. Dennis, CTO di Blockworks, confronta i vantaggi e gli svantaggi di Bitcoin NFT ed Ethereum NFT in base alle caratteristiche tecniche e spiega le sfide che Bitcoin NFT deve affrontare nei processi di acquisto e scambio.</li></ol>
<p>I file NFT di Ethereum sono presenti nei contratti intelligenti o nelle piattaforme di hosting dei contratti, mentre i file NFT di Bitcoin sono memorizzati sulla blockchain, quindi sono limitati dalla dimensione del blocco di Bitcoin. La dimensione massima di un file Ordinal è di 4 MB, il che rende impossibile la visualizzazione di enormi video di animazione 3D e rende anche difficile la creazione di NFT su Bitcoin.1⁄1Potenziali ragioni riconosciute dagli artisti. [Originale in inglese]</p>
<p>Per impostazione predefinita, ogni epigrafe è legata a 10000 stats (0.0001 BTC). Questo è l’importo minimo per un’epigrafe, e l’utente deve anche pagare la tassa mineraria in base alle dimensioni dell’immagine. Ad esempio, con un tasso di 10 sats/vB, l’utente deve pagare 2500 sats (0.000025 BTC) per ogni kb di dimensione dell’immagine. Tecnicamente, ci possono essere solo 10K epigrafi per BTC, mentre i contratti intelligenti su Ethereum possono creare un numero illimitato di NFT. Questo concetto rende gli NFT di Bitcoin più rari degli NFT di Ethereum.</p>
<p>Sfida: 1. desiderare <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">acquistare Bitcoin</a> Gli NFT richiedono l’esecuzione di un nodo Bitcoin completamente sincronizzato e un portafoglio ord; 2. Il trasferimento comporta rischi significativi; 3. Poiché attualmente non esiste un’opzione di transazione senza fiducia nello standard ufficiale di Bitcoin, creare un mercato user-friendly come Opensea non è facile.</p>
<p>3、Forbes: Rischi e opportunità dei Bitcoin NFT visti dal boom degli Ordinals (18/02/2023)</p>
<p>Introduzione: Il protocollo Ordinals consente di aggiungere NFT alle transazioni di Bitcoin, ma le opinioni al riguardo sono divergenti. Leeor Shimron, autore di Forbes, analizza i rischi e le opportunità dei Bitcoin NFT a partire dalla controversia degli Ordinals. Articolo tradotto da Chaincatcher.</p>
<p>I puristi del Bitcoin che si oppongono al progetto Ordinals ritengono che Ordinals sia solo spam nello spazio del blocco che ostruisce lo spazio e occupa lo spazio delle transazioni finanziarie legittime sulla rete. Ma i sostenitori ritengono che Ordinals aumenta la domanda di spazio del blocco, promuove lo sviluppo di un mercato di tariffe sane e consente ai minatori di ottenere incentivi proteggendo la sicurezza della rete.</p>
<p>Opportunità: gli ordini hanno aumentato i guadagni delle commissioni dei minatori, assicurando che i blocchi siano pieni e attirando l’attenzione di nuovi utenti e sviluppatori di Bitcoin. La marcatura delle transazioni in Bitcoin potrebbe incoraggiare ulteriori esperimenti e sviluppi nella rete, stimolando nuove innovazioni nell’ecosistema Bitcoin. Altri artisti e collezioni NFT potrebbero distribuire nuovi NFT su Ordinals.</p>
<p>Rischio: Una parte del valore crescente dei progetti NFT di Ordinals potrebbe essere attribuita al fatto che rappresentano i ‘primi’ progetti implementati su un protocollo, ma rimangono comunque investimenti principalmente speculativi. Come altri standard NFT, le questioni legate alla proprietà intellettuale dei NFT di Bitcoin rimangono irrisolte. I progetti NFT basati su Ethereum hanno sviluppato meccanismi innovativi per la royalty degli artisti e le aste, resta da vedere se queste strutture possono essere riutilizzate su Bitcoin.</p>
<p>4、【Lunga promozione in inglese】Punto di vista: Gli NFT di Bitcoin sono più probabili a portare innovazione sociale piuttosto che innovazione tecnologica (2023/02/12)</p>
<p>Introduzione: Gli Ordinals NFT lanciati sulla mainnet di Bitcoin come argomento caldo della scorsa settimana hanno suscitato numerosi dibattiti positivi e negativi. Teng Yan, ricercatore di Delphi Digital, ha riconosciuto il valore storico dei primi 1000 Ordinals, ma ritiene anche che, a causa delle limitazioni tecniche, i NFT di Bitcoin siano più probabili a portare innovazioni sociali piuttosto che tecnologiche.</p>
<p>“Teoria degli “Oggetti Storici”: nel mondo degli NFT, l’origine storica è considerata molto importante. Allo stesso modo, ritengo che il maggior valore storico sarà attribuito ai primi 1000 Ordinals interessanti: unici”.1⁄1Opere e comunità di piccole dimensioni. Attualmente, Ordinals ha oltre 40000 iscrizioni, nulla che superi le 10000 è probabilmente particolarmente prezioso puramente in base all’origine. [originale in inglese]</p>
<p>L’istinto suggerisce che l’unico tipo di NFT significativo su Bitcoin sia quello di archiviazione del valore, come ad esempio le opere d’arte di alta qualità. Rispetto agli NFT di Ethereum, la programmabilità degli NFT di Ordinals è estremamente limitata, il che ne limita gravemente le possibilità d’uso. Bitcoin non ha nemmeno una comunità NFT, e l’infrastruttura e gli strumenti NFT sono praticamente nulli.</p>
<p>Ci sono abbastanza costruttori su Bitcoin che vogliono davvero creare qualcosa di innovativo con questi NFT? Se c’è davvero innovazione, la mia ipotesi è che sia più probabile che si tratti di un’innovazione sociale, come una comunità unica o una DAO che sfrutta questi NFT, piuttosto che di un’innovazione tecnologica. [Originale in inglese]</p>
<h2 id="h2-Interpretazione20del20protocollo20di20realizzazione20di20Bitcoin20NFT20Ordinals479654"><a name="Interpretazione del protocollo di realizzazione di Bitcoin NFT Ordinals" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Interpretazione del protocollo di realizzazione di Bitcoin NFT Ordinals</h2><p>1️⃣️ Una guida completa ai principi di base del protocollo Ordinals e al sistema di rarità di ‘聪’ (20/03/2023) Introduzione: l’avvento del protocollo Ordinals ha cambiato l’ecosistema del Bitcoin. Lo studioso di crittografia Wang Yishi analizza i principi di base di Ordinals e presenta il sistema di rarità di ‘聪’, sostenendo che il numero di serie dell’iscrizione non è necessariamente correlato al valore collezionistico.</p>
<p>Ogni Bitcoin può essere diviso in 100.000.000 di unità chiamate satoshi (o sats) in cinese. Il protocollo Ordinals propone di ordinare i satoshi in un determinato ordine, assegnando loro un numero ordinale e poi collegandoli ad altre informazioni: immagini, testi, video o persino una sequenza di codice. In questo modo, ogni satoshi diventa unico e non sostituibile. Questo equivale a dare ai Bitcoin la capacità nativa di creare NFT.</p>
<p>Nucleo del protocollo: 1) Ogni numero ‘聪’ è univoco. 2) First in, first out, ovvero l’ordinamento dei numeri ‘聪’ è determinato dall’indice nella transazione di output. Il sistema di rarità dei ‘聪’ è composto da una serie di eventi regolari: 1) Blocchi; 2) Regolazione della difficoltà; 3) Riduzione della ricompensa del blocco; 4) Cicli, ogni 6 volte la riduzione e la regolazione della difficoltà si verificano contemporaneamente. Questo viene chiamato ‘sovrapposizione’, e l’intervallo di tempo tra due sovrapposizioni è chiamato un ‘ciclo’.</p>
<p>Livello di rarità ‘C’ 1) Normale, non il primo ‘C’ nel blocco. 2) Raro, il primo ‘C’ in ciascun blocco. 3) Raro, il primo ‘C’ in ogni periodo di regolazione della difficoltà. 4) Epico, il primo ‘C’ in ogni periodo di dimezzamento. 5) Leggendario: il primo ‘C’ in ogni ciclo. 6) Mitico: il primo ‘C’ nel blocco della creazione. Tuttavia, il numero di serie e il valore collezionistico della scrittura non sono necessariamente correlati.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16836895613.png" alt=""></p>
<p>2⃣️ Analisi del nuovo racconto in inglese su Bitcoin Ordinals: Non solo ‘Bitcoin NFT’ (20/02/2023)<br>Introduzione: Negli ultimi mesi, sono stati coniati quasi 140.000 Bitcoin Ordinals NFT. L’istituto di ricerca criptata Delphi Digital ha esplorato e analizzato gli Ordinals dal modo in cui sono stati coniati, le differenze con gli NFT e l’impatto su Bitcoin.</p>
<p>La teoria degli ordinali assegna a ogni satoshi di Bitcoin un numero univoco. L’utente inserisce i dati in questi satoshi specifici, che può cambiare fondamentalmente la fungibilità del Bitcoin. Questi metadati registrati sugli ordinali esistono per sempre sul Bitcoin e i dati registrati vengono completamente conservati sulla catena attraverso lo  di spesa di Taproot. Questo è in netto contrasto con la tradizionale forma NFT in cui i dati vengono tendenzialmente conservati su server centralizzati.</p>
<p>Esistono delle sottili differenze tra Ordinals e NFT. Gli sviluppatori possono utilizzare NFT illimitati per creare contratti, mentre gli Ordinals sono limitati dalla quantità di satoshi in ciascun blocco. In teoria, la dimensione massima di ogni blocco di Bitcoin dovrebbe essere di 1 MB, ma con l’ausilio di SegWit e Taproot, gli utenti di Ordinal possono aggiungere 3 MB di dati a ciascun blocco. Con l’aumento delle commissioni e la crescita delle dimensioni dei blocchi, si aumenta il budget di sicurezza di Bitcoin e la redditività dei minatori.</p>
<p>Blocchi più grandi significano che i nodi Bitcoin devono memorizzare più dati man mano che la catena cresce. Con l’aumento delle esigenze di archiviazione dei nodi, ciò potrebbe portare alla centralizzazione di Bitcoin. Allo stesso tempo, le commissioni pagate ai miner sono state aumentate. Gli ordinali rappresentano già il 12,5% delle commissioni giornaliere di Bitcoin. Ordinals porta una nuova base di utenti a Bitcoin: gli utenti iscrivono commissioni per mantenere la catena, mentre Ordinals porta sia sicurezza che cultura alla catena. [Originale in inglese]</p>
<p><img src="https://gimg2.gateimg.com/image/article/16836895984.jpeg" alt=""></p>
<p>3⃣️ Bitcoin NFT ‘Time for Reclamation’: Ordinals protocol, FOMO and debates (09/02/2023)<br>Introduction: On January 21st, Casey Rodarmor, a core contributor to Bitcoin, released version 0.4.0 of the Ordinals protocol, officially bringing NFTs to the Bitcoin mainnet. So far, about 9,000 NFTs have been minted on the Bitcoin mainnet through the Ordinals protocol. This article introduces the basic information and participation tutorial of the Ordinals protocol, and summarizes the FOMO sentiment and related debates it has sparked.</p>
<p>Gli ordinali del protocollo hanno un sistema di numerazione che supporta il tracciamento e il trasferimento dell’unità minima di Bitcoin, Satoshi. I diversi Satoshi vengono numerati in base all’ordine di estrazione e vengono trasferiti dagli input alle transazioni in uscita in ordine FIFO. Dopo che ogni Satoshi ha un numero unico come identificatore, può essere tracciato o scambiato singolarmente. Sulla base di questo, scrivendo dati all’interno di ogni Satoshi (come immagini, testi, SVG, HTML, ecc.), viene completata la trasformazione da ‘unità minima di Bitcoin’ a ‘Bitcoin NFT’.</p>
<p>A differenza del mercato centralizzato NFT ampiamente utilizzato su Ethereum, tutto sembra così primitivo sulla mainnet di Bitcoin, come una ‘terra vergine’. Non ci sono mercati NFT, tutto si basa sulle transazioni OTC; non ci sono pagine di Mint, la modalità di vendita è principalmente ‘dare soldi al creatore -&gt; il creatore mette l’NFT sulla blockchain -&gt; distribuire manualmente l’NFT all’acquirente’; Ordinals non ha nemmeno rilasciato un’app portafoglio leggera, se si desidera mettere l’NFT sulla blockchain o trasferirlo a un altro indirizzo, è necessario installare il portafoglio core di Bitcoin e utilizzare tutte le funzionalità di Ordinals tramite la riga di comando.</p>
<p>Il Mago di Taproot ha quasi riempito l’intero blocco con un’immagine di 3,94 MB, facendo sì che la rete Bitcoin estragga il blocco più grande della storia. Un altro sviluppatore principale di Bitcoin, Luke Dashjr, ha definito questa transazione come ‘spam’ e ha sviluppato rapidamente un ‘filtro antispam’ per i minatori per selezionare e filtrare le transazioni di Bitcoin NFT create con il protocollo Ordinals. Quali saranno le conseguenze a lungo termine del protocollo Ordinals sulla rete Bitcoin: un maggiore incentivo per le applicazioni non finanziarie per i minatori, o un aumento dei costi per le applicazioni finanziarie?</p>
<p>Secondo i dati di Dune Analytics, da quando è stato lanciato il protocollo NFT basato su Bitcoin, Ordinals, le spese per le iscrizioni sulla rete Bitcoin sono costantemente in aumento. Al 7 febbraio, il protocollo Ordinals ha rappresentato il 12% delle spese totali di transazione sulla rete Bitcoin e lo 0,3% delle ricompense per blocco, e continua a crescere in modo esponenziale, causando la congestione più grave della mempool di Bitcoin dall’insolvenza di FTX e 3AC.</p>
<p>4⃣️ Messari: gli ordinali portano una nuova narrativa su Bitcoin(2023/03/11)<br>Guida alla lettura:Il ricercatore di Messari Sami Kassab ha scritto un rapporto per interpretare il “rinascimento” portato dall’iscrizione a Bitcoin,Messari ha twittato ufficialmente per riassumere il rapporto,L’identità di Bitcoin come strumento di copertura dall’inflazione、Una riserva di valore e un asset istituzionale maturo è stato scosso,Dopo l’aggiornamento di SegWit e Taproot,L’emergere di Ordinals ha portato una nuova narrativa a Bitcoin。</p>
<p>L’aggiornamento soft fork di Segregated Witness (SegWit) rende più facile e conveniente memorizzare grandi quantità di dati, mentre Taproot elimina il limite sulla quantità di dati che possono essere inclusi nelle transazioni BTC. Il protocollo Ordinals è emerso su questa base e in meno di tre mesi ci sono già oltre 342.000 iscrizioni pubblicate su Bitcoin, tra cui immagini, testi, video, app, audio e modelli. Qual è l’impatto delle iscrizioni e degli Ordinals sul sottofondo di Bitcoin? Le iscrizioni rappresentano il 6% delle commissioni TX. Il mese scorso la dimensione media dei blocchi Bitcoin è aumentata del 71%. La mempool di Bitcoin ha subito un forte aumento dell’attività legata alle iscrizioni.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168368965444.jpg" alt=""></p>
<p>5⃣️ [Inglese] Grayscale: Gli ordini possono sbloccare il nuovo potenziale di Bitcoin? (01/05/2023)<br>Introduzione: Grayscale discute l’effetto degli ordini sulla rete Bitcoin. Grayscale ritiene che, nonostante l’opposizione attuale della comunità, a lungo termine gli ordini avranno un impatto positivo sulla rete Bitcoin e attireranno una nuova ondata di utenti e sviluppatori nella comunità Bitcoin.</p>
<p>La critica contro gli Ordinali può essere riassunta nei seguenti tre punti:1. deviare dalla visione originale di Bitcoin di costruire un “sistema di denaro elettronico peer-to-peer”; 2. L’incorporazione di dati extra in un blocco ne aumenterà le dimensioni, causando il gonfiore della blockchain; 3. Compromettendo la fungibilità di Bitcoin, influenzando così il suo caso d’uso principale come valuta elettronica. [Originale in inglese]</p>
<p>Riteniamo che gli Ordinals abbiano un impatto positivo su due aspetti chiave della rete Bitcoin: l’aumento delle commissioni per i minatori di Bitcoin e la possibile promozione di una trasformazione culturale all’interno della comunità Bitcoin. Il primo potrebbe stabilire un livello di costo sostenibile per le transazioni al fine di incentivare i minatori e garantire la sicurezza della rete Bitcoin per l’intero ciclo di vita. Il secondo potrebbe promuovere una comunità e una cultura orientate allo sviluppo per sostenere la rete Bitcoin.</p>
<p>A differenza di ERC721, gli ordinali rappresentano direttamente gli asset digitali non fungibili grazie alla loro immutabilità, alla mancanza di programmabilità e alle rigorose esigenze di iscrizione sulla catena di blocchi. Anche se gli NFT di Ethereum sono più programmati e attualmente dominano il mercato degli NFT in termini di quantità e popolarità, gli ordinali potrebbero essere una scelta interessante per coloro che cercano asset digitali semplici e rari sulla blockchain più matura disponibile.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168368968302bfdb46-d113-4d94-9df2-269c28be7b07_1080x1080.webp" alt=""></p>
<h2 id="h2-Ordinali20Ecosistema230849"><a name="Ordinali Ecosistema" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ordinali Ecosistema</h2><ol>
<li>veDAO Research Institute: Bitcoin NFT Protocol Ordinals Eco-Summary (2023/03/14)</li></ol>
<p>Introduzione: NFT come token crittografico non è stato ampiamente sviluppato nelle prime blockchain per alcune ragioni, ma ha avuto grande successo dopo l’adesione di Ordinals. veDAO Research Institute ha riassunto e interpretato l’ecosistema BTC NFT.</p>
<p>Forgiatura: 1) Ordinals Bot è uno strumento per la forgiatura di NFT Bitcoin su protocollo Ordinals, che elimina la necessità per gli utenti di eseguire il nodo Bitcoin durante la forgiatura di NFT Bitcoin. 2) La piattaforma Gamma.io è composta da tre prodotti principali: un mercato NFT, un Launchpad e una piattaforma di social networking. Gamma.io supporta sia il mercato primario che il mercato secondario per NFT Bitcoin.</p>
<p>Portafoglio: 1) Ordinals Wallet è un portafoglio del browser utilizzato per inviare e ricevere BTC NFT sul protocollo Ordinals. Oltre alle funzioni di base del portafoglio, supporta anche la visualizzazione, la ricerca e il caricamento delle collezioni di iscrizioni NFT Bitcoin. 2) Sparrow Wallet è un portafoglio open source basato su Bitcoin che supporta vari tipi di transazioni e dispositivi hardware. Gli utenti possono utilizzare Sparrow Wallet per creare, ricevere, gestire e trasferire BTC NFT. 3) Hiro Wallet è un portafoglio basato su <a href="/price/stacks-stx" rel="nofollow noopener noreferrer" target="_blank">Stacks</a> Il portafoglio di sviluppo della catena è principalmente utilizzato per gestire il token STX. Attualmente ha iniziato a supportare NFT di Bitcoin. 4) Xverse è un portafoglio non custodito di Bitcoin basato su Stack ed è anche uno dei mercati più grandi nell’ecosistema di Bitcoin NFT. Xverse supporta transazioni con il token STX o altre criptovalute come BTC, ETH, ecc., e supporta anche la connessione tramite Hiro Wallet o altri portafogli. 5) <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>.com Wallet è un portafoglio mobile che supporta diverse criptovalute, inclusi BTC, e gli NFT (chiamati BNT) coniati sulla rete Satoshi Vision (SV). Il portafoglio prevede anche il supporto per gli NFT BTC coniati sul protocollo Ordinals.</p>
<p>Mercato: 1) Twetch è un social network “Play to Earn” costruito su BSV che consente agli utenti di guadagnare denaro pubblicando contenuti. La piattaforma include anche un marketplace NFT, un portafoglio BSV e molte altre funzionalità come una funzione di chat e una bacheca di lavoro. 2) Ordinals Market è una piattaforma aperta e decentralizzata in cui chiunque può pubblicare i propri lavori o raccogliere i lavori di altre persone, e supporta anche applicazioni e servizi di terze parti per fornire più funzionalità ed esperienze. 3) OpenOrdex è una piattaforma di trading decentralizzata di Ordinals, e vale la pena ricordare che l’order book centralizzato di OpenOrdex si basa sul protocollo di comunicazione <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> Nostr, precedentemente di grande successo.</p>
<ol>
<li>Analisi del mercato Gamma NFT di Bitcoin: meccanismo PSBT, vantaggi e svantaggi e situazione generale del mercato (22/03/2023)<br>Introduzione: Lo studioso di Bitcoin NFT xiyu ha pubblicato un’analisi del progetto Gamma del mercato NFT Ordinals, introducendo le caratteristiche del meccanismo di transazione a firma parziale (PSBT) utilizzato, delineando il processo di transazione e analizzando i punti di forza e debolezza di Gamma e la situazione attuale del mercato dei Bitcoin NFT.</li></ol>
<p>PSBT: La transazione di firma parziale (PSBT) definisce un formato preciso per trasmettere transazioni Bitcoin. Questo formato può contenere i metadati di una transazione, consentendo ai firmatari di firmare e verificare più facilmente la transazione. Questo standard definisce anche il processo di fusione delle firme e la finalizzazione della transazione, consentendo a più parti di firmare in parallelo la stessa transazione e quindi combinare le rispettive PSBT per formare una transazione completa firmata.</p>
<p>Vantaggi di Gamma: non è necessario fidarsi, non c’è bisogno di preoccuparsi che la piattaforma possa rubarci la chiave privata, la sicurezza è migliorata molto rispetto al modo in cui la piattaforma genera la chiave privata. Esperienza simile a Metamask+Opensea, per le transazioni a bassa frequenza come NFT, non ci sono attualmente problemi nell’esperienza di transazione. Svantaggio: commissioni del 1,5%, anche se non è alto, ma Openordex ha commissioni del 0, che ha ucciso il mercato fin dall’inizio.</p>
<p>Ordinals Eco: Currently, in the Ordinals Eco, from minting to wallets to trading, although it is not as mature as the Ethereum network, it is also close to it. What is currently lacking is the wealth effect, which is related to the overall sluggishness of the NFT market, and Ordinals still needs some time to evolve.</p>
<p>Magic Eden ha anche lanciato un mercato di scambio, iniziando una nuova competizione nel mercato degli scambi. Se le borse esistenti non si adattano rapidamente, il volume di scambi si sposterà presto. PSBT è attualmente il miglior modello di scambio per Bitcoin NFT e potrebbe essere applicato in più ambiti in futuro.</p>
<ol>
<li>Il nuovo progetto NFT di Bitcoin Chainspace: la nuova opera di Tim Shel, il creatore di Loot (28/02/2023)<br>Introduzione: Il protocollo Ordinals ha dato a Bitcoin nuove possibilità al di fuori del settore finanziario, ma manca un’infrastruttura NFT corrispondente nell’ecosistema di Bitcoin. L’autore della rubrica LeftOfCenter scrive sull’impianto di Chainspace, un progetto NFT di Bitcoin che ha avviato con successo lo sviluppo del modello di contratto NFT a doppia catena e ha intervistato il fondatore Tim Shel per comprendere gli scenari di utilizzo, i piani futuri e il potenziale narrativo.</li></ol>
<p>Chainspace è un progetto NFT basato sul protocollo Ordinals di Bitcoin avviato dal nucleo centrale di Loot, Tim Shel, e dall’ingegnere di Zora, Iain. Include 800 applicazioni di rendering video archiviate sulla rete Bitcoin che puoi usare per selfie, utilizzando filtri preimpostati che rappresentano diversi stili estetici della comunità crittografica, per generare selfie di emoticon gm, per esprimere la propria identità e interagire con la comunità. Il mantenimento dell’anonimato è un altro caso d’uso importante per Chainspace.</p>
<p>Chainspace adotta un modello di contratto NFT a doppia catena, ovvero memorizza gli NFT nella rete Bitcoin e crea una copia speculare NFT sulla catena Ethereum per la distribuzione iniziale. Inoltre, gli NFT speculare su Ethereum sono compatibili con EVM, risolvendo così il problema della mancanza di infrastrutture per il trading e la circolazione degli NFT su Bitcoin. Ciò non solo abbassa la soglia di creazione, ma sfrutta appieno le infrastrutture di mercato secondario NFT nell’ecosistema Ethereum.</p>
<p>L’obiettivo del progetto è quello di introdurre più nuovi utenti nell’ecosistema completamente nuovo di Bitcoin. L’esplorazione pratica di Chainspace stessa ha dimostrato che questo modello di rilascio più semplice ed eseguibile è fattibile e, in seguito, Tim Shel e Iain, in qualità di sviluppatori, hanno pianificato di rendere open source il codice del contratto di questo modello di struttura a doppia catena per consentire a più creatori e sviluppatori di utilizzarlo. Tim Shel ha paragonato Chainspace a un’opera d’arte nel mondo reale, che, sebbene sia un bene pubblico accessibile a tutti, è ancora di proprietà di finanziatori specifici.</p>
<p>4, [Inglese] Anteprima del nuovo progetto: la serie di NFT di Bitcoin TwelveFold di Yuga Labs (28/02/2023)<br>Guida: Yuga Labs ha annunciato il lancio della nuova serie di NFT TwelveFold basata sulla blockchain di Bitcoin e ha pubblicato una descrizione dettagliata di TwelveFold.</p>
<p>TwelveFold è un sistema artistico basato sul numero 12, progettato intorno a una griglia 12x12 che rappresenta visivamente i dati sulla blockchain di Bitcoin. Questo NFT include elementi 3D altamente renderizzati e caratteristiche disegnate a mano, come un omaggio alle iscrizioni ordinali realizzate a mano. Tutte queste scelte si discostano dallo stile tipico di Yuga, il che è bello fare qualcosa di inaspettato.</p>
<p>Il Bitcoin è una criptovaluta fungibile, ma la proposta di miglioramento del Bitcoin (BIP) descrive un metodo chiamato “inscribing” che consente agli autori di collegare dati a singoli satoshi (la più piccola unità di Bitcoin).1⁄100（1,000,000）e i metadati custoditi sulla catena (soprattutto per opere d’arte). In effetti, questo consente ai satoshi di funzionare come token non fungibili, rendendo di fatto possibile il concetto di NFT sulla blockchain di Bitcoin. Entrando nel Discord di Ordinal un mese fa, sembrava di dare un’occhiata all’ecosistema NFT di Ethereum del 2017. Questa atmosfera vivace e appassionata è esattamente ciò che amiamo qui a Yuga.</p>
<p>Cosa faremo dopo? Ci saranno ulteriori dettagli sul tempo e sulle modalità dell’asta nelle prossime settimane. Auguriamo buona fortuna a tutti gli offerenti e non vediamo l’ora di condividere questo tesoro con il mondo.【原文为英文】</p>
<p>5, Concept verification del protocollo di trading NFT Bitcoin Ordyswap (15/02/2023)</p>
<p>Introduzione: l’obiettivo di Ordyswap è quello di realizzare la funzionalità di trading di Bitcoin Ordinal NFT. Il co-fondatore del progetto di dominio Bitcoin BNS ha immaginato un mercato di Bitcoin NFT basato sulla rete di Blockstack chiamato Ordyswap.</p>
<p>Ordyswap consente a chiunque di presentare un’offerta per un determinato Ordinal NFT. Per creare un’offerta, il presentatore deve bloccare abbastanza token STX e specificare l’indirizzo Bitcoin dell’NFT con un numero d’ordine specifico che desidera acquistare. Se il proprietario accetta l’offerta, l’Ordinal NFT verrà automaticamente inviato al offerente e contemporaneamente gli STX verranno automaticamente pagati al venditore dell’NFT. L’intero processo si basa completamente su transazioni on-chain e non coinvolge alcun processo di custodia centralizzato.</p>
<div class="blog-details-info"><br>  <div>Autore:<strong>0XNATALIE</strong><br>  <div class="info-tips"><em>Questo articolo rappresenta solo il punto di vista dell'autore e non costituisce alcun consiglio di trading.<br>  </em><div><em></em> Questo contenuto è stato ripreso da ChainFeeds Substack, tutti i diritti sono riservati all'autore originale.<br></div><p></p><br></div></div></div>