@bennyblader/ddk-rn 0.3.31 → 0.3.33

package/ddk-ffi/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ddk_ffi"
-version = "0.3.31"
+version = "0.3.33"
 edition = "2021"
 license = "MIT"
 description = "rust-dlc language bindings"

package/ddk-ffi/src/ddk_ffi.udl

@@ -205,6 +205,31 @@ namespace ddk_ffi {
         sequence<OracleInfo> oracle_info,
         sequence<sequence<sequence<sequence<u8>>>> msgs
     );
+
+    [Throws=DLCError]
+    sequence<u8> extract_ecdsa_signature_from_oracle_signatures(
+        sequence<sequence<u8>> oracle_signatures,
+        sequence<u8> adaptor_signature
+    );
+
+    // Debug function to get all inputs for adaptor signature creation
+    // Use this to compare values with Fordefi
+    [Throws=DLCError]
+    CetAdaptorSignatureDebugInfo get_cet_adaptor_signature_inputs(
+        Transaction cet,
+        sequence<OracleInfo> oracle_info,
+        sequence<u8> funding_script_pubkey,
+        u64 fund_output_value,
+        sequence<sequence<sequence<u8>>> msgs
+    );
+
+    // Get sighash for a CET - the actual message that gets signed
+    [Throws=DLCError]
+    sequence<u8> get_cet_sighash(
+        Transaction cet,
+        sequence<u8> funding_script_pubkey,
+        u64 fund_output_value
+    );
 };
 
 // Transaction representation
@@ -297,6 +322,25 @@ dictionary OracleInfo {
     sequence<sequence<u8>> nonces;
 };
 
+// Debug info for CET adaptor signature inputs
+// All the values that go into creating an adaptor signature
+dictionary CetAdaptorSignatureDebugInfo {
+    // The sighash (32 bytes) - this is the message that gets signed
+    sequence<u8> sighash;
+    // The adaptor point (33 bytes compressed public key)
+    sequence<u8> adaptor_point;
+    // Input index (always 0 for CETs)
+    u32 input_index;
+    // The funding script pubkey used for sighash
+    sequence<u8> script_pubkey;
+    // The fund output value used for sighash
+    u64 value;
+    // The CET txid
+    string cet_txid;
+    // Raw CET bytes for verification
+    sequence<u8> cet_raw;
+};
+
 // Error types for DLC operations
 [Error]
 enum DLCError {

package/ddk-ffi/src/lib.rs

@@ -9,13 +9,15 @@ use bitcoin::{
     TxOut as BtcTxOut, Txid, Witness,
 };
 use bitcoin::{Script, WPubkeyHash};
+use ddk_dlc::secp_utils;
 use ddk_dlc::{
     self, dlc_input::DlcInputInfo as RustDlcInputInfo, DlcTransactions as RustDlcTransactions,
     OracleInfo as DlcOracleInfo, PartyParams as DlcPartyParams, Payout as DlcPayout,
     TxInputInfo as DlcTxInputInfo,
 };
 use secp256k1_zkp::{
-    ecdsa::Signature as EcdsaSignature, Message, PublicKey, Secp256k1, SecretKey, XOnlyPublicKey,
+    ecdsa::Signature as EcdsaSignature, Message, PublicKey, Scalar, Secp256k1, SecretKey,
+    XOnlyPublicKey,
 };
 use secp256k1_zkp::{schnorr::Signature as SchnorrSignature, All, EcdsaAdaptorSignature};
 use std::str::FromStr;
@@ -191,6 +193,31 @@ pub struct OracleInfo {
     pub nonces: Vec<Vec<u8>>,
 }
 
+/// Debug info for CET adaptor signature inputs.
+///
+/// Contains all the values that go into creating an adaptor signature,
+/// useful for comparing with external signers during debugging.
+///
+/// This struct is intentionally always available (not feature-gated)
+/// to support production debugging scenarios.
+#[derive(Clone)]
+pub struct CetAdaptorSignatureDebugInfo {
+    /// The sighash (32 bytes) - this is the message that gets signed
+    pub sighash: Vec<u8>,
+    /// The adaptor point (33 bytes compressed public key)
+    pub adaptor_point: Vec<u8>,
+    /// Input index (always 0 for CETs)
+    pub input_index: u32,
+    /// The funding script pubkey used for sighash
+    pub script_pubkey: Vec<u8>,
+    /// The fund output value used for sighash
+    pub value: u64,
+    /// The CET txid
+    pub cet_txid: String,
+    /// Raw CET bytes for verification
+    pub cet_raw: Vec<u8>,
+}
+
 // Conversion helpers
 pub fn btc_tx_to_transaction(tx: &BtcTransaction) -> Transaction {
     use bitcoin::consensus::Encodable;
@@ -828,6 +855,33 @@ fn vec_to_ecdsa_adaptor_signature(signature: Vec<u8>) -> Result<EcdsaAdaptorSign
     EcdsaAdaptorSignature::from_slice(&signature).map_err(|_| DLCError::InvalidSignature)
 }
 
+fn signatures_to_secret(signatures: &[Vec<SchnorrSignature>]) -> Result<SecretKey, DLCError> {
+    let s_values = signatures
+        .iter()
+        .flatten()
+        .map(|x| match secp_utils::schnorrsig_decompose(x) {
+            Ok(v) => Ok(v.1),
+            Err(err) => Err(DLCError::Secp256k1Error(err.to_string())),
+        })
+        .collect::<Result<Vec<&[u8]>, DLCError>>()?;
+
+    if s_values.is_empty() {
+        return Err(DLCError::InvalidArgument(
+            "No signatures provided".to_string(),
+        ));
+    }
+
+    let secret = SecretKey::from_slice(s_values[0])
+        .map_err(|_| DLCError::InvalidArgument("Invalid signature".to_string()))?;
+
+    let result = s_values.iter().skip(1).fold(secret, |accum, s| {
+        let sec = SecretKey::from_slice(s).unwrap();
+        accum.add_tweak(&Scalar::from(sec)).unwrap()
+    });
+
+    Ok(result)
+}
+
 pub fn create_cet_adaptor_sigs_from_oracle_info(
     cets: Vec<Transaction>,
     oracle_info: Vec<OracleInfo>,
@@ -1100,6 +1154,141 @@ pub fn create_cet_adaptor_points_from_oracle_info(
     Ok(adaptor_points)
 }
 
+pub fn extract_ecdsa_signature_from_oracle_signatures(
+    oracle_signatures: Vec<Vec<u8>>,
+    adaptor_signature: Vec<u8>,
+) -> Result<Vec<u8>, DLCError> {
+    // Convert oracle signatures to Schnorr signatures
+    let oracle_sigs = oracle_signatures
+        .iter()
+        .map(|sig| vec_to_schnorr_signature(sig.as_slice()))
+        .collect::<Result<Vec<_>, _>>()?;
+
+    // Extract the secret key from oracle signatures
+    let adaptor_secret = signatures_to_secret(&[oracle_sigs])?;
+
+    // Convert adaptor signature to EcdsaAdaptorSignature
+    let adaptor_sig = vec_to_ecdsa_adaptor_signature(adaptor_signature)?;
+
+    // Decrypt the adaptor signature to get the final ECDSA signature
+    let ecdsa_sig = adaptor_sig
+        .decrypt(&adaptor_secret)
+        .map_err(|e| DLCError::Secp256k1Error(e.to_string()))?;
+
+    // Return the DER-encoded signature
+    Ok(ecdsa_sig.serialize_der().to_vec())
+}
+
+/// Get all the inputs that go into creating a CET adaptor signature.
+///
+/// This debug function is intentionally always available (not feature-gated)
+/// to enable debugging signature mismatches in production environments where
+/// rebuilding with debug features may not be feasible.
+///
+/// Use this to compare values with external signers (e.g., Fordefi) when
+/// debugging adaptor signature verification failures.
+///
+/// Returns:
+/// - `sighash`: The 32-byte BIP143 sighash message that gets signed
+/// - `adaptor_point`: The 33-byte compressed adaptor public key
+/// - `input_index`: Always 0 for CETs
+/// - `script_pubkey`: The funding script used for sighash calculation
+/// - `value`: The fund output value used for sighash calculation
+/// - `cet_txid`: The CET transaction ID
+/// - `cet_raw`: Raw serialized CET bytes
+pub fn get_cet_adaptor_signature_inputs(
+    cet: Transaction,
+    oracle_info: Vec<OracleInfo>,
+    funding_script_pubkey: Vec<u8>,
+    fund_output_value: u64,
+    msgs: Vec<Vec<Vec<u8>>>,
+) -> Result<CetAdaptorSignatureDebugInfo, DLCError> {
+    let btc_tx = transaction_to_btc_tx(&cet)?;
+    let funding_script = Script::from_bytes(&funding_script_pubkey);
+
+    // Convert oracle info
+    let oracle_infos: Vec<DlcOracleInfo> = oracle_info
+        .iter()
+        .map(|info| {
+            let public_key = XOnlyPublicKey::from_slice(&info.public_key)
+                .map_err(|_| DLCError::InvalidPublicKey)?;
+            let nonces = info
+                .nonces
+                .iter()
+                .map(|nonce| XOnlyPublicKey::from_slice(nonce))
+                .collect::<Result<Vec<_>, _>>()
+                .map_err(|_| DLCError::InvalidArgument("Invalid nonce pubkey".to_string()))?;
+            Ok(DlcOracleInfo { public_key, nonces })
+        })
+        .collect::<Result<Vec<_>, DLCError>>()?;
+
+    // Convert messages
+    let cet_msgs: Vec<Vec<Message>> = msgs
+        .into_iter()
+        .map(|outcome_msgs| {
+            outcome_msgs
+                .iter()
+                .map(|m| {
+                    Message::from_digest_slice(m)
+                        .map_err(|_| DLCError::InvalidArgument("Invalid message".to_string()))
+                })
+                .collect::<Result<Vec<_>, _>>()
+        })
+        .collect::<Result<Vec<_>, _>>()?;
+
+    let secp = get_secp_context();
+
+    // Get the adaptor point
+    let adaptor_point = ddk_dlc::get_adaptor_point_from_oracle_info(secp, &oracle_infos, &cet_msgs)
+        .map_err(|e| DLCError::Secp256k1Error(e.to_string()))?;
+
+    // Get the sighash - this is the actual message being signed
+    let sig_hash = ddk_dlc::util::get_sig_hash_msg(
+        &btc_tx,
+        0, // input_index is always 0 for CETs
+        funding_script,
+        Amount::from_sat(fund_output_value),
+    )
+    .map_err(DLCError::from)?;
+
+    Ok(CetAdaptorSignatureDebugInfo {
+        sighash: sig_hash.as_ref().to_vec(),
+        adaptor_point: adaptor_point.serialize().to_vec(),
+        input_index: 0,
+        script_pubkey: funding_script_pubkey,
+        value: fund_output_value,
+        cet_txid: btc_tx.compute_txid().to_string(),
+        cet_raw: cet.raw_bytes,
+    })
+}
+
+/// Get the sighash for a CET - the actual 32-byte message that gets signed.
+///
+/// This debug function is intentionally always available (not feature-gated)
+/// to enable debugging sighash mismatches in production environments where
+/// rebuilding with debug features may not be feasible.
+///
+/// Use this to compare sighash values with external signers (e.g., Fordefi)
+/// when debugging signature verification failures.
+pub fn get_cet_sighash(
+    cet: Transaction,
+    funding_script_pubkey: Vec<u8>,
+    fund_output_value: u64,
+) -> Result<Vec<u8>, DLCError> {
+    let btc_tx = transaction_to_btc_tx(&cet)?;
+    let funding_script = Script::from_bytes(&funding_script_pubkey);
+
+    let sig_hash = ddk_dlc::util::get_sig_hash_msg(
+        &btc_tx,
+        0, // input_index is always 0 for CETs
+        funding_script,
+        Amount::from_sat(fund_output_value),
+    )
+    .map_err(DLCError::from)?;
+
+    Ok(sig_hash.as_ref().to_vec())
+}
+
 pub fn convert_mnemonic_to_seed(
     mnemonic: String,
     passphrase: Option<String>,
@@ -1735,7 +1924,7 @@ mod tests {
         let mut rng = secp256k1_zkp::rand::thread_rng();
         let (offer_party_params, offer_fund_sk) =
             get_party_params(1_000_000_000, 100_000_000, None);
-        let (accept_party_params, accept_fund_sk) =
+        let (accept_party_params, _accept_fund_sk) =
             get_party_params(1_000_000_000, 100_000_000, None);
 
         let dlc_txs = create_dlc_transactions(
@@ -1837,7 +2026,7 @@ mod tests {
             cets[0].clone(),
             cet_sigs[0].signature.clone(),
             oracle_signatures[0].clone(),
-            accept_fund_sk.secret_bytes().to_vec(),
+            _accept_fund_sk.secret_bytes().to_vec(),
             offer_party_params.fund_pubkey.clone(),
             accept_party_params.fund_pubkey.clone(),
             fund_output_value,
@@ -1886,4 +2075,368 @@ mod tests {
         )
         .expect("Invalid decrypted adaptor signature");
     }
+
+    #[test]
+    fn test_extract_ecdsa_signature_from_oracle_signatures() {
+        // Setup test data (similar to the main test)
+        let secp = Secp256k1::new();
+        let mut rng = secp256k1_zkp::rand::thread_rng();
+        let (offer_party_params, offer_fund_sk) =
+            get_party_params(1_000_000_000, 100_000_000, None);
+        let (accept_party_params, _accept_fund_sk) =
+            get_party_params(1_000_000_000, 100_000_000, None);
+
+        let dlc_txs = create_dlc_transactions(
+            payouts_test(),
+            offer_party_params.clone(),
+            accept_party_params.clone(),
+            100,
+            4,
+            10,
+            10,
+            0, // Add missing fund_output_serial_id parameter
+        )
+        .unwrap();
+
+        let cets = dlc_txs.cets;
+        const NB_ORACLES: usize = 1; // 1 oracle
+        const NB_OUTCOMES: usize = 3; // 3 outcomes (enumeration)
+        const NB_DIGITS: usize = 1; // 1 nonce for enumeration contract
+
+        let mut oracle_infos: Vec<OracleInfo> = Vec::with_capacity(NB_ORACLES);
+        let mut oracle_sks: Vec<Keypair> = Vec::with_capacity(NB_ORACLES);
+        let mut oracle_sk_nonce: Vec<Vec<[u8; 32]>> = Vec::with_capacity(NB_ORACLES);
+        let mut oracle_sigs: Vec<Vec<SchnorrSignature>> = Vec::with_capacity(NB_ORACLES);
+
+        // Messages: 3 outcomes × 1 oracle × 1 message per outcome
+        let messages: Vec<Vec<Vec<_>>> = (0..NB_OUTCOMES)
+            .map(|outcome_idx| {
+                vec![
+                    // Single oracle
+                    vec![
+                        // Single message for this outcome
+                        {
+                            let message = &[outcome_idx as u8]; // Different message per outcome
+                            let hash = sha256::Hash::hash(message).to_byte_array();
+                            hash.to_vec()
+                        },
+                    ],
+                ]
+            })
+            .collect();
+
+        // Setup single oracle with single nonce
+        for i in 0..NB_ORACLES {
+            // Runs once
+            let oracle_kp = Keypair::new(&secp, &mut rng);
+            let oracle_pubkey = oracle_kp.x_only_public_key().0;
+            let mut nonces: Vec<XOnlyPublicKey> = Vec::with_capacity(NB_DIGITS);
+            let mut sk_nonces: Vec<[u8; 32]> = Vec::with_capacity(NB_DIGITS);
+            oracle_sigs.push(Vec::with_capacity(NB_DIGITS));
+
+            // Single nonce for enumeration
+            let mut sk_nonce = [0u8; 32];
+            rng.fill_bytes(&mut sk_nonce);
+            let oracle_r_kp = Keypair::from_seckey_slice(&secp, &sk_nonce).unwrap();
+            let nonce = XOnlyPublicKey::from_keypair(&oracle_r_kp).0;
+
+            // Sign the first outcome's message with the single nonce
+            let sig = secp_utils::schnorrsig_sign_with_nonce(
+                &secp,
+                &Message::from_digest_slice(&messages[0][0][0]).unwrap(), // First outcome, first oracle, first message
+                &oracle_kp,
+                &sk_nonce,
+            );
+
+            oracle_sigs[i].push(sig);
+            nonces.push(nonce);
+            sk_nonces.push(sk_nonce);
+
+            oracle_infos.push(OracleInfo {
+                public_key: oracle_pubkey.serialize().to_vec(),
+                nonces: nonces.iter().map(|n| n.serialize().to_vec()).collect(), // Just 1 nonce
+            });
+            oracle_sk_nonce.push(sk_nonces);
+            oracle_sks.push(oracle_kp);
+        }
+
+        let funding_script_pubkey = ddk_dlc::make_funding_redeemscript(
+            &PublicKey::from_slice(&offer_party_params.fund_pubkey.clone()).unwrap(),
+            &PublicKey::from_slice(&accept_party_params.fund_pubkey.clone()).unwrap(),
+        );
+        let fund_output_value = dlc_txs.fund.outputs[0].value;
+
+        // Create adaptor signatures
+        let cet_sigs = create_cet_adaptor_sigs_from_oracle_info(
+            cets.clone(),
+            oracle_infos.clone(),
+            offer_fund_sk.secret_bytes().to_vec(),
+            funding_script_pubkey.clone().into_bytes(),
+            fund_output_value,
+            messages.clone(),
+        )
+        .unwrap();
+
+        // Convert oracle signatures to the format expected by our function
+        let oracle_signatures = oracle_sigs
+            .iter()
+            .map(|s| s.iter().map(|s| s.serialize().to_vec()).collect::<Vec<_>>())
+            .collect::<Vec<_>>();
+
+        // Test our new function
+        let result = extract_ecdsa_signature_from_oracle_signatures(
+            oracle_signatures[0].clone(),
+            cet_sigs[0].signature.clone(),
+        );
+
+        assert!(result.is_ok(), "Function should succeed");
+
+        let ecdsa_sig_bytes = result.unwrap();
+        assert!(
+            !ecdsa_sig_bytes.is_empty(),
+            "Should return non-empty signature"
+        );
+
+        // Verify the signature is valid DER format
+        let ecdsa_sig = EcdsaSignature::from_der(&ecdsa_sig_bytes);
+        assert!(ecdsa_sig.is_ok(), "Should be valid DER signature");
+    }
+
+    #[test]
+    fn test_get_cet_sighash() {
+        // Setup: Create DLC transactions to get a valid CET
+        let (offer_party_params, _offer_fund_sk) =
+            get_party_params(1_000_000_000, 100_000_000, None);
+        let (accept_party_params, _accept_fund_sk) =
+            get_party_params(1_000_000_000, 100_000_000, Some(2));
+
+        let dlc_txs = create_dlc_transactions(
+            payouts_test(),
+            offer_party_params.clone(),
+            accept_party_params.clone(),
+            100,
+            4,
+            10,
+            10,
+            0,
+        )
+        .unwrap();
+
+        let cet = dlc_txs.cets[0].clone();
+        let funding_script_pubkey = ddk_dlc::make_funding_redeemscript(
+            &PublicKey::from_slice(&offer_party_params.fund_pubkey).unwrap(),
+            &PublicKey::from_slice(&accept_party_params.fund_pubkey).unwrap(),
+        );
+        let fund_output_value = dlc_txs.fund.outputs[0].value;
+
+        // Act: Get the sighash
+        let result = get_cet_sighash(
+            cet.clone(),
+            funding_script_pubkey.clone().into_bytes(),
+            fund_output_value,
+        );
+
+        // Assert
+        assert!(result.is_ok(), "get_cet_sighash should succeed");
+        let sighash = result.unwrap();
+        assert_eq!(sighash.len(), 32, "Sighash should be 32 bytes");
+
+        // Verify against direct ddk-dlc call
+        let btc_tx = transaction_to_btc_tx(&cet).unwrap();
+        let direct_sighash = ddk_dlc::util::get_sig_hash_msg(
+            &btc_tx,
+            0,
+            Script::from_bytes(&funding_script_pubkey.clone().into_bytes()),
+            Amount::from_sat(fund_output_value),
+        )
+        .unwrap();
+
+        assert_eq!(
+            sighash,
+            direct_sighash.as_ref().to_vec(),
+            "Sighash should match direct ddk-dlc calculation"
+        );
+    }
+
+    #[test]
+    fn test_get_cet_adaptor_signature_inputs() {
+        // Setup: Create DLC transactions and oracle info
+        let secp = Secp256k1::new();
+        let mut rng = secp256k1_zkp::rand::thread_rng();
+        let (offer_party_params, _offer_fund_sk) =
+            get_party_params(1_000_000_000, 100_000_000, None);
+        let (accept_party_params, _accept_fund_sk) =
+            get_party_params(1_000_000_000, 100_000_000, Some(2));
+
+        let dlc_txs = create_dlc_transactions(
+            payouts_test(),
+            offer_party_params.clone(),
+            accept_party_params.clone(),
+            100,
+            4,
+            10,
+            10,
+            0,
+        )
+        .unwrap();
+
+        let cet = dlc_txs.cets[0].clone();
+        let funding_script_pubkey = ddk_dlc::make_funding_redeemscript(
+            &PublicKey::from_slice(&offer_party_params.fund_pubkey).unwrap(),
+            &PublicKey::from_slice(&accept_party_params.fund_pubkey).unwrap(),
+        );
+        let fund_output_value = dlc_txs.fund.outputs[0].value;
+
+        // Create oracle info (single oracle, single nonce for enumeration)
+        let oracle_kp = Keypair::new(&secp, &mut rng);
+        let oracle_pubkey = oracle_kp.x_only_public_key().0;
+        let mut sk_nonce = [0u8; 32];
+        rng.fill_bytes(&mut sk_nonce);
+        let oracle_r_kp = Keypair::from_seckey_slice(&secp, &sk_nonce).unwrap();
+        let nonce = XOnlyPublicKey::from_keypair(&oracle_r_kp).0;
+
+        let oracle_info = vec![OracleInfo {
+            public_key: oracle_pubkey.serialize().to_vec(),
+            nonces: vec![nonce.serialize().to_vec()],
+        }];
+
+        // Create message (first outcome)
+        let message = &[0u8];
+        let hash = sha256::Hash::hash(message).to_byte_array();
+        let msgs = vec![vec![hash.to_vec()]]; // Single oracle, single message
+
+        // Act: Get debug info
+        let result = get_cet_adaptor_signature_inputs(
+            cet.clone(),
+            oracle_info.clone(),
+            funding_script_pubkey.clone().into_bytes(),
+            fund_output_value,
+            msgs.clone(),
+        );
+
+        // Assert
+        assert!(
+            result.is_ok(),
+            "get_cet_adaptor_signature_inputs should succeed"
+        );
+        let debug_info = result.unwrap();
+
+        // Verify sighash
+        assert_eq!(debug_info.sighash.len(), 32, "Sighash should be 32 bytes");
+        let expected_sighash = get_cet_sighash(
+            cet.clone(),
+            funding_script_pubkey.clone().into_bytes(),
+            fund_output_value,
+        )
+        .unwrap();
+        assert_eq!(
+            debug_info.sighash, expected_sighash,
+            "Sighash should match get_cet_sighash result"
+        );
+
+        // Verify adaptor point
+        assert_eq!(
+            debug_info.adaptor_point.len(),
+            33,
+            "Adaptor point should be 33 bytes (compressed pubkey)"
+        );
+
+        // Verify input index is always 0 for CETs
+        assert_eq!(
+            debug_info.input_index, 0,
+            "Input index should always be 0 for CETs"
+        );
+
+        // Verify script_pubkey matches what we passed in
+        assert_eq!(
+            debug_info.script_pubkey,
+            funding_script_pubkey.clone().into_bytes(),
+            "Script pubkey should match input"
+        );
+
+        // Verify value matches
+        assert_eq!(
+            debug_info.value, fund_output_value,
+            "Value should match input"
+        );
+
+        // Verify cet_txid is valid
+        let btc_tx = transaction_to_btc_tx(&cet).unwrap();
+        assert_eq!(
+            debug_info.cet_txid,
+            btc_tx.compute_txid().to_string(),
+            "CET txid should match"
+        );
+
+        // Verify cet_raw matches input
+        assert_eq!(
+            debug_info.cet_raw, cet.raw_bytes,
+            "CET raw bytes should match input"
+        );
+    }
+
+    #[test]
+    fn test_get_cet_sighash_invalid_transaction() {
+        // Create an invalid transaction (empty raw_bytes)
+        let invalid_tx = Transaction {
+            version: 2,
+            lock_time: 0,
+            inputs: vec![],
+            outputs: vec![],
+            raw_bytes: vec![0x00], // Invalid serialization
+        };
+
+        let result = get_cet_sighash(invalid_tx, vec![0x00, 0x14], 100_000);
+
+        assert!(
+            result.is_err(),
+            "Should fail with invalid transaction bytes"
+        );
+    }
+
+    #[test]
+    fn test_get_cet_adaptor_signature_inputs_invalid_oracle_pubkey() {
+        // Setup valid CET
+        let (offer_party_params, _) = get_party_params(1_000_000_000, 100_000_000, None);
+        let (accept_party_params, _) = get_party_params(1_000_000_000, 100_000_000, Some(2));
+
+        let dlc_txs = create_dlc_transactions(
+            payouts_test(),
+            offer_party_params.clone(),
+            accept_party_params.clone(),
+            100,
+            4,
+            10,
+            10,
+            0,
+        )
+        .unwrap();
+
+        let cet = dlc_txs.cets[0].clone();
+        let funding_script_pubkey = ddk_dlc::make_funding_redeemscript(
+            &PublicKey::from_slice(&offer_party_params.fund_pubkey).unwrap(),
+            &PublicKey::from_slice(&accept_party_params.fund_pubkey).unwrap(),
+        );
+
+        // Invalid oracle info (wrong pubkey length)
+        let invalid_oracle_info = vec![OracleInfo {
+            public_key: vec![0x00; 20], // Invalid: should be 32 bytes for x-only
+            nonces: vec![vec![0x00; 32]],
+        }];
+
+        let msgs = vec![vec![vec![0u8; 32]]];
+
+        let result = get_cet_adaptor_signature_inputs(
+            cet,
+            invalid_oracle_info,
+            funding_script_pubkey.into_bytes(),
+            100_000,
+            msgs,
+        );
+
+        assert!(
+            result.is_err(),
+            "Should fail with invalid oracle public key"
+        );
+    }
 }

package/lib/commonjs/ddk_ffi-ffi.js.map

@@ -1 +1 @@
-{"version":3,"names":["getter","globalThis","NativeDdkFfi","_default","exports","default","isRustFutureContinuationCallbackTypeCompatible","isUniffiForeignFutureTypeCompatible"],"sourceRoot":"../../src","sources":["ddk_ffi-ffi.ts"],"mappings":";;;;;;AAAA;AACA;;AA4PA;AACA;AACA;AACA;AACA;AACA,MAAMA,MAAmC,GAAGA,CAAA,KACzCC,UAAU,CAASC,YAAY;AAAC,IAAAC,QAAA,GAAAC,OAAA,CAAAC,OAAA,GACpBL,MAAM,EAErB;AAmHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMM,8CAGL,GAAG,IAAI;AACR,MAAMC,mCAGL,GAAG,IAAI","ignoreList":[]}
+{"version":3,"names":["getter","globalThis","NativeDdkFfi","_default","exports","default","isRustFutureContinuationCallbackTypeCompatible","isUniffiForeignFutureTypeCompatible"],"sourceRoot":"../../src","sources":["ddk_ffi-ffi.ts"],"mappings":";;;;;;AAAA;AACA;;AAkRA;AACA;AACA;AACA;AACA;AACA,MAAMA,MAAmC,GAAGA,CAAA,KACzCC,UAAU,CAASC,YAAY;AAAC,IAAAC,QAAA,GAAAC,OAAA,CAAAC,OAAA,GACpBL,MAAM,EAErB;AAmHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMM,8CAGL,GAAG,IAAI;AACR,MAAMC,mCAGL,GAAG,IAAI","ignoreList":[]}