implement burn

.gitignore

@@ -10,3 +10,4 @@
 /target
 /test-times.txt
 /tmp
+/.fleet/

src/charm.rs

@@ -1,5 +1,6 @@
 #[derive(Copy, Clone)]
 pub(crate) enum Charm {
+  Burned,
   Coin,
   Cursed,
   Epic,
@@ -13,7 +14,7 @@ pub(crate) enum Charm {
 }
 
 impl Charm {
-  pub(crate) const ALL: [Charm; 10] = [
+  pub(crate) const ALL: [Charm; 11] = [
     Self::Coin,
     Self::Uncommon,
     Self::Rare,
@@ -24,6 +25,7 @@ impl Charm {
     Self::Cursed,
     Self::Unbound,
     Self::Lost,
+    Self::Burned,
   ];
 
   fn flag(self) -> u16 {
@@ -40,6 +42,7 @@ impl Charm {
 
   pub(crate) fn icon(self) -> &'static str {
     match self {
+      Self::Burned => "🔥",
       Self::Coin => "🪙",
       Self::Cursed => "👹",
       Self::Epic => "🪻",
@@ -55,6 +58,7 @@ impl Charm {
 
   pub(crate) fn title(self) -> &'static str {
     match self {
+      Self::Burned => "burned",
       Self::Coin => "coin",
       Self::Cursed => "cursed",
       Self::Epic => "epic",

src/index/updater/inscription_updater.rs

@@ -18,6 +18,7 @@ pub(super) struct Flotsam {
   inscription_id: InscriptionId,
   offset: u64,
   origin: Origin,
+  burned: bool,
 }
 
 #[derive(Debug, Clone)]
@@ -83,6 +84,12 @@ impl<'a, 'db, 'tx> InscriptionUpdater<'a, 'db, 'tx> {
         continue;
       }
 
+      // if the inscription was sent to an OP_RETURN it was burned
+      let is_burned = tx.output
+          .get(input_index)
+          .map(|output| output.script_pubkey.is_op_return())
+          .unwrap_or(false);
+
       // find existing inscriptions on input (transfers of inscriptions)
       for (old_satpoint, inscription_id) in Index::inscriptions_on_output(
         self.satpoint_to_sequence_number,
@@ -94,6 +101,7 @@ impl<'a, 'db, 'tx> InscriptionUpdater<'a, 'db, 'tx> {
           offset,
           inscription_id,
           origin: Origin::Old { old_satpoint },
+          burned: is_burned,
         });
 
         inscribed_offsets
@@ -189,6 +197,7 @@ impl<'a, 'db, 'tx> InscriptionUpdater<'a, 'db, 'tx> {
           .unwrap_or(offset);
 
         floating_inscriptions.push(Flotsam {
+          burned: is_burned,
           inscription_id,
           offset,
           origin: Origin::New {
@@ -367,13 +376,32 @@ impl<'a, 'db, 'tx> InscriptionUpdater<'a, 'db, 'tx> {
           .satpoint_to_sequence_number
           .remove_all(&old_satpoint.store())?;
 
-        (
-          false,
-          self
+        let sequence_number = self
             .id_to_sequence_number
             .get(&inscription_id.store())?
             .unwrap()
-            .value(),
+            .value();
+
+        if flotsam.burned {
+          let mut inscription_entry = InscriptionEntry::load(
+            self
+                .sequence_number_to_entry
+                .get(sequence_number)?
+                .unwrap()
+                .value(),
+          );
+
+          Charm::Burned.set(&mut inscription_entry.charms);
+
+          self.sequence_number_to_entry.insert(
+            sequence_number,
+            &inscription_entry.store(),
+          )?;
+        }
+
+        (
+          false,
+          sequence_number
         )
       }
       Origin::New {

src/subcommand/server.rs

@@ -29,6 +29,10 @@ use {
   },
   axum_server::Handle,
   brotli::Decompressor,
+  bitcoin::blockdata::script::Instruction::{
+    Op, PushBytes
+  },
+  bitcoin::blockdata::opcodes::all::{OP_PUSHNUM_NEG1,OP_RETURN},
   rust_embed::RustEmbed,
   rustls_acme::{
     acme::{LETS_ENCRYPT_PRODUCTION_DIRECTORY, LETS_ENCRYPT_STAGING_DIRECTORY},
@@ -1242,11 +1246,37 @@ impl Server {
       Charm::Lost.set(&mut charms);
     }
 
+    let mut is_burned = false;
+    let burn_payload = output.as_ref().and_then(|o| {
+      let mut instructions = o.script_pubkey.instructions();
+
+      // Check if the first instruction is OP_RETURN
+      if let Some(Ok(Op(OP_RETURN))) = instructions.next() {
+        // Check if the second instruction is OP_1NEGATE
+        if let Some(Ok(Op(OP_PUSHNUM_NEG1))) = instructions.next() {
+          is_burned = true;
+          // Extract the payload if it exists
+          instructions.filter_map(|instr| {
+            if let Ok(PushBytes(data)) = instr {
+              String::from_utf8(data.as_bytes().to_vec()).ok()
+            } else {
+              None
+            }
+          }).next()
+        } else {
+          None
+        }
+      } else {
+        None
+      }
+    });
+
     Ok(if accept_json.0 {
       Json(InscriptionJson {
         inscription_id,
         children,
         inscription_number: entry.inscription_number,
+        is_burned: Some(is_burned),
         genesis_height: entry.height,
         parent,
         genesis_fee: entry.fee,
@@ -1268,10 +1298,13 @@ impl Server {
         previous,
         next,
         rune,
+        burn_payload,
+        charms: Some(charms),
       })
       .into_response()
     } else {
       InscriptionHtml {
+        burn_payload,
         chain: server_config.chain,
         charms,
         children,
@@ -1280,6 +1313,7 @@ impl Server {
         inscription,
         inscription_id,
         inscription_number: entry.inscription_number,
+        is_burned: Some(is_burned),
         next,
         output,
         parent,

src/subcommand/wallet.rs

@@ -46,7 +46,7 @@ pub(crate) enum Wallet {
   Restore(restore::Restore),
   #[command(about = "List wallet satoshis")]
   Sats(sats::Sats),
-  #[command(about = "Send sat or inscription")]
+  #[command(about = "Send sat or inscription (option to burn)")]
   Send(send::Send),
   #[command(about = "See wallet transactions")]
   Transactions(transactions::Transactions),

src/subcommand/wallet/inscribe/batch.rs

@@ -340,6 +340,7 @@ impl Batch {
       change,
       self.commit_fee_rate,
       Target::Value(reveal_fee + total_postage),
+      chain,
     )
     .build_transaction()?;
 

src/subcommand/wallet/send.rs

@@ -1,9 +1,32 @@
-use {super::*, crate::subcommand::wallet::transaction_builder::Target, crate::wallet::Wallet};
+use bitcoin::script::Builder;
+use {
+  super::*,
+  bitcoin::{
+    blockdata::opcodes::all::{OP_PUSHNUM_NEG1,OP_RETURN},
+    script::PushBytesBuf,
+  },
+  crate::{
+    subcommand::wallet::transaction_builder::{Target},
+    wallet::Wallet,
+  },
+};
 
 #[derive(Debug, Parser, Clone)]
+#[clap(
+  group = ArgGroup::new("output")
+  .required(true)
+  .args(&["address", "burn"]),
+)]
 pub(crate) struct Send {
-  address: Address<NetworkUnchecked>,
   outgoing: Outgoing,
+  #[arg(long, conflicts_with = "burn", help = "Recipient address")]
+  address: Option<Address<NetworkUnchecked>>,
+  #[arg(
+    long,
+    conflicts_with = "address",
+    help = "Message to append when burning sats"
+  )]
+  burn: Option<String>,
   #[arg(long, help = "Use fee rate of <FEE_RATE> sats/vB")]
   fee_rate: FeeRate,
   #[arg(
@@ -20,10 +43,7 @@ pub struct Output {
 
 impl Send {
   pub(crate) fn run(self, options: Options) -> SubcommandResult {
-    let address = self
-      .address
-      .clone()
-      .require_network(options.chain().network())?;
+    let output = self.get_output(&options)?;
 
     let index = Index::open(&options)?;
     index.update()?;
@@ -45,14 +65,33 @@ impl Send {
 
     let satpoint = match self.outgoing {
       Outgoing::Amount(amount) => {
+        // let script = output.get_script(); // Replace with the actual method to get the Script from output
+
+        if output.is_op_return() {
+          bail!("refusing to burn amount");
+        }
+
+        let address = match chain.address_from_script(output.as_script()) {
+          Ok(addr) => addr,
+          Err(e) => {
+            bail!("failed to get address from script: {:?}", e);
+          }
+        };
+
         Self::lock_non_cardinal_outputs(&client, &inscriptions, &runic_outputs, unspent_outputs)?;
-        let transaction = Self::send_amount(&client, amount, address, self.fee_rate)?;
-        return Ok(Box::new(Output { transaction }));
-      }
+        let txid = Self::send_amount(&client, amount, address, self.fee_rate)?;
+        return Ok(Box::new(Output { transaction: txid }));
+      },
       Outgoing::InscriptionId(id) => index
         .get_inscription_satpoint_by_id(id)?
         .ok_or_else(|| anyhow!("inscription {id} not found"))?,
       Outgoing::Rune { decimal, rune } => {
+        let address = self
+            .address
+            .unwrap()
+            .clone()
+            .require_network(options.chain().network())?;
+
         let transaction = Self::send_runes(
           address,
           chain,
@@ -100,10 +139,11 @@ impl Send {
       unspent_outputs,
       locked_outputs,
       runic_outputs,
-      address.clone(),
+      output,
       change,
       self.fee_rate,
       postage,
+      chain,
     )
     .build_transaction()?;
 
@@ -116,6 +156,25 @@ impl Send {
     Ok(Box::new(Output { transaction: txid }))
   }
 
+  fn get_output(&self, options: &Options) -> Result<ScriptBuf, Error> {
+    if let Some(address) = &self.address {
+      let address = address.clone().require_network(options.chain().network())?;
+      Ok(ScriptBuf::from(address))
+    } else if let Some(msg) = &self.burn {
+      let push_data_buf = PushBytesBuf::try_from(Vec::from(msg.clone()))
+          .expect("burn payload too large");
+
+      Ok(Builder::new()
+        .push_opcode(OP_RETURN)
+        .push_opcode(OP_PUSHNUM_NEG1)
+        .push_slice(&push_data_buf)
+        .into_script()
+      )
+    } else {
+      bail!("no valid output given")
+    }
+  }
+
   fn lock_non_cardinal_outputs(
     client: &Client,
     inscriptions: &BTreeMap<SatPoint, InscriptionId>,