Learning-Bitcoin-from-the-Command-Line/it/04_2_Intermezzo_Usare_JQ.md

Interludio: utilizzo di JQ

La creazione di una transazione raw ha rivelato come i risultati più complessi di bitcoin-cli non possano essere facilmente salvati in variabili della riga di comando. La risposta è JQ, che consente di filtrare singoli elementi da dati JSON più complessi.

Installa JQ

Per le versioni moderne di Debian, dovresti essere in grado di installare JQ usando apt-get:

# apt-get install jq

📖 Che cos'è JQ? cito "jq è come sed per i dati JSON: puoi usarlo per suddividere, filtrare, mappare e trasformare i dati strutturati e giocare con il testo con la stessa facilità di sed , awk, grep e compagnia bella."

Se funziona, il gioco è fatto!

Altrimenti, puoi scaricare JQ da un repository Github. Basta scaricare un file binario per Linux, OS X o Windows, a seconda dei casi.

Una volta scaricato il binario, puoi installarlo sul tuo sistema. Se stai lavorando su un VPS Debian come suggeriamo, la tua installazione sarà simile a questa:

$ mv jq-linux64 jq
$ sudo /usr/bin/install -m 0755 -o root -g root -t /usr/local/bin jq

Usa JQ per accedere al valore di un oggetto JSON tramite chiave

Esempio di utilizzo: Cattura l'esadecimale da una transazione grezza firmata.

Nella sezione precedente, l'uso di "signrawtransaction" ha offerto un esempio di impossibilità di acquisire facilmente i dati in variabili a causa dell'uso dell'output JSON:

$ bitcoin-cli signrawtransactionwithwallet $rawtxhex
{
  "hex": "02000000013a6e4279b799791049e1826602e84d2e36797e2005887b98c3ecf16b01b7f361010000006a4730440220335d15a2a2ca3ce6a302ce041686739d4a38eb0599a5ea08305de71965268d05022015f77a33cf7d613015b2aba5beb03088033625505ad5d4d0624defdbea22262b01210278608b54b8fb0d8379d3823d31f03a7c6ab0adffb07dd3811819fdfc34f8c132ffffffff01409c0000000000001976a914e7c1345fc8f87c68170b3aa798a956c2fe6a9eff88ac00000000",
  "complete": true
}

Fortunatamente, JQ può facilmente acquisire dati di questo tipo!

Per utilizzare JQ, esegui jq nel backend di una pipe | e utilizza sempre l'invocazione standard di jq -r. La -r dice a JQ di produrre un output grezzo, raw, che funzionerà per le variabili della riga di comando, mentre il . dice a jq di produrre l'output. Proteggiamo questo argomento in ' ' perché avremo bisogno di quella protezione in seguito quando le nostre chiamate a 'jq diventeranno più complesse.

Per acquisire un valore specifico da un oggetto JSON, elenca semplicemente la chiave dopo .:

$ bitcoin-cli signrawtransactionwithwallet $rawtxhex | jq -r '.hex'
02000000013a6e4279b799791049e1826602e84d2e36797e2005887b98c3ecf16b01b7f361010000006a4730440220335d15a2a2ca3ce6a302ce041686739d4a38eb0599a5ea08305de71965268d05022015f77a33cf7d613015b2aba5beb03088033625505ad5d4d0624defdbea22262b01210278608b54b8fb0d8379d3823d31f03a7c6ab0adffb07dd3811819fdfc34f8c132ffffffff01409c0000000000001976a914e7c1345fc8f87c68170b3aa798a956c2fe6a9eff88ac00000000

Con questo strumento in mano, puoi acquisire informazioni dagli oggetti JSON alle variabili della riga di comando:

$ signedtx=$(bitcoin-cli signrawtransactionwithwallet $rawtxhex | jq -r '.hex')
$ echo $signedtx
02000000013a6e4279b799791049e1826602e84d2e36797e2005887b98c3ecf16b01b7f361010000006a4730440220335d15a2a2ca3ce6a302ce041686739d4a38eb0599a5ea08305de71965268d05022015f77a33cf7d613015b2aba5beb03088033625505ad5d4d0624defdbea22262b01210278608b54b8fb0d8379d3823d31f03a7c6ab0adffb07dd3811819fdfc34f8c132ffffffff01409c0000000000001976a914e7c1345fc8f87c68170b3aa798a956c2fe6a9eff88ac00000000

È quindi possibile utilizzare tali variabili facilmente e senza errori:

$ bitcoin-cli sendrawtransaction $signedtx
3f9ccb6e16663e66dc119de1866610cc4f7a83079bfec2abf0598ed3adf10a78

Utilizza JQ per accedere ai valori di singoli oggetti JSON in un array tramite chiave

Esempio di utilizzo: Cattura txid e vout per un UTXO selezionato.

Ottenere dati da un oggetto JSON è semplice, ma cosa succede se l'oggetto JSON si trova in un array JSON? Il comando listunspent offre un ottimo esempio, perché solitamente conterrà un numero di transazioni diverse. E se volessi acquisire informazioni specifiche da uno di essi?

Quando lavori con un array JSON, la prima cosa che devi fare è dire a JQ a quale indice accedere. Ad esempio, potresti aver esaminato le tue transazioni in "listunspent" e aver deciso di voler lavorare con la seconda. Si usa '.[1]' per accedere al secondo elemento. [ ] dice che stiamo facendo riferimento a un array JSON e 1 dice che vogliamo il primo indice.

$ bitcoin-cli listunspent | jq -r '.[1]'
{
  "txid": "91261eafae15ea53dedbea7c1db748c52bbc04a85859ffd0d839bda1421fda4c",
  "vout": 0,
  "address": "mjehC2KHzXcBDcwTd4LhZ2GzyzrZ3Kd3ff",
  "label": "",
  "scriptPubKey": "76a9142d573900aa357a38afd741fbf24b075d263ea6e088ac",
  "amount": 0.00022,
  "confirmations": 9,
  "spendable": true,
  "solvable": true,
  "desc": "pkh([d6043800/0'/0'/3']0278608b54b8fb0d8379d3823d31f03a7c6ab0adffb07dd3811819fdfc34f8c132)#nhjc3f8y",
  "safe": true
}

È quindi possibile acquisire un singolo valore dall'array selezionato (1)] utilizzando una pipe all'interno degli argomenti JQ; e poi (2) richiedere successivamente il valore specifico, come nell'esempio precedente. Quanto segue catturerebbe il txid dal primo oggetto JSON nell'array JSON prodotto da listunspent:

$ bitcoin-cli listunspent | jq -r '.[1] | .txid'
91261eafae15ea53dedbea7c1db748c52bbc04a85859ffd0d839bda1421fda4c

Notare attentamente come le virgolette ' ' stanno dappertutto nelle espressione JQ inclusa la pipe | .

Questo metodo può essere utilizzato per compilare le variabili per un UTXO che desideri utilizzare:

$ newtxid=$(bitcoin-cli listunspent | jq -r '.[1] | .txid')
$ newvout=$(bitcoin-cli listunspent | jq -r '.[1] | .vout')
$ echo $newtxid
91261eafae15ea53dedbea7c1db748c52bbc04a85859ffd0d839bda1421fda4c
$ echo $newvout
0

Ecco! Ora potremmo creare una nuova transazione grezza utilizzando il nostro primo UTXO come input, senza dover digitare manualmente nessuna delle informazioni UTXO!

Utilizza JQ per accedere ai valori degli oggetti JSON corrispondenti in un array in base alla chiave

Esempio di utilizzo: Elenca il valore di tutti gli UTXO non spesi.

Invece di accedere a un singolo valore specifico in un oggetto JSON specifico, potresti invece accedere a tutto un valore specifico in tutti gli oggetti JSON. Questo viene fatto con .[], dove non è specificato alcun indice. Ad esempio, questo elencherebbe tutti i fondi non spesi:

$ bitcoin-cli listunspent | jq -r '.[] | .amount'
0.0001
0.00022

Usa JQ per fare calcoli semplici tramite chiave

Esempio di utilizzo: Somma il valore di tutti gli UTXO non spesi.

A questo punto, puoi iniziare a utilizzare l'output JQ per semplici calcoli. Ad esempio, sommando i valori delle transazioni non spese con un semplice script awk otterresti l'equivalente di getbalance:

$ bitcoin-cli listunspent | jq -r '.[] | .amount' | awk '{s+=$1} END {print s}'
0.00032
$ bitcoin-cli getbalance
0.00032000

Utilizza JQ per visualizzare più valori di oggetti JSON in un array tramite più chiavi

Esempio di utilizzo: Elenca le informazioni sull'utilizzo per tutti gli UTXO.

JQ può facilmente acquisire singoli elementi da oggetti e array JSON e inserirli in variabili. Questo sarà il suo utilizzo principale nelle sezioni future. Tuttavia, può anche essere utilizzato per ridurre "enormi quantità" di informazioni prodotte da "bitcoin-cli" in "quantità ragionevoli" di informazioni.

Ad esempio, potresti voler vedere un elenco di tutti i tuoi UTXO (.[]) e ottenere un elenco di tutte le loro informazioni più importanti (.txid, .vout, .amount):

$ bitcoin-cli listunspent | jq -r '.[] | .txid, .vout, .amount'
ca4898d8f950df03d6bfaa00578bd0305d041d24788b630d0c4a32debcac9f36
0
0.0001
91261eafae15ea53dedbea7c1db748c52bbc04a85859ffd0d839bda1421fda4c
0
0.00022

Ciò rende facile decidere quali UTXO spendere in una transazione grezza, ma non è molto carino.

Fortunatamente, JQ ti permette anche di essere fantasioso. Puoi utilizzare {} per creare nuovi oggetti JSON (per analisi aggiuntive o per un output gradevole). Puoi anche definire il nome della nuova chiave per ciascuno dei tuoi valori. L'output risultante dovrebbe essere molto più intuitivo e meno soggetto a errori (anche se ovviamente meno utile per scaricare informazioni direttamente nelle variabili).

L'esempio seguente mostra esattamente la stessa analisi di "listunspent", ma con ogni vecchio oggetto JSON ricostruito come un nuovo oggetto JSON abbreviato, con tutti i nuovi valori denominati con le loro vecchie chiavi:

$ bitcoin-cli listunspent | jq -r '.[] | { txid: .txid, vout: .vout, amount: .amount }'
{
  "txid": "ca4898d8f950df03d6bfaa00578bd0305d041d24788b630d0c4a32debcac9f36",
  "vout": 0,
  "amount": 0.0001
}
{
  "txid": "91261eafae15ea53dedbea7c1db748c52bbc04a85859ffd0d839bda1421fda4c",
  "vout": 0,
  "amount": 0.00022
}

Ovviamente potresti rinominare le tue nuove chiavi come ritieni opportuno. Non c'è niente di magico nei nomi originali scelti da Satoshi:

$ bitcoin-cli listunspent | jq -r '.[] | { tx: .txid, output: .vout, bitcoins: .amount }'
{
  "tx": "ca4898d8f950df03d6bfaa00578bd0305d041d24788b630d0c4a32debcac9f36",
  "output": 0,
  "bitcoins": 0.0001
}
{
  "tx": "91261eafae15ea53dedbea7c1db748c52bbc04a85859ffd0d839bda1421fda4c",
  "output": 0,
  "bitcoins": 0.00022
}

Utilizza JQ per accedere agli oggetti JSON in base al valore cercato

Esempio di utilizzo: Cerca automaticamente gli UTXO utilizzati in una transazione.

Le ricerche JQ finora sono state abbastanza semplici: si utilizza una chiave per cercare uno o più valori in un oggetto o array JSON. Ma cosa succede se invece desideri cercare un valore in un oggetto JSON... tramite un altro valore? Questo tipo di ricerca indiretta ha una reale applicabilità quando lavori con transazioni basate su UTXO esistenti. Ad esempio, può consentire di calcolare il valore totale degli UTXO utilizzati in una transazione, cosa di vitale importanza.

Questo esempio utilizza la seguente transazione raw. Si noti che questa è una transazione grezza più complessa con due input e due output. Impareremo a realizzarli in alcune sezioni; per ora è necessario saper offrire esempi robusti. Nota che a differenza dei nostri esempi precedenti, questo ha due oggetti nell'array "vin" e due nell'array "vout".

$ bitcoin-cli decoderawtransaction $rawtxhex
{
  "txid": "6f83a0b78c598de01915554688592da1d7a3047eacacc8a9be39f5396bf0a07e",
  "hash": "6f83a0b78c598de01915554688592da1d7a3047eacacc8a9be39f5396bf0a07e",
  "size": 160,
  "vsize": 160,
  "version": 2,
  "locktime": 0,
  "vin": [
    {
      "txid": "d261b9494eb29084f668e1abd75d331fc2d6525dd206b2f5236753b5448ca12c",
      "vout": 1,
      "scriptSig": {
        "asm": "",
        "hex": ""
      },
      "sequence": 4294967295
    },
    {
      "txid": "c7c7f6371ec19330527325908a544bbf8401191645598301d24b54d37e209e7b",
      "vout": 1,
      "scriptSig": {
        "asm": "",
        "hex": ""
      },
      "sequence": 4294967295
    }
  ],
  "vout": [
    {
      "value": 1.00000000,
      "n": 0,
      "scriptPubKey": {
        "asm": "OP_DUP OP_HASH160 cfc39be7ea3337c450a0c77a839ad0e160739058 OP_EQUALVERIFY OP_CHECKSIG",
        "hex": "76a914cfc39be7ea3337c450a0c77a839ad0e16073905888ac",
        "reqSigs": 1,
        "type": "pubkeyhash",
        "addresses": [
          "mzTWVv2QSgBNqXx7RC56zEhaQPve8C8VS9"
        ]
      }
    },
    {
      "value": 0.04500000,
      "n": 1,
      "scriptPubKey": {
        "asm": "OP_DUP OP_HASH160 166692bda9f25ced145267bb44286e8ee3963d26 OP_EQUALVERIFY OP_CHECKSIG",
        "hex": "76a914166692bda9f25ced145267bb44286e8ee3963d2688ac",
        "reqSigs": 1,
        "type": "pubkeyhash",
        "addresses": [
          "mhZQ3Bih6wi7jP1tpFZrCcyr4NsfCapiZP"
        ]
      }
    }
  ]
}

Recupera i valori

Supponiamo di sapere esattamente come è costruita questa transazione: sappiamo che utilizza due UTXO come input. Per recuperare il txid per i due UTXO, potremmo usare jq per cercare il valore .vin della transazione, quindi fare riferimento all'array 0 di .vin, quindi al valore .txid di quell'array. Successivamente, potremmo fare lo stesso con il primo array, quindi lo stesso con i due valori .vout di .vin. Facile:

$ usedtxid1=$(bitcoin-cli decoderawtransaction $rawtxhex | jq -r '.vin | .[0] | .txid')
$ echo $usedtxid1
d261b9494eb29084f668e1abd75d331fc2d6525dd206b2f5236753b5448ca12c
$ usedtxid2=$(bitcoin-cli decoderawtransaction $rawtxhex | jq -r '.vin | .[1] | .txid')
$ echo $usedtxid2
c7c7f6371ec19330527325908a544bbf8401191645598301d24b54d37e209e7b

$ usedvout1=$(bitcoin-cli decoderawtransaction $rawtxhex | jq -r '.vin | .[0] | .vout')
$ echo $usedvout1
1
$ usedvout2=$(bitcoin-cli decoderawtransaction $rawtxhex | jq -r '.vin | .[1] | .vout')
$ echo $usedvout2
1

Tuttavia, sarebbe meglio avere un caso generale che salvi automaticamente tutti i txid dei nostri UTXO.

Sappiamo già che possiamo accedere a tutti i file .txid utilizzando un valore di array .[]. Possiamo usarlo per creare una ricerca generale .txid:

$ usedtxid=($(bitcoin-cli decoderawtransaction $rawtxhex | jq -r '.vin | .[] | .txid'))
$ echo ${usedtxid[0]}
d261b9494eb29084f668e1abd75d331fc2d6525dd206b2f5236753b5448ca12c
$ echo ${usedtxid[1]}
c7c7f6371ec19330527325908a544bbf8401191645598301d24b54d37e209e7b

$ usedvout=($(bitcoin-cli decoderawtransaction $rawtxhex | jq -r '.vin | .[] | .vout'))
$ echo ${usedvout[0]}
1
$ echo ${usedvout[1]}
1

L'unico vero trucco qui è il modo in cui abbiamo salvato le informazioni utilizzando la shell bash. Invece di salvare in una variabile con $(command), abbiamo invece salvato in un array con ($(command)). Siamo quindi riusciti ad accedere ai singoli elementi dell'array bash con una costruzione ${variable[n]}. Potremmo invece accedere all'intero array con ${variable[@]}. (Sì, nessuno ha mai detto che Bash fosse carino.)

:avviso: ATTENZIONE: Ricorda sempre che un UTXO è una transazione più un vout. Abbiamo mancato il vout la prima volta che abbiamo scritto questo esempio JQ e ha smesso di funzionare quando ci siamo ritrovati in una situazione in cui ci erano stati inviati due vout dalla stessa transazione.

Recupera gli oggetti correlati

Ora puoi utilizzare le informazioni "txid" e "vout" salvate per fare riferimento agli UTXO in "listunspent". Per trovare le informazioni sugli UTXO utilizzati dalla transazione grezza, è necessario esaminare l'intero array JSON ([]) delle transazioni non spese. Puoi quindi scegliere (select) singoli oggetti JSON che includono (contains) i txid. Si poi si selezionano (select) le transazioni tra quelle che anche contengono (contain) il vout corretto.

L'uso di un altro livello di pipe è la metodologia standard di JQ: prendi una serie di dati, poi li riduci a tutte le transazioni rilevanti, quindi li riduci ai vout che sono stati effettivamente utilizzati da quelle transazioni. Tuttavia, gli argomenti select e contains sono qualcosa di nuovo. Mostrano parte della complessità di JSON che va oltre lo scopo di questo tutorial; per ora sappi solo che questa particolare invocazione funzionerà per catturare oggetti corrispondenti.

Per iniziare in modo semplice, seleziona i due UTXO uno alla volta:

$ bitcoin-cli listunspent | jq -r '.[] | select (.txid | contains("'${usedtxid[0]}'")) | select(.vout | contains('${usedvout[0]}'))'
{
  "txid": "d261b9494eb29084f668e1abd75d331fc2d6525dd206b2f5236753b5448ca12c",
  "vout": 1,
  "address": "miSrC3FvkPPZgqqvCiQycq7io7wTSVsAFH",
  "scriptPubKey": "76a91420219e4f3c6bc0f6524d538009e980091b3613e888ac",
  "amount": 0.9,
  "confirmations": 6,
  "spendable": true,
  "solvable": true
}
$ bitcoin-cli listunspent | jq -r '.[] | select (.txid | contains("'${usedtxid[1]}'")) | select(.vout | contains('${usedvout[1]}'))'
{
  "txid": "c7c7f6371ec19330527325908a544bbf8401191645598301d24b54d37e209e7b",
  "vout": 1,
  "address": "mzizSuAy8aL1ytFijds7pm4MuDPx5aYH5Q",
  "scriptPubKey": "76a914d2b12da30320e81f2dfa416c5d9499d08f778f9888ac",
  "amount": 0.4,
  "confirmations": 5,
  "spendable": true,
  "solvable": true
}

Un semplice bash for-loop potrebbe invece darti tutti i tuoi UTXO:

$ for ((i=0; i<${#usedtxid[*]}; i++)); do txid=${usedtxid[i]}; vout=${usedvout[i]}; bitcoin-cli listunspent | jq -r '.[] | select (.txid | contains("'${txid}'")) | select(.vout | contains('$vout'))'; done;
{
  "txid": "d261b9494eb29084f668e1abd75d331fc2d6525dd206b2f5236753b5448ca12c",
  "vout": 1,
  "address": "miSrC3FvkPPZgqqvCiQycq7io7wTSVsAFH",
  "scriptPubKey": "76a91420219e4f3c6bc0f6524d538009e980091b3613e888ac",
  "amount": 0.9,
  "confirmations": 7,
  "spendable": true,
  "solvable": true
}
{
  "txid": "c7c7f6371ec19330527325908a544bbf8401191645598301d24b54d37e209e7b",
  "vout": 1,
  "address": "mzizSuAy8aL1ytFijds7pm4MuDPx5aYH5Q",
  "scriptPubKey": "76a914d2b12da30320e81f2dfa416c5d9499d08f778f9888ac",
  "amount": 0.4,
  "confirmations": 6,
  "spendable": true,
  "solvable": true
}

Nota che abbiamo utilizzato ancora un altro elemento brutto dell'array ${#usedtxid[*]} per determinare la dimensione dell'array, quindi abbiamo effettuato l'accesso a ciascun valore nell'array usedtxid e a ciascun valore nell'array parallelo usedvout, inserendo trasformarli in variabili più semplici per un accesso meno brutto.

Usa JSON per calcoli semplici in base al valore

Esempio di utilizzo: Calcola automaticamente il valore degli UTXO utilizzati in una transazione.

Ora puoi fare un ulteriore passo avanti e richiedere il .amount (o qualsiasi altro valore-chiave JSON) dagli UTXO che stai recuperando.

Questo esempio ripete l'utilizzo degli array $usedtxid e $usedvout impostati come segue:

$ usedtxid=($(bitcoin-cli decoderawtransaction $rawtxhex | jq -r '.vin | .[] | .txid'))
$ usedvout=($(bitcoin-cli decoderawtransaction $rawtxhex | jq -r '.vin | .[] | .vout'))

Lo stesso script "for" può essere utilizzato per scorrere questi array, ma con una pipe aggiunta nel JQ che restituisce il valore amount per ciascuno degli UTXO selezionati.

$ for ((i=0; i<${#usedtxid[*]}; i++)); do txid=${usedtxid[i]}; vout=${usedvout[i]}; bitcoin-cli listunspent | jq -r '.[] | select (.txid | contains("'${txid}'")) | select(.vout | contains('$vout')) | .amount'; done;
0.9
0.4

A questo punto puoi anche sommare gli .amounts con uno script awk, per vedere realmente quanti soldi ci sono negli UTXO che la transazione sta spendendo:

$ for ((i=0; i<${#usedtxid[*]}; i++)); do txid=${usedtxid[i]}; vout=${usedvout[i]}; bitcoin-cli listunspent | jq -r '.[] | select (.txid | contains("'${txid}'")) | select(.vout | contains('$vout')) | .amount'; done | awk '{s+=$1} END {print s}'
1.3

Wow!

Usa JQ per calcoli complessi

Esempio di utilizzo: Calcola la commissione per una transazione.

Per calcolare la commissione di transazione completa a questo punto è necessario solo un ulteriore calcolo: determinare quanti soldi passano attraverso il .vout. Questo è un semplice utilizzo di JQ in cui devi semplicemente usare awk per riassumere il valore di tutte le informazioni vout:

$ bitcoin-cli decoderawtransaction $rawtxhex | jq -r '.vout  [] | .value' | awk '{s+=$1} END {print s}'
1.045

Per completare il calcolo della commissione di transazione, sottrai l'importo .vout .(1.045) dall'importo .vin (1.3).

Per fare ciò, dovrai installare bc:

$ sudo apt-get install bc

Mettendo tutto insieme si crea una calcolatrice completa in sole cinque righe di script:

$ usedtxid=($(bitcoin-cli decoderawtransaction $rawtxhex | jq -r '.vin | .[] | .txid'))
$ usedvout=($(bitcoin-cli decoderawtransaction $rawtxhex | jq -r '.vin | .[] | .vout'))
$ btcin=$(for ((i=0; i<${#usedtxid[*]}; i++)); do txid=${usedtxid[i]}; vout=${usedvout[i]}; bitcoin-cli listunspent | jq -r '.[] | select (.txid | contains("'${txid}'")) | select(.vout | contains('$vout')) | .amount'; done | awk '{s+=$1} END {print s}')
$ btcout=$(bitcoin-cli decoderawtransaction $rawtxhex | jq -r '.vout  [] | .value' | awk '{s+=$1} END {print s}')
$ echo "$btcin-$btcout"| /usr/bin/bc
.255

E questo è anche un buon esempio del motivo per cui ricontrolli le tue commissioni: avevamo intenzione di inviare una commissione di transazione di 5.000 satoshi, ma invece abbiamo inviato 255.000 satoshi. Ops!

:avviso: ATTENZIONE: La prima volta che abbiamo scritto questa lezione, abbiamo effettivamente calcolato male la nostra tariffa e non l'abbiamo vista finché non abbiamo eseguito il nostro calcolatore delle tariffe. È così facile sbagliare, poi i tuoi soldi sono finiti. (L'esempio sopra è in realtà tratto dalla nostra seconda iterazione della calcolatrice e quella volta abbiamo commesso l'errore di proposito.)

Per ulteriori magie JSON (e se qualcosa non è chiaro), leggi il Manuale JSON e il [Cookbook JSON](https:// github.com/stedolan/jq/wiki/Cookbook). Utilizzeremo regolarmente JQ negli esempi futuri.

Crea alcuni nuovi alias

Il codice JQ può essere un po' ingombrante, quindi dovresti considerare di aggiungere alcune invocazioni più lunghe e interessanti al tuo ~/.bash_profile.

Ogni volta che stai esaminando una grande massa di informazioni in un oggetto JSON generato da un comando bitcoin-cli, valuta la possibilità di scrivere un alias per ridurlo a ciò che vuoi vedere.

alias btcunspent="bitcoin-cli listunspent | jq -r '.[] | { txid: .txid, vout: .vout, amount: .amount }'"

Esegui lo script della commissione di transazione

Lo Script di calcolo della tariffa è disponibile nella directory src-code. Puoi scaricarlo e salvarlo come txfee-calc.sh.

:avviso: ATTENZIONE: Questo script non è stato controllato in modo approfondito. Se hai intenzione di usarlo per verificare le commissioni di transazione reali, dovresti farlo solo come triplo controllo dopo aver già fatto tutti i conti da solo.

Assicurati che le autorizzazioni sullo script siano corrette:

$ chmod 755 txfee-calc.sh

È quindi possibile eseguire lo script come segue:

$ ./txfee-calc.sh $rawtxhex
.255

Potresti anche voler creare un alias:

alias btctxfee="~/txfee-calc.sh"

Riepilogo: utilizzo di JQ

JQ semplifica l'estrazione di informazioni da array e oggetti JSON. Può anche essere utilizzato negli script di shell per calcoli abbastanza complessi che ti semplificheranno la vita.

Cosa viene dopo?

Continua a inviare Bitcoin" qui Capitolo 4.3: Creare una Transazione Grezza con Alias.