Implement burning

crates/ordinals/src/charm.rs

@@ -14,10 +14,11 @@ pub enum Charm {
   Uncommon = 9,
   Vindicated = 10,
   Mythic = 11,
+  Burned = 12,
 }
 
 impl Charm {
-  pub const ALL: [Self; 12] = [
+  pub const ALL: [Self; 13] = [
     Self::Coin,
     Self::Uncommon,
     Self::Rare,
@@ -30,6 +31,7 @@ impl Charm {
     Self::Unbound,
     Self::Lost,
     Self::Vindicated,
+    Self::Burned,
   ];
 
   fn flag(self) -> u16 {
@@ -62,6 +64,7 @@ impl Charm {
       Self::Unbound => "🔓",
       Self::Uncommon => "🌱",
       Self::Vindicated => "❤️‍🔥",
+      Self::Burned => "💀🔥",
     }
   }
 
@@ -91,6 +94,7 @@ impl Display for Charm {
         Self::Unbound => "unbound",
         Self::Uncommon => "uncommon",
         Self::Vindicated => "vindicated",
+        Self::Burned => "burned",
       }
     )
   }
@@ -113,6 +117,7 @@ impl FromStr for Charm {
       "unbound" => Self::Unbound,
       "uncommon" => Self::Uncommon,
       "vindicated" => Self::Vindicated,
+      "burned" => Self::Burned,
       _ => return Err(format!("invalid charm `{s}`")),
     })
   }

src/index/updater/inscription_updater.rs

@@ -291,6 +291,7 @@ impl<'a, 'tx> InscriptionUpdater<'a, 'tx> {
     let mut range_to_vout = BTreeMap::new();
     let mut new_locations = Vec::new();
     let mut output_value = 0;
+    let mut is_burned = false;
     for (vout, tx_out) in tx.output.iter().enumerate() {
       let end = output_value + tx_out.value;
 
@@ -307,6 +308,7 @@ impl<'a, 'tx> InscriptionUpdater<'a, 'tx> {
           offset: flotsam.offset - output_value,
         };
 
+        is_burned = tx_out.script_pubkey.is_op_return();
         new_locations.push((new_satpoint, inscriptions.next().unwrap()));
       }
 
@@ -345,7 +347,7 @@ impl<'a, 'tx> InscriptionUpdater<'a, 'tx> {
         _ => new_satpoint,
       };
 
-      self.update_inscription_location(input_sat_ranges, flotsam, new_satpoint)?;
+      self.update_inscription_location(input_sat_ranges, flotsam, new_satpoint, is_burned)?;
     }
 
     if is_coinbase {
@@ -354,7 +356,7 @@ impl<'a, 'tx> InscriptionUpdater<'a, 'tx> {
           outpoint: OutPoint::null(),
           offset: self.lost_sats + flotsam.offset - output_value,
         };
-        self.update_inscription_location(input_sat_ranges, flotsam, new_satpoint)?;
+        self.update_inscription_location(input_sat_ranges, flotsam, new_satpoint, false)?;
       }
       self.lost_sats += self.reward - output_value;
       Ok(())
@@ -392,6 +394,7 @@ impl<'a, 'tx> InscriptionUpdater<'a, 'tx> {
     input_sat_ranges: Option<&VecDeque<(u64, u64)>>,
     flotsam: Flotsam,
     new_satpoint: SatPoint,
+    is_burned: bool,
   ) -> Result {
     let inscription_id = flotsam.inscription_id;
     let (unbound, sequence_number) = match flotsam.origin {
@@ -406,6 +409,29 @@ impl<'a, 'tx> InscriptionUpdater<'a, 'tx> {
           .unwrap()
           .value();
 
+        println!("is_burned {}", is_burned);
+
+        if is_burned {
+          let entry = InscriptionEntry::load(
+            self.sequence_number_to_entry
+              .get(&sequence_number)?
+              .unwrap()
+              .value(),
+          );
+
+          let mut charms = entry.charms.clone();
+          Charm::Burned.set(&mut charms);
+
+          self.sequence_number_to_entry.insert(
+            sequence_number,
+            &InscriptionEntry {
+              charms,
+              ..entry
+            }
+              .store(),
+          )?;
+        }
+
         if let Some(sender) = self.event_sender {
           sender.blocking_send(Event::InscriptionTransferred {
             block_height: self.height,

src/subcommand/wallet/send.rs

@@ -1,4 +1,23 @@
-use {super::*, crate::outgoing::Outgoing, base64::Engine, bitcoin::psbt::Psbt};
+use {super::*, crate::outgoing::Outgoing, base64::Engine, bitcoin::{opcodes,psbt::Psbt}};
+
+#[derive(Clone, Copy)]
+struct AddressParser;
+
+#[derive(Clone, Debug, PartialEq)]
+enum ParsedAddress {
+  Address(Address<NetworkUnchecked>),
+  ScriptBuf(ScriptBuf),
+}
+
+fn parse_address(arg: &str) -> Result<ParsedAddress, bitcoin::address::Error> {
+  if arg == "burn" {
+    let builder = script::Builder::new()
+      .push_opcode(opcodes::all::OP_RETURN);
+    Ok(ParsedAddress::ScriptBuf(builder.into_script()))
+  } else {
+    Ok(ParsedAddress::Address(Address::from_str(arg)?))
+  }
+}
 
 #[derive(Debug, Parser)]
 pub(crate) struct Send {
@@ -11,7 +30,8 @@ pub(crate) struct Send {
     help = "Target <AMOUNT> postage with sent inscriptions. [default: 10000 sat]"
   )]
   pub(crate) postage: Option<Amount>,
-  address: Address<NetworkUnchecked>,
+  #[arg(value_parser = parse_address)]
+  address: ParsedAddress,
   outgoing: Outgoing,
 }
 
@@ -25,25 +45,32 @@ pub struct Output {
 
 impl Send {
   pub(crate) fn run(self, wallet: Wallet) -> SubcommandResult {
-    let address = self
-      .address
-      .clone()
-      .require_network(wallet.chain().network())?;
+    let recipient = match self.address {
+      ParsedAddress::Address(address) => {
+        address
+          .clone()
+          .require_network(wallet.chain().network())?
+          .script_pubkey()
+      }
+      ParsedAddress::ScriptBuf(script_buf) => {
+        script_buf.clone()
+      }
+    };
 
     let unsigned_transaction = match self.outgoing {
       Outgoing::Amount(amount) => {
-        Self::create_unsigned_send_amount_transaction(&wallet, address, amount, self.fee_rate)?
+        Self::create_unsigned_send_amount_transaction(&wallet, recipient, amount, self.fee_rate)?
       }
       Outgoing::Rune { decimal, rune } => Self::create_unsigned_send_runes_transaction(
         &wallet,
-        address,
+        recipient,
         rune,
         decimal,
         self.fee_rate,
       )?,
       Outgoing::InscriptionId(id) => Self::create_unsigned_send_satpoint_transaction(
         &wallet,
-        address,
+        recipient,
         wallet
           .inscription_info()
           .get(&id)
@@ -55,15 +82,15 @@ impl Send {
       )?,
       Outgoing::SatPoint(satpoint) => Self::create_unsigned_send_satpoint_transaction(
         &wallet,
-        address,
+        recipient,
         satpoint,
         self.postage,
         self.fee_rate,
         false,
       )?,
       Outgoing::Sat(sat) => Self::create_unsigned_send_satpoint_transaction(
         &wallet,
-        address,
+        recipient,
         wallet.find_sat_in_outputs(sat)?,
         self.postage,
         self.fee_rate,
@@ -132,7 +159,7 @@ impl Send {
 
   fn create_unsigned_send_amount_transaction(
     wallet: &Wallet,
-    destination: Address,
+    destination: ScriptBuf,
     amount: Amount,
     fee_rate: FeeRate,
   ) -> Result<Transaction> {
@@ -143,7 +170,7 @@ impl Send {
       lock_time: LockTime::ZERO,
       input: Vec::new(),
       output: vec![TxOut {
-        script_pubkey: destination.script_pubkey(),
+        script_pubkey: destination,
         value: amount.to_sat(),
       }],
     };
@@ -159,7 +186,7 @@ impl Send {
 
   fn create_unsigned_send_satpoint_transaction(
     wallet: &Wallet,
-    destination: Address,
+    destination: ScriptBuf,
     satpoint: SatPoint,
     postage: Option<Amount>,
     fee_rate: FeeRate,
@@ -195,18 +222,19 @@ impl Send {
         wallet.utxos().clone(),
         wallet.locked_utxos().clone().into_keys().collect(),
         runic_outputs,
-        destination.clone(),
+        destination,
         change,
         fee_rate,
         postage,
+        wallet.chain().network()
       )
-      .build_transaction()?,
+        .build_transaction()?,
     )
   }
 
   fn create_unsigned_send_runes_transaction(
     wallet: &Wallet,
-    destination: Address,
+    destination: ScriptBuf,
     spaced_rune: SpacedRune,
     decimal: Decimal,
     fee_rate: FeeRate,
@@ -295,7 +323,7 @@ impl Send {
           value: TARGET_POSTAGE.to_sat(),
         },
         TxOut {
-          script_pubkey: destination.script_pubkey(),
+          script_pubkey: destination,
           value: TARGET_POSTAGE.to_sat(),
         },
       ],

src/test.rs

@@ -10,6 +10,7 @@ pub(crate) use {
   std::iter,
   tempfile::TempDir,
   unindent::Unindent,
+  wallet::transaction_builder::OutputType
 };
 
 pub(crate) fn txid(n: u64) -> Txid {
@@ -40,7 +41,16 @@ pub(crate) fn address() -> Address {
     .assume_checked()
 }
 
-pub(crate) fn recipient() -> Address {
+pub(crate) fn recipient() -> ScriptBuf {
+  recipient_as_address()
+    .script_pubkey()
+}
+
+pub(crate) fn recipient_address_as_output_type() -> OutputType {
+  OutputType::Address(recipient_as_address())
+}
+
+pub(crate) fn recipient_as_address() -> Address {
   "tb1q6en7qjxgw4ev8xwx94pzdry6a6ky7wlfeqzunz"
     .parse::<Address<NetworkUnchecked>>()
     .unwrap()
@@ -60,6 +70,10 @@ pub(crate) fn change(n: u64) -> Address {
   .assume_checked()
 }
 
+pub(crate) fn change_as_output_type(n: u64) -> OutputType {
+  OutputType::Address(change(n))
+}
+
 pub(crate) fn tx_in(previous_output: OutPoint) -> TxIn {
   TxIn {
     previous_output,

src/wallet/batch/plan.rs

@@ -523,10 +523,11 @@ impl Plan {
       utxos.clone(),
       locked_utxos.clone(),
       runic_utxos,
-      commit_tx_address.clone(),
+      commit_tx_address.script_pubkey(),
       commit_change,
       self.commit_fee_rate,
       Target::Value(target_value),
+      chain.network()
     )
     .build_transaction()?;
 

src/wallet/recipient.rs

@@ -0,0 +1,56 @@
+use rustls_acme::acme::AuthStatus::Invalid;
+use super::*;
+
+#[derive(Debug, PartialEq)]
+pub(crate) enum RecipientError {
+  InvalidRecipient
+}
+
+impl Display for RecipientError {
+  fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+    match self {
+      RecipientError::InvalidRecipient => {
+        write!(f, "Invalid recipient")
+      }
+    }
+  }
+}
+
+impl std::error::Error for RecipientError {}
+
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) enum Recipient {
+  Address(Address),
+  ScriptBuf(ScriptBuf),
+}
+
+trait ScriptPubkey {
+  fn script_pubkey(&self) -> ScriptBuf;
+}
+
+impl ScriptPubkey for Address {
+  fn script_pubkey(&self) -> ScriptBuf {
+    self.script_pubkey()
+  }
+}
+
+impl ScriptPubkey for ScriptBuf {
+  fn script_pubkey(&self) -> ScriptBuf {
+    self.clone()
+  }
+}
+
+impl Recipient {
+  pub fn to_address(&self) -> Result<Address> {
+    match self {
+      Recipient::Address(address) => Ok(address.clone()),
+      _ => Err(anyhow!(RecipientError::InvalidRecipient)),
+    }
+  }
+  pub fn script_pubkey(&self) -> ScriptBuf {
+    match self {
+      Recipient::Address(address) => address.script_pubkey(),
+      Recipient::ScriptBuf(script_buf) => script_buf.script_pubkey(),
+    }
+  }
+}