Taproot Data Availability

pub struct TaprootDA {
    rpc_client: Arc<v28::Client>,  // Bitcoin Core RPC (corepc)
    bdk_bitcoind_client: Option<Arc<bdk_bitcoind_rpc::bitcoincore_rpc::Client>>,
}

OP_FALSE OP_IF
  <data_chunk_1>
  <data_chunk_2>
  ...
  <data_chunk_n>
OP_ENDIF OP_TRUE

fn create_taproot_envelope_script(&self, data: &[u8]) -> Result<ScriptBuf> {
    let mut script = Builder::new();
    script = script.push_opcode(OP_FALSE).push_opcode(OP_IF);
    
    // Add data in chunks of 520 bytes (Bitcoin script push limit)
    for chunk in data.chunks(520) {
        if let Ok(push_bytes) = <&bitcoin::blockdata::script::PushBytes>::try_from(chunk) {
            script = script.push_slice(push_bytes);
        }
    }
    
    script = script.push_opcode(OP_ENDIF).push_opcode(OP_TRUE);
    Ok(script.into_script())
}

fn create_taproot_address_with_info(
    &self,
    data: &[u8],
    network: bitcoin::Network,
) -> Result<(BitcoinAddress, String, Vec<u8>)> {
    let secp = Secp256k1::new();
    
    // Generate random internal key
    let keypair = Keypair::new(&secp, &mut OsRng);
    let (xonly, _parity) = bitcoin::secp256k1::XOnlyPublicKey::from_keypair(&keypair);
    
    // Create envelope script for the data
    let envelope_script = self.create_taproot_envelope_script(data)?;
    
    // Build Taproot tree with envelope as leaf
    let spend_info = TaprootBuilder::new()
        .add_leaf(0, envelope_script.clone())?  // Depth 0 (only leaf)
        .finalize(&secp, xonly)?;
    
    let output_key = spend_info.output_key();
    let address = BitcoinAddress::p2tr_tweaked(output_key, network);
    
    // Get control block for spending
    let control_block = spend_info
        .control_block(&(envelope_script.clone(), LeafVersion::TapScript))
        .ok_or(anyhow!("Failed to get control block"))?;
    
    Ok((address, internal_key_hex, control_block_bytes))
}

fn calculate_exact_reveal_fee(
    &self,
    envelope_script: &ScriptBuf,
    control_block: &[u8],
    sat_per_vb: u64,
    available_amount: u64,
) -> Result<u64> {
    // Create temporary reveal transaction
    let temp_reveal_tx = self.create_temp_reveal_transaction(
        envelope_script, 
        control_block
    )?;
    
    // Calculate exact vBytes using Bitcoin Core's weight calculation
    let exact_tx_size_vb = self.calculate_actual_tx_size_vb(&temp_reveal_hex)?;
    
    let mut reveal_fee = sat_per_vb * exact_tx_size_vb;
    
    // Enforce minimum relay fee (16 sats for Bitcoin Core 30.0)
    const MIN_RELAY_FEE_SATS: u64 = 16;
    if reveal_fee < MIN_RELAY_FEE_SATS {
        let adjusted_sat_per_vb = MIN_RELAY_FEE_SATS.div_ceil(exact_tx_size_vb);
        reveal_fee = adjusted_sat_per_vb * exact_tx_size_vb;
    }
    
    // Cap to available amount
    if reveal_fee > available_amount {
        reveal_fee = available_amount;
    }
    
    Ok(reveal_fee)
}

fn calculate_actual_tx_size_vb(&self, raw_tx_hex: &str) -> Result<u64> {
    let tx_bytes = hex::decode(raw_tx_hex)?;
    let tx: bitcoin::Transaction = bitcoin::consensus::deserialize(&tx_bytes)?;
    
    // Use rust-bitcoin's battle-tested weight calculation
    let weight = tx.weight();
    let vsize = weight.to_wu().div_ceil(4);  // vBytes = weight / 4 (rounded up)
    
    Ok(vsize)
}

weight = (base_size * 3) + total_size
vBytes = weight / 4

let xkey: ExtendedKey = mnemonic.into_extended_key()?;
let xprv = xkey.into_xprv(network)?;

let external_descriptor = format!("wpkh({}/0/*)", xprv);
let internal_descriptor = format!("wpkh({}/1/*)", xprv);

let wallet_path = Path::new(data_dir)
    .join(format!("wallet_{}.sqlite3", network_str));
let mut conn = Connection::open(&wallet_path)?;

let wallet_opt = Wallet::load()
    .descriptor(KeychainKind::External, Some(external_descriptor.clone()))
    .descriptor(KeychainKind::Internal, Some(internal_descriptor.clone()))
    .extract_keys()  // Extract private keys for signing
    .check_network(network)
    .load_wallet(&mut conn)?;

use bdk_bitcoind_rpc::Emitter;
let mut emitter = Emitter::new(
    bdk_client.as_ref(),
    wallet.latest_checkpoint().clone(),
    0,
    std::iter::empty::<Arc<Transaction>>(),
);

while let Some(block_emission) = emitter.next_block()? {
    wallet.apply_block(&block_emission.block, block_emission.block_height())?;
}
wallet.persist(&mut conn)?;

use bdk_electrum::{electrum_client, BdkElectrumClient};

let electrum_client = electrum_client::Client::new(electrum_url)?;
let electrum = BdkElectrumClient::new(electrum_client);

// Soft sync: only syncs revealed addresses (not full chain scan)
let request = wallet.start_sync_with_revealed_spks().build();
let response = electrum.sync(request, 5, false)?;

wallet.apply_update(response)?;
wallet.persist(&mut conn)?;

let mut tx_builder = wallet.build_tx();

// Set fee rate
let fee_rate = FeeRate::from_sat_per_vb(sat_per_vb).expect("valid fee rate");
tx_builder.fee_rate(fee_rate);

// Add Taproot output with calculated amount
tx_builder.add_recipient(
    taproot_address.script_pubkey(),
    Amount::from_sat(min_taproot_output),
);

// Build PSBT
let mut psbt = tx_builder.finish()?;

// Sign with wallet keys
#[allow(deprecated)]
let finalized = wallet.sign(&mut psbt, SignOptions::default())?;

// Finalize if needed
if !finalized {
    use bdk_wallet::miniscript::psbt::PsbtExt;
    psbt.finalize_mut(&Secp256k1::new())?;
}

// Extract final transaction
let commit_tx = psbt.extract_tx()?;
let commit_tx_hex = hex::encode(bitcoin::consensus::serialize(&commit_tx));

const DUST_THRESHOLD: u64 = 330;  // Bitcoin dust limit for Taproot

let exact_reveal_fee = self.calculate_exact_reveal_fee(
    &envelope_script,
    &control_block,
    sat_per_vb,
    u64::MAX,
)?;

// Ensure output meets both reveal fee and dust threshold
let min_taproot_output = exact_reveal_fee.max(DUST_THRESHOLD);

// OP_RETURN output with marker
let op_return_data = b"CORELANE";
let op_return_script = Builder::new()
    .push_opcode(bitcoin::blockdata::opcodes::all::OP_RETURN)
    .push_slice(op_return_data)
    .into_script();

let mut reveal_tx = Transaction {
    version: bitcoin::transaction::Version::TWO,
    lock_time: bitcoin::absolute::LockTime::ZERO,
    input: vec![bitcoin::TxIn {
        previous_output: bitcoin::OutPoint {
            txid: commit_txid,
            vout: taproot_vout_index as u32,
        },
        script_sig: ScriptBuf::new(),  // Empty for Taproot
        sequence: bitcoin::Sequence::MAX,
        witness: Witness::new(),
    }],
    output: vec![bitcoin::TxOut {
        value: bitcoin::Amount::from_sat(0),  // Zero-value OP_RETURN
        script_pubkey: op_return_script,
    }],
};

// Add witness to reveal the envelope
let mut witness = Witness::new();
witness.push(envelope_script.as_bytes());  // The data envelope script
witness.push(&control_block);              // Control block proves script path
reveal_tx.input[0].witness = witness;

[script] [control_block]

let package_txs = vec![
    serde_json::json!(commit_tx_hex),
    serde_json::json!(reveal_final_hex),
];

let package_result: Result<serde_json::Value, _> = self.rpc_client
    .call("submitpackage", &[serde_json::json!(package_txs)])
    .map_err(|e| anyhow!(e).context("submitpackage RPC call failed"));

match package_result {
    Ok(result) => {
        let commit_txid = commit_tx.compute_txid();
        let reveal_txid = reveal_tx.compute_txid();
        
        info!("Commit transaction ID (txid): {}", commit_txid);
        info!("Reveal transaction ID (txid): {}", reveal_txid);
        info!("Data embedded AND revealed atomically in the same block");
        
        Ok(commit_txid.to_string())
    }
    Err(e) => Err(anyhow!("Failed to submit transaction package: {}", e))
}

let transactions: Vec<Vec<u8>> = raw_tx_hex_vec
    .iter()
    .map(|tx_hex| hex::decode(tx_hex.trim_start_matches("0x")))
    .collect::<Result<Vec<_>>>()?;

let mut bundle = CoreLaneBundleCbor::new_with_sequencer(
    transactions, 
    sequencer_payment_recipient
);
bundle.marker = marker;  // Head or Standard

let bundle_cbor = bundle.to_cbor()?;  // Brotli compressed

let mut payload = Vec::new();
payload.extend_from_slice(b"CORE_BNDL");
payload.extend_from_slice(&bundle_cbor);

const MAX_DECOMPRESSED_SIZE: u32 = 128 * 1024 * 1024;

if decompressed_length > MAX_DECOMPRESSED_SIZE {
    return Err(anyhow!(
        "Decompressed length {} exceeds maximum of {} bytes (128MB)",
        decompressed_length, MAX_DECOMPRESSED_SIZE
    ));
}

let capped_sat_per_vb = sat_per_vb
    .max(min_relay_fee_sat_vb)
    .min(50);  // Cap at 50 sat/vB max

let final_sat_per_vb = capped_sat_per_vb.clamp(1, 10);  // Force 1-10 for testing

let params = brotli::enc::BrotliEncoderParams {
    quality: 6,
    lgwin: 22,
    ..Default::default()
};

if let Some(leaf_script) = input.witness.taproot_leaf_script() {
    // leaf_script.script is a reference to witness data (zero-copy)
    if let Some(data) = extract_envelope_data_with_prefix(leaf_script.script, prefix) {
        return Some(data);
    }
}