Merge branch 'master' of github.com:ordinals/ord into index-rune-burns

Author: raphjaph

crates/mockcore/src/server.rs

@@ -258,17 +258,25 @@ impl Api for Server {
       }
     }
 
+    let Some(tx) = state.transactions.get(&txid) else {
+      return Ok(None);
+    };
+
+    let script_pubkey = &tx.output[usize::try_from(vout).unwrap()].script_pubkey;
+
     Ok(Some(GetTxOutResult {
       bestblock: BlockHash::all_zeros(),
       coinbase: false,
       confirmations: confirmations.unwrap().try_into().unwrap(),
       script_pub_key: GetRawTransactionResultVoutScriptPubKey {
         asm: String::new(),
-        hex: Vec::new(),
+        hex: script_pubkey.to_bytes(),
         req_sigs: None,
         type_: None,
         addresses: Vec::new(),
-        address: None,
+        address: Address::from_script(script_pubkey, state.network)
+          .ok()
+          .map(|addr| addr.into_unchecked()),
       },
       value: *value,
     }))

docs/src/guides/api.md

@@ -1803,6 +1803,7 @@ curl -s -H "Accept: application/json" \
 ```json
 {
   "address": "bc1pz4kvfpurqc2hwgrq0nwtfve2lfxvdpfcdpzc6ujchyr3ztj6gd9sfr6ayf",
+  "confirmations": 6,
   "indexed": false,
   "inscriptions": [],
   "outpoint": "bc4c30829a9564c0d58e6287195622b53ced54a25711d1b86be7cd3a70ef61ed:0",

justfile

@@ -49,28 +49,19 @@ deploy-mainnet-charlie branch='master' remote='ordinals/ord': \
 deploy-signet branch='master' remote='ordinals/ord': \
   (deploy branch remote 'signet' 'signet.ordinals.net')
 
-deploy-testnet branch='master' remote='ordinals/ord': \
-  (deploy branch remote 'test' 'testnet.ordinals.net')
-
-deploy-testnet4 branch='master' remote='ordinals/ord': \
-  (deploy branch remote 'testnet4' 'testnet4.ordinals.net')
-
 deploy-all: \
-  deploy-testnet \
-  deploy-testnet4 \
   deploy-signet \
   deploy-mainnet-alpha \
   deploy-mainnet-bravo \
   deploy-mainnet-charlie
 
 delete-indices: \
   (delete-index "signet.ordinals.net") \
-  (delete-index "testnet.ordinals.net")
 
 delete-index domain:
   ssh root@{{domain}} 'systemctl stop ord && rm -f /var/lib/ord/*/index.redb'
 
-servers := 'alpha bravo charlie signet testnet3 testnet4'
+servers := 'alpha bravo charlie signet'
 
 initialize-server-keys:
   #!/usr/bin/env bash

src/api.rs

@@ -169,6 +169,7 @@ pub struct UtxoRecursive {
 #[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct Output {
   pub address: Option<Address<NetworkUnchecked>>,
+  pub confirmations: u32,
   pub indexed: bool,
   pub inscriptions: Option<Vec<InscriptionId>>,
   pub outpoint: OutPoint,
@@ -183,6 +184,7 @@ pub struct Output {
 impl Output {
   pub fn new(
     chain: Chain,
+    confirmations: u32,
     inscriptions: Option<Vec<InscriptionId>>,
     outpoint: OutPoint,
     tx_out: TxOut,
@@ -196,6 +198,7 @@ impl Output {
         .address_from_script(&tx_out.script_pubkey)
         .ok()
         .map(|address| uncheck(&address)),
+      confirmations,
       indexed,
       inscriptions,
       outpoint,

src/index.rs

@@ -18,7 +18,10 @@ use {
   },
   bitcoin::block::Header,
   bitcoincore_rpc::{
-    json::{GetBlockHeaderResult, GetBlockStatsResult},
+    json::{
+      GetBlockHeaderResult, GetBlockStatsResult, GetRawTransactionResult,
+      GetRawTransactionResultVout, GetRawTransactionResultVoutScriptPubKey, GetTxOutResult,
+    },
     Client,
   },
   chrono::SubsecRound,
@@ -1596,6 +1599,87 @@ impl Index {
     Ok(Some(result))
   }
 
+  pub fn get_unspent_or_unconfirmed_output(
+    &self,
+    txid: &Txid,
+    vout: u32,
+  ) -> Result<Option<GetTxOutResult>> {
+    if txid == &self.genesis_block_coinbase_txid {
+      let Some(output) = &self
+        .genesis_block_coinbase_transaction
+        .output
+        .get(vout.into_usize())
+      else {
+        return Ok(None);
+      };
+
+      return Ok(Some(GetTxOutResult {
+        bestblock: self.block_hash(None)?.unwrap(),
+        coinbase: true,
+        confirmations: self.block_count()?,
+        script_pub_key: GetRawTransactionResultVoutScriptPubKey {
+          address: None,
+          addresses: Vec::new(),
+          asm: output.script_pubkey.to_asm_string(),
+          hex: output.script_pubkey.to_bytes(),
+          req_sigs: Some(1),
+          type_: Some(bitcoincore_rpc::json::ScriptPubkeyType::Pubkey),
+        },
+        value: output.value,
+      }));
+    }
+
+    Ok(self.client.get_tx_out(txid, vout, Some(true))?)
+  }
+
+  pub fn get_transaction_info(&self, txid: &Txid) -> Result<Option<GetRawTransactionResult>> {
+    if txid == &self.genesis_block_coinbase_txid {
+      let tx = &self.genesis_block_coinbase_transaction;
+
+      let block = bitcoin::blockdata::constants::genesis_block(self.settings.chain().network());
+      let time = block.header.time.into_usize();
+
+      return Ok(Some(GetRawTransactionResult {
+        in_active_chain: Some(true),
+        hex: consensus::encode::serialize(tx),
+        txid: tx.compute_txid(),
+        hash: tx.compute_wtxid(),
+        size: tx.total_size(),
+        vsize: tx.vsize(),
+        #[allow(clippy::cast_sign_loss)]
+        version: tx.version.0 as u32,
+        locktime: 0,
+        vin: Vec::new(),
+        vout: tx
+          .output
+          .iter()
+          .enumerate()
+          .map(|(n, output)| GetRawTransactionResultVout {
+            n: n.try_into().unwrap(),
+            value: output.value,
+            script_pub_key: GetRawTransactionResultVoutScriptPubKey {
+              asm: output.script_pubkey.to_asm_string(),
+              hex: output.script_pubkey.clone().into(),
+              req_sigs: None,
+              type_: None,
+              addresses: Vec::new(),
+              address: None,
+            },
+          })
+          .collect(),
+        blockhash: Some(block.block_hash()),
+        confirmations: Some(self.block_count()?),
+        time: Some(time),
+        blocktime: Some(time),
+      }));
+    }
+
+    self
+      .client
+      .get_raw_transaction_info(txid, None)
+      .into_option()
+  }
+
   pub fn get_transaction(&self, txid: Txid) -> Result<Option<Transaction>> {
     if txid == self.genesis_block_coinbase_txid {
       return Ok(Some(self.genesis_block_coinbase_transaction.clone()));
@@ -2404,9 +2488,12 @@ impl Index {
   pub(crate) fn get_output_info(&self, outpoint: OutPoint) -> Result<Option<(api::Output, TxOut)>> {
     let sat_ranges = self.list(outpoint)?;
 
+    let confirmations;
     let indexed;
+    let spent;
+    let txout;
 
-    let txout = if outpoint == OutPoint::null() || outpoint == unbound_outpoint() {
+    if outpoint == OutPoint::null() || outpoint == unbound_outpoint() {
       let mut value = 0;
 
       if let Some(ranges) = &sat_ranges {
@@ -2415,35 +2502,49 @@ impl Index {
         }
       }
 
+      confirmations = 0;
       indexed = true;
-
-      TxOut {
+      spent = false;
+      txout = TxOut {
         value: Amount::from_sat(value),
         script_pubkey: ScriptBuf::new(),
-      }
+      };
     } else {
       indexed = self.contains_output(&outpoint)?;
 
-      let Some(tx) = self.get_transaction(outpoint.txid)? else {
-        return Ok(None);
-      };
+      if let Some(result) = self.get_unspent_or_unconfirmed_output(&outpoint.txid, outpoint.vout)? {
+        confirmations = result.confirmations;
+        spent = false;
+        txout = TxOut {
+          value: result.value,
+          script_pubkey: ScriptBuf::from_bytes(result.script_pub_key.hex),
+        };
+      } else {
+        let Some(result) = self.get_transaction_info(&outpoint.txid)? else {
+          return Ok(None);
+        };
 
-      let Some(txout) = tx.output.into_iter().nth(outpoint.vout as usize) else {
-        return Ok(None);
-      };
+        let Some(output) = result.vout.into_iter().nth(outpoint.vout.into_usize()) else {
+          return Ok(None);
+        };
 
-      txout
+        confirmations = result.confirmations.unwrap_or_default();
+        spent = true;
+        txout = TxOut {
+          value: output.value,
+          script_pubkey: ScriptBuf::from_bytes(output.script_pub_key.hex),
+        };
+      }
     };
 
     let inscriptions = self.get_inscriptions_for_output(outpoint)?;
 
     let runes = self.get_rune_balances_for_output(outpoint)?;
 
-    let spent = self.is_output_spent(outpoint)?;
-
     Ok(Some((
       api::Output::new(
         self.settings.chain(),
+        confirmations,
         inscriptions,
         outpoint,
         txout.clone(),