btc: support op_return outputs

Author: benma's agent

CHANGELOG-npm.md

@@ -1,5 +1,8 @@
 # Changelog
 
+## 0.12.0
+- btc: add support for OP_RETURN outputs
+
 ## 0.11.0
 - Add `btcXpubs()`
 

CHANGELOG-rust.md

@@ -1,5 +1,8 @@
 # Changelog
 
+## 0.11.0
+- btc: add support for OP_RETURN outputs
+
 ## 0.10.0
 - Add `btc_xpubs()`
 

Cargo.lock

@@ -1,7 +1,7 @@
 [package]
 name = "bitbox-api"
 authors = ["Marko Bencun <[email protected]>"]
-version = "0.10.0"
+version = "0.11.0"
 homepage = "https://bitbox.swiss/"
 repository = "https://github.com/BitBoxSwiss/bitbox-api-rs/"
 readme = "README-rust.md"

Cargo.toml

@@ -1 +1 @@
-0.11.0
+0.12.0

NPM_VERSION

@@ -175,6 +175,7 @@ enum BTCOutputType {
   P2WPKH = 3;
   P2WSH = 4;
   P2TR = 5;
+  OP_RETURN = 6;
 }
 
 message BTCSignOutputRequest {

messages/btc.proto

@@ -13,6 +13,8 @@ pub use bitcoin::{
     Script,
 };
 
+use bitcoin::blockdata::{opcodes, script::Instruction};
+
 #[cfg(feature = "wasm")]
 use enum_assoc::Assoc;
 
@@ -160,6 +162,8 @@ pub struct Payload {
 pub enum PayloadError {
     #[error("unrecognized pubkey script")]
     Unrecognized,
+    #[error("{0}")]
+    InvalidOpReturn(&'static str),
 }
 
 impl Payload {
@@ -190,6 +194,46 @@ impl Payload {
                 data: pkscript[2..].to_vec(),
                 output_type: pb::BtcOutputType::P2tr,
             })
+        } else if matches!(script.as_bytes().first(), Some(byte) if *byte == opcodes::all::OP_RETURN.to_u8())
+        {
+            let mut instructions = script.instructions_minimal();
+            match instructions.next() {
+                Some(Ok(Instruction::Op(op))) if op == opcodes::all::OP_RETURN => {}
+                _ => return Err(PayloadError::Unrecognized),
+            }
+
+            let payload = match instructions.next() {
+                None => {
+                    return Err(PayloadError::InvalidOpReturn(
+                        "naked OP_RETURN is not supported",
+                    ))
+                }
+                Some(Ok(Instruction::Op(op))) if op == opcodes::all::OP_PUSHBYTES_0 => Vec::new(),
+                Some(Ok(Instruction::PushBytes(push))) => push.as_bytes().to_vec(),
+                Some(Ok(_)) => {
+                    return Err(PayloadError::InvalidOpReturn(
+                        "no data push found after OP_RETURN",
+                    ))
+                }
+                Some(Err(_)) => {
+                    return Err(PayloadError::InvalidOpReturn(
+                        "failed to parse OP_RETURN payload",
+                    ))
+                }
+            };
+
+            match instructions.next() {
+                None => Ok(Payload {
+                    data: payload,
+                    output_type: pb::BtcOutputType::OpReturn,
+                }),
+                Some(Ok(_)) => Err(PayloadError::InvalidOpReturn(
+                    "only one data push supported after OP_RETURN",
+                )),
+                Some(Err(_)) => Err(PayloadError::InvalidOpReturn(
+                    "failed to parse OP_RETURN payload",
+                )),
+            }
         } else {
             Err(PayloadError::Unrecognized)
         }
@@ -206,8 +250,7 @@ impl TryFrom<&bitcoin::TxOut> for TxExternalOutput {
     type Error = PsbtError;
     fn try_from(value: &bitcoin::TxOut) -> Result<Self, Self::Error> {
         Ok(TxExternalOutput {
-            payload: Payload::from_pkscript(value.script_pubkey.as_bytes())
-                .map_err(|_| PsbtError::UnknownOutputType)?,
+            payload: Payload::from_pkscript(value.script_pubkey.as_bytes())?,
             value: value.value.to_sat(),
         })
     }
@@ -251,6 +294,18 @@ pub enum PsbtError {
     #[error("Unrecognized/unsupported output type.")]
     #[cfg_attr(feature = "wasm", assoc(js_code = "unknown-output-type"))]
     UnknownOutputType,
+    #[error("Invalid OP_RETURN script: {0}")]
+    #[cfg_attr(feature = "wasm", assoc(js_code = "invalid-op-return"))]
+    InvalidOpReturn(&'static str),
+}
+
+impl From<PayloadError> for PsbtError {
+    fn from(value: PayloadError) -> Self {
+        match value {
+            PayloadError::Unrecognized => PsbtError::UnknownOutputType,
+            PayloadError::InvalidOpReturn(message) => PsbtError::InvalidOpReturn(message),
+        }
+    }
 }
 
 enum OurKey {
@@ -753,6 +808,15 @@ impl<R: Runtime> PairedBitBox<R> {
         if transaction.script_configs.iter().any(is_taproot_simple) {
             self.validate_version(">=9.10.0")?; // taproot since 9.10.0
         }
+        if transaction.outputs.iter().any(|output| {
+            matches!(
+                output,
+                TxOutput::External(tx_output)
+                    if tx_output.payload.output_type == pb::BtcOutputType::OpReturn
+            )
+        }) {
+            self.validate_version(">=9.24.0")?;
+        }
 
         let mut sigs: Vec<Vec<u8>> = Vec::new();
 
@@ -1181,6 +1245,62 @@ mod tests {
                 output_type: pb::BtcOutputType::P2tr,
             }
         );
+
+        // OP_RETURN empty (OP_0)
+        let pkscript = hex::decode("6a00").unwrap();
+        assert_eq!(
+            Payload::from_pkscript(&pkscript).unwrap(),
+            Payload {
+                data: Vec::new(),
+                output_type: pb::BtcOutputType::OpReturn,
+            }
+        );
+
+        // OP_RETURN with data push
+        let pkscript = hex::decode("6a03aabbcc").unwrap();
+        assert_eq!(
+            Payload::from_pkscript(&pkscript).unwrap(),
+            Payload {
+                data: vec![0xaa, 0xbb, 0xcc],
+                output_type: pb::BtcOutputType::OpReturn,
+            }
+        );
+
+        // OP_RETURN with 80-byte payload (PUSHDATA1)
+        let mut pkscript = vec![opcodes::all::OP_RETURN.to_u8(), 0x4c, 0x50];
+        pkscript.extend(std::iter::repeat_n(0xaa, 80));
+        assert_eq!(
+            Payload::from_pkscript(&pkscript).unwrap(),
+            Payload {
+                data: vec![0xaa; 80],
+                output_type: pb::BtcOutputType::OpReturn,
+            }
+        );
+
+        // Invalid OP_RETURN scripts
+        let pkscript = hex::decode("6a").unwrap();
+        assert!(matches!(
+            Payload::from_pkscript(&pkscript),
+            Err(PayloadError::InvalidOpReturn(
+                "naked OP_RETURN is not supported"
+            ))
+        ));
+
+        let pkscript = hex::decode("6a6a").unwrap();
+        assert!(matches!(
+            Payload::from_pkscript(&pkscript),
+            Err(PayloadError::InvalidOpReturn(
+                "no data push found after OP_RETURN"
+            ))
+        ));
+
+        let pkscript = hex::decode("6a0000").unwrap();
+        assert!(matches!(
+            Payload::from_pkscript(&pkscript),
+            Err(PayloadError::InvalidOpReturn(
+                "only one data push supported after OP_RETURN"
+            ))
+        ));
     }
 
     // Test that a PSBT containing only p2wpkh inputs is converted correctly to a transaction to be

sandbox/package-lock.json

@@ -1190,6 +1190,7 @@ pub enum BtcOutputType {
     P2wpkh = 3,
     P2wsh = 4,
     P2tr = 5,
+    OpReturn = 6,
 }
 impl BtcOutputType {
     /// String value of the enum field names used in the ProtoBuf definition.
@@ -1204,6 +1205,7 @@ impl BtcOutputType {
             Self::P2wpkh => "P2WPKH",
             Self::P2wsh => "P2WSH",
             Self::P2tr => "P2TR",
+            Self::OpReturn => "OP_RETURN",
         }
     }
     /// Creates an enum from field names used in the ProtoBuf definition.
@@ -1215,6 +1217,7 @@ impl BtcOutputType {
             "P2WPKH" => Some(Self::P2wpkh),
             "P2WSH" => Some(Self::P2wsh),
             "P2TR" => Some(Self::P2tr),
+            "OP_RETURN" => Some(Self::OpReturn),
             _ => None,
         }
     }

src/btc.rs

@@ -12,10 +12,12 @@ use util::test_initialized_simulators;
 use bitbox_api::{btc::Xpub, pb};
 
 use bitcoin::bip32::DerivationPath;
+use bitcoin::opcodes::all;
 use bitcoin::psbt::Psbt;
 use bitcoin::secp256k1;
 use bitcoin::{
-    transaction, Amount, OutPoint, ScriptBuf, Sequence, Transaction, TxIn, TxOut, Witness,
+    blockdata::script::Builder, transaction, Amount, OutPoint, ScriptBuf, Sequence, Transaction,
+    TxIn, TxOut, Witness,
 };
 use miniscript::psbt::PsbtExt;
 
@@ -338,6 +340,109 @@ async fn test_btc_psbt_mixed_spend() {
     .await
 }
 
+#[tokio::test]
+async fn test_btc_psbt_op_return() {
+    test_initialized_simulators(async |bitbox| {
+        if !semver::VersionReq::parse(">=9.24.0")
+            .unwrap()
+            .matches(bitbox.version())
+        {
+            // OP_RETURN outputs are supported from firmware v9.24.0.
+            return;
+        }
+
+        let secp = secp256k1::Secp256k1::new();
+        let fingerprint = util::simulator_xprv().fingerprint(&secp);
+
+        let input_path: DerivationPath = "m/84'/1'/0'/0/5".parse().unwrap();
+        let change_path: DerivationPath = "m/84'/1'/0'/1/0".parse().unwrap();
+
+        let input_pub = util::simulator_xpub_at(&secp, &input_path).to_pub();
+        let change_pub = util::simulator_xpub_at(&secp, &change_path).to_pub();
+
+        let prev_tx = Transaction {
+            version: transaction::Version::TWO,
+            lock_time: bitcoin::absolute::LockTime::ZERO,
+            input: vec![TxIn {
+                previous_output:
+                    "3131313131313131313131313131313131313131313131313131313131313131:0"
+                        .parse()
+                        .unwrap(),
+                script_sig: ScriptBuf::new(),
+                sequence: Sequence(0xFFFFFFFF),
+                witness: Witness::default(),
+            }],
+            output: vec![TxOut {
+                value: Amount::from_sat(50_000_000),
+                script_pubkey: ScriptBuf::new_p2wpkh(&input_pub.wpubkey_hash()),
+            }],
+        };
+
+        let op_return_data = b"hello world";
+        let op_return_script = Builder::new()
+            .push_opcode(all::OP_RETURN)
+            .push_slice(op_return_data)
+            .into_script();
+
+        let tx = Transaction {
+            version: transaction::Version::TWO,
+            lock_time: bitcoin::absolute::LockTime::ZERO,
+            input: vec![TxIn {
+                previous_output: OutPoint {
+                    txid: prev_tx.compute_txid(),
+                    vout: 0,
+                },
+                script_sig: ScriptBuf::new(),
+                sequence: Sequence(0xFFFFFFFF),
+                witness: Witness::default(),
+            }],
+            output: vec![
+                TxOut {
+                    value: Amount::from_sat(49_000_000),
+                    script_pubkey: ScriptBuf::new_p2wpkh(&change_pub.wpubkey_hash()),
+                },
+                TxOut {
+                    value: Amount::from_sat(0),
+                    script_pubkey: op_return_script.clone(),
+                },
+            ],
+        };
+
+        let mut psbt = Psbt::from_unsigned_tx(tx).unwrap();
+
+        psbt.inputs[0].non_witness_utxo = Some(prev_tx.clone());
+        psbt.inputs[0].witness_utxo = Some(prev_tx.output[0].clone());
+        psbt.inputs[0]
+            .bip32_derivation
+            .insert(input_pub.0, (fingerprint, input_path.clone()));
+
+        psbt.outputs[0]
+            .bip32_derivation
+            .insert(change_pub.0, (fingerprint, change_path.clone()));
+
+        bitbox
+            .btc_sign_psbt(
+                pb::BtcCoin::Tbtc,
+                &mut psbt,
+                None,
+                pb::btc_sign_init_request::FormatUnit::Default,
+            )
+            .await
+            .unwrap();
+
+        psbt.finalize_mut(&secp).unwrap();
+
+        let final_tx = psbt.clone().extract_tx_unchecked_fee_rate();
+        assert_eq!(final_tx.output.len(), 2);
+        assert_eq!(final_tx.output[1].value, Amount::from_sat(0));
+        assert_eq!(final_tx.output[1].script_pubkey, op_return_script);
+
+        // Verify the signed tx, including that all sigs/witnesses are correct.
+        verify_transaction(psbt);
+    })
+    .await
+}
+
 #[tokio::test]
 async fn test_btc_psbt_multisig_p2wsh() {
     test_initialized_simulators(async |bitbox| {