channels_sv2 8.0.0

//! Abstraction of a factory for creating Sv2 Extended or Standard Jobs.
//!
//! This module provides the [`JobFactory`] struct, which enables the creation
//! of uniquely identified Extended and Standard mining jobs as required by
//! Stratum V2 (SV2) mining servers. It manages job ID assignment, construction
//! of coinbase transactions, and correct association of template and custom job
//! parameters.
//!
//! ## Responsibilities
//!
//! - **Job ID Generation**: Ensures all jobs have unique IDs per factory instance.
//! - **Job Construction**: Builds Extended and Standard jobs from SV2 templates and custom job
//!   messages, assembling all required coinbase transaction data and metadata.
//! - **Coinbase Output Validation**: Verifies that coinbase outputs match SV2 template constraints
//!   and protocol rules.
//! - **`scriptSig` Budget Enforcement**: Verifies that the assembled coinbase `scriptSig` fits
//!   within [`MAX_SCRIPT_SIG_SIZE`]. This is the authoritative check, since the template's
//!   `coinbase_prefix` is only known at job creation time.
//! - **Version Rolling**: Tracks version rolling allowance for created jobs.
//!
//! ## Usage
//!
//! Designed for mining server implementations. Use `JobFactory` to generate jobs in response to
//! incoming SV2 messages (`NewTemplate`, `SetCustomMiningJob`), ensuring protocol correctness and
//! uniqueness of job IDs.
use crate::{
    bip141::try_strip_bip141,
    chain_tip::ChainTip,
    merkle_root::merkle_root_from_path,
    outputs::deserialize_template_outputs,
    server::jobs::{error::*, extended::ExtendedJob, standard::StandardJob},
};
use binary_sv2::{B0255Owned, Sv2OptionOwned};
use bitcoin::{
    absolute::LockTime,
    blockdata::witness::Witness,
    consensus::{serialize, Decodable},
    transaction::{OutPoint, Transaction, TxIn, TxOut, Version},
    Amount, Sequence,
};
use mining_sv2::{NewExtendedMiningJobOwned, NewMiningJobOwned, SetCustomMiningJobOwned};
use std::convert::TryInto;
use template_distribution_sv2::NewTemplateOwned;

/// Maximum size, in bytes, of a coinbase transaction `scriptSig`, as mandated by Bitcoin
/// consensus rules.
pub const MAX_SCRIPT_SIG_SIZE: usize = 100;

/// Maximum number of bytes that [`NewTemplateOwned::coinbase_prefix`] is allowed to contribute to
/// the coinbase `scriptSig`, as mandated by the Sv2 Template Distribution Protocol spec.
///
/// The spec phrase "up to 8 bytes (not including the length byte)" refers to the `B0255` wire
/// length prefix. The BIP34 script push opcode is already part of these 8 bytes.
pub const MAX_COINBASE_PREFIX_SIZE: usize = 8;

#[derive(Debug, PartialEq, Eq, Clone)]
struct JobIdFactory {
    state: u32,
}

impl JobIdFactory {
    /// Creates a new [`Id`] instance initialized to `0`.
    fn new() -> Self {
        Self { state: 0 }
    }

    /// Increments then returns the internal state on a new ID.
    ///
    /// Explicitly wraps to `0` after `u32::MAX`, restarting the sequence. This makes the
    /// overflow behavior identical across build profiles (unchecked `+= 1` would panic with
    /// overflow checks enabled and wrap silently without them). Reuse of an ID is safe in
    /// practice: future jobs are consumed on activation and past/stale jobs are flushed on
    /// every chain-tip transition, so a wrapped ID can only land on a still-tracked job (the
    /// stale set retained from the previous tip) if all 2³² allocations happen within a single
    /// tip epoch — orders of magnitude beyond any realistic job rate. Even then, the job store
    /// drops the stale namesake in favor of the new job (see `JobStore`), so the collision only
    /// changes the error code the stale job's late shares are rejected with.
    fn next(&mut self) -> u32 {
        self.state = self.state.wrapping_add(1);
        self.state
    }
}

/// A Factory for creating Extended or Standard Jobs.
///
/// Ensures unique job ids within any window of 2³² allocations: IDs are sequential and
/// explicitly wrap to `0` after `u32::MAX` (see `JobIdFactory::next` for why reuse is safe).
///
/// Enables creation of new Extended Jobs from NewTemplate and SetCustomMiningJob messages.
///
/// Enables creation of new Standard Jobs from NewTemplate messages.
#[derive(Debug, Clone)]
pub struct JobFactory {
    job_id_factory: JobIdFactory,
    version_rolling_allowed: bool,
    pool_tag_string: Option<String>,
    miner_tag_string: Option<String>,
}

impl JobFactory {
    /// Creates a new [`JobFactory`] instance.
    ///
    /// The `pool_tag_string` and `miner_tag_string` are optional and will be added to the coinbase
    /// scriptSig.
    ///
    /// Version rolling is always allowed for standard jobs, so the `version_rolling_allowed`
    /// parameter is only relevant for creating extended jobs.
    pub fn new(
        version_rolling_allowed: bool,
        pool_tag_string: Option<String>,
        miner_tag_string: Option<String>,
    ) -> Self {
        Self {
            job_id_factory: JobIdFactory::new(),
            version_rolling_allowed,
            pool_tag_string,
            miner_tag_string,
        }
    }

    /// Returns a byte vector with the OP_PUSHBYTES opcode and `Sv2/<pool>/<miner>/` tag.
    ///
    /// The character `/` is used as a delimiter.
    ///
    /// If pool and/or miner tags are not provided, delimiters are still kept
    /// (e.g. `Sv2///` when both are missing).
    pub fn op_pushbytes_pool_miner_tag(&self) -> Result<Vec<u8>, JobFactoryError> {
        let mut pool_miner_tag = vec![];
        pool_miner_tag.extend_from_slice(b"Sv2/");
        if let Some(pool_tag_string) = &self.pool_tag_string {
            pool_miner_tag.extend_from_slice(pool_tag_string.as_bytes());
        }
        pool_miner_tag.extend_from_slice(b"/");
        if let Some(miner_tag_string) = &self.miner_tag_string {
            pool_miner_tag.extend_from_slice(miner_tag_string.as_bytes());
        }
        pool_miner_tag.extend_from_slice(b"/");

        // Create the proper OP_PUSHBYTES opcode based on data length
        let op_pushbytes = match pool_miner_tag.len() {
            // OP_PUSHBYTES_N is a valid single-byte push opcode only for N in 1..=75.
            // The scriptSig budget is enforced separately, see `MAX_SCRIPT_SIG_SIZE`.
            len @ 1..=75 => len as u8,
            _ => return Err(JobFactoryError::CoinbaseTxPrefixError),
        };

        let mut op_pushbytes_pool_miner_tag = vec![];
        op_pushbytes_pool_miner_tag.push(op_pushbytes);
        op_pushbytes_pool_miner_tag.extend_from_slice(&pool_miner_tag);

        Ok(op_pushbytes_pool_miner_tag)
    }

    /// Returns the number of bytes that the `Sv2/<pool>/<miner>/` tag assembled by
    /// [`JobFactory::op_pushbytes_pool_miner_tag`] contributes to the coinbase `scriptSig`,
    /// including the `OP_PUSHBYTES` opcode.
    pub fn pool_miner_tag_size(&self) -> usize {
        1 // OP_PUSHBYTES opcode
            + 3 // "Sv2"
            + 3 // three `/` delimiters
            + self.pool_tag_string.as_ref().map_or(0, |s| s.len())
            + self.miner_tag_string.as_ref().map_or(0, |s| s.len())
    }

    /// Returns the number of bytes of the coinbase `scriptSig` assembled by this factory, for a
    /// [`NewTemplateOwned::coinbase_prefix`] of `coinbase_prefix_size` bytes and a full extranonce
    /// of `full_extranonce_size` bytes.
    ///
    /// The assembled layout is:
    /// `coinbase_prefix || OP_PUSHBYTES_N || Sv2/pool_tag/miner_tag/ || OP_PUSHBYTES_M ||
    /// extranonce`
    ///
    /// Callers that do not have a template at hand (such as channel constructors) should pass
    /// [`MAX_COINBASE_PREFIX_SIZE`] to get the worst-case size allowed by the spec.
    pub fn script_sig_size(
        &self,
        coinbase_prefix_size: usize,
        full_extranonce_size: usize,
    ) -> usize {
        coinbase_prefix_size
            + self.pool_miner_tag_size()
            + 1 // OP_PUSHBYTES opcode for the extranonce
            + full_extranonce_size
    }

    /// Returns whether the coinbase `scriptSig` assembled by this factory fits within
    /// [`MAX_SCRIPT_SIG_SIZE`], for a full extranonce of `full_extranonce_size` bytes and the
    /// worst-case [`NewTemplateOwned::coinbase_prefix`] allowed by the spec
    /// ([`MAX_COINBASE_PREFIX_SIZE`]).
    ///
    /// Meant for callers that do not have a template at hand, such as channel constructors and
    /// extranonce setters. Since it assumes the largest in-spec prefix, a `true` here guarantees
    /// that no in-spec template can overflow the budget; the exact size is still re-checked
    /// against each actual template in `JobFactory::coinbase`.
    pub fn fits_script_sig_budget(&self, full_extranonce_size: usize) -> bool {
        self.script_sig_size(MAX_COINBASE_PREFIX_SIZE, full_extranonce_size) <= MAX_SCRIPT_SIG_SIZE
    }

    /// Creates a new job from a template.
    ///
    /// This job (and related shares) is fully committed to:
    /// - The template
    /// - The additional coinbase outputs (added to the outputs coming from the template)
    /// - The extranonce prefix of the channel at the time of job creation
    ///
    /// The optional `ChainTip` defines whether the job will be future or not.
    ///
    /// Version rolling is always allowed for standard jobs, so the `version_rolling_allowed`
    /// parameter is ignored.
    ///
    /// It's up to the caller to ensure that the sum of `additional_coinbase_outputs` is equal to
    /// available template revenue. Returns an error otherwise.
    pub fn new_standard_job(
        &mut self,
        channel_id: u32,
        chain_tip: Option<ChainTip>,
        extranonce_prefix: Vec<u8>,
        template: NewTemplateOwned,
        additional_coinbase_outputs: Vec<TxOut>,
    ) -> Result<StandardJob, JobFactoryError> {
        let coinbase_outputs_sum = additional_coinbase_outputs
            .iter()
            .map(|o| o.value.to_sat())
            .sum::<u64>();
        if coinbase_outputs_sum != template.coinbase_tx_value_remaining {
            return Err(JobFactoryError::InvalidCoinbaseOutputsSum);
        }

        let job_id = self.job_id_factory.next();

        let version = template.version;

        let coinbase_tx_prefix = self.coinbase_tx_prefix(
            template.clone(),
            additional_coinbase_outputs.clone(),
            extranonce_prefix.len(),
        )?;
        let coinbase_tx_suffix = self.coinbase_tx_suffix(
            template.clone(),
            additional_coinbase_outputs.clone(),
            extranonce_prefix.len(),
        )?;
        let merkle_path = template.merkle_path.clone();
        let merkle_root = merkle_root_from_path(
            &coinbase_tx_prefix,
            &coinbase_tx_suffix,
            &extranonce_prefix,
            merkle_path.as_slice(),
        )
        .expect("merkle root must be valid")
        .into();

        let job_message = match template.future_template {
            true => NewMiningJobOwned {
                channel_id,
                job_id,
                min_ntime: Sv2OptionOwned::new(None),
                version,
                merkle_root,
            },
            false => {
                let min_ntime = match chain_tip {
                    Some(chain_tip) => Some(chain_tip.min_ntime()),
                    None => return Err(JobFactoryError::ChainTipRequired),
                };

                NewMiningJobOwned {
                    channel_id,
                    job_id,
                    min_ntime: Sv2OptionOwned::new(min_ntime),
                    version,
                    merkle_root,
                }
            }
        };

        let job = StandardJob::from_template(
            template,
            extranonce_prefix,
            additional_coinbase_outputs,
            job_message,
        )
        .map_err(|_| JobFactoryError::DeserializeCoinbaseOutputsError)?;

        Ok(job)
    }

    /// Creates a new job from a template.
    ///
    /// This job (and related shares) is fully committed to:
    /// - The template
    /// - The additional coinbase outputs (added to the outputs coming from the template)
    /// - The extranonce prefix of the channel at the time of job creation
    ///
    /// The optional `ChainTip` defines whether the job will be future or not.
    ///
    /// It's up to the caller to ensure that the sum of `additional_coinbase_outputs` is equal to
    /// available template revenue. Returns an error otherwise.
    pub fn new_extended_job(
        &mut self,
        channel_id: u32,
        chain_tip: Option<ChainTip>,
        extranonce_prefix: Vec<u8>,
        template: NewTemplateOwned,
        additional_coinbase_outputs: Vec<TxOut>,
        full_extranonce_size: usize,
    ) -> Result<ExtendedJob, JobFactoryError> {
        let coinbase_outputs_sum = additional_coinbase_outputs
            .iter()
            .map(|o| o.value.to_sat())
            .sum::<u64>();
        if coinbase_outputs_sum != template.coinbase_tx_value_remaining {
            return Err(JobFactoryError::InvalidCoinbaseOutputsSum);
        }

        let job_id = self.job_id_factory.next();

        let version = template.version;

        let coinbase_tx_prefix = self.coinbase_tx_prefix(
            template.clone(),
            additional_coinbase_outputs.clone(),
            full_extranonce_size,
        )?;
        let coinbase_tx_suffix = self.coinbase_tx_suffix(
            template.clone(),
            additional_coinbase_outputs.clone(),
            full_extranonce_size,
        )?;

        // strip bip141 bytes from coinbase_tx_prefix and coinbase_tx_suffix
        let (coinbase_tx_prefix_stripped_bip141, coinbase_tx_suffix_stripped_bip141) =
            try_strip_bip141(&coinbase_tx_prefix, &coinbase_tx_suffix)
                .map_err(|_| JobFactoryError::FailedToStripBip141)?
                .ok_or(JobFactoryError::FailedToStripBip141)?;

        let merkle_path = template.merkle_path.clone();

        let job_message = match template.future_template {
            true => NewExtendedMiningJobOwned {
                channel_id,
                job_id,
                min_ntime: Sv2OptionOwned::new(None),
                version,
                version_rolling_allowed: self.version_rolling_allowed,
                merkle_path,
                coinbase_tx_prefix: coinbase_tx_prefix_stripped_bip141
                    .try_into()
                    .map_err(|_| JobFactoryError::CoinbaseTxPrefixError)?,
                coinbase_tx_suffix: coinbase_tx_suffix_stripped_bip141
                    .try_into()
                    .map_err(|_| JobFactoryError::CoinbaseTxSuffixError)?,
            },
            false => {
                let min_ntime = match chain_tip {
                    Some(chain_tip) => Some(chain_tip.min_ntime()),
                    None => return Err(JobFactoryError::ChainTipRequired),
                };
                NewExtendedMiningJobOwned {
                    channel_id,
                    job_id,
                    min_ntime: Sv2OptionOwned::new(min_ntime),
                    version,
                    version_rolling_allowed: self.version_rolling_allowed,
                    merkle_path,
                    coinbase_tx_prefix: coinbase_tx_prefix_stripped_bip141
                        .try_into()
                        .map_err(|_| JobFactoryError::CoinbaseTxPrefixError)?,
                    coinbase_tx_suffix: coinbase_tx_suffix_stripped_bip141
                        .try_into()
                        .map_err(|_| JobFactoryError::CoinbaseTxSuffixError)?,
                }
            }
        };

        let job = ExtendedJob::from_template(
            template,
            extranonce_prefix,
            additional_coinbase_outputs,
            coinbase_tx_prefix,
            coinbase_tx_suffix,
            job_message,
        )
        .map_err(|_| JobFactoryError::DeserializeCoinbaseOutputsError)?;

        Ok(job)
    }

    /// Creates a new coinbase_tx_prefix and coinbase_tx_suffix from a template.
    ///
    /// To be used by a Sv2 Job Declarator Client to create a `DeclareMiningJob` message.
    ///
    /// It's up to the caller to ensure that the sum of `additional_coinbase_outputs`
    /// is equal to available template revenue. Returns an error otherwise.
    pub fn new_coinbase_tx_prefix_and_suffix(
        &self,
        template: NewTemplateOwned,
        additional_coinbase_outputs: Vec<TxOut>,
        full_extranonce_size: usize,
    ) -> Result<(Vec<u8>, Vec<u8>), JobFactoryError> {
        let coinbase_outputs_sum = additional_coinbase_outputs
            .iter()
            .map(|o| o.value.to_sat())
            .sum::<u64>();
        if coinbase_outputs_sum != template.coinbase_tx_value_remaining {
            return Err(JobFactoryError::InvalidCoinbaseOutputsSum);
        }

        let coinbase_tx_prefix = self.coinbase_tx_prefix(
            template.clone(),
            additional_coinbase_outputs.clone(),
            full_extranonce_size,
        )?;
        let coinbase_tx_suffix =
            self.coinbase_tx_suffix(template, additional_coinbase_outputs, full_extranonce_size)?;
        Ok((coinbase_tx_prefix, coinbase_tx_suffix))
    }

    /// Creates a new `SetCustomMiningJob` message from a template.
    ///
    /// To be used by a Sv2 Job Declarator Client.
    ///
    /// It's up to the caller to ensure that the sum of the additional coinbase outputs is equal to
    /// available template revenue.
    ///
    /// Returns [`JobFactoryError::ScriptSigSizeTooLarge`] if the template's `coinbase_prefix`, the
    /// pool/miner tag and the full extranonce do not fit within [`MAX_SCRIPT_SIG_SIZE`].
    #[allow(clippy::too_many_arguments)]
    pub fn new_custom_job(
        &self,
        channel_id: u32,
        request_id: u32,
        token: B0255Owned,
        chain_tip: ChainTip,
        template: NewTemplateOwned,
        additional_coinbase_outputs: Vec<TxOut>,
        full_extranonce_size: usize,
    ) -> Result<SetCustomMiningJobOwned, JobFactoryError> {
        // the `coinbase_prefix` assembled below carries this factory's pool/miner tag, so the
        // regular scriptSig layout applies. catching it here means the Job Declarator Client fails
        // locally instead of having the pool reject the `SetCustomMiningJob` it just sent
        if self.script_sig_size(template.coinbase_prefix.len(), full_extranonce_size)
            > MAX_SCRIPT_SIG_SIZE
        {
            return Err(JobFactoryError::ScriptSigSizeTooLarge);
        }

        let coinbase_outputs_sum = additional_coinbase_outputs
            .iter()
            .map(|o| o.value.to_sat())
            .sum::<u64>();
        if coinbase_outputs_sum != template.coinbase_tx_value_remaining {
            return Err(JobFactoryError::InvalidCoinbaseOutputsSum);
        }

        let template_outputs = deserialize_template_outputs(
            template.coinbase_tx_outputs.to_owned_bytes(),
            template.coinbase_tx_outputs_count,
        )
        .map_err(|_| JobFactoryError::DeserializeCoinbaseOutputsError)?;

        let mut coinbase_tx_outputs = vec![];
        coinbase_tx_outputs.extend_from_slice(additional_coinbase_outputs.as_slice());
        coinbase_tx_outputs.extend_from_slice(template_outputs.as_slice());

        let serialized_outputs = serialize(&coinbase_tx_outputs);

        let mut coinbase_prefix = vec![];
        coinbase_prefix.extend_from_slice(template.coinbase_prefix.as_bytes());
        coinbase_prefix.extend_from_slice(&self.op_pushbytes_pool_miner_tag()?);
        coinbase_prefix.push(full_extranonce_size as u8); // OP_PUSHBYTES_X (for the full extranonce)

        let set_custom_mining_job = SetCustomMiningJobOwned {
            channel_id,
            request_id,
            token,
            version: template.version,
            prev_hash: chain_tip.prev_hash(),
            min_ntime: chain_tip.min_ntime(),
            nbits: chain_tip.nbits(),
            coinbase_tx_version: template.coinbase_tx_version,
            coinbase_prefix: coinbase_prefix
                .try_into()
                .map_err(|_| JobFactoryError::FailedToSerializeCoinbasePrefix)?,
            coinbase_tx_input_n_sequence: template.coinbase_tx_input_sequence,
            coinbase_tx_outputs: serialized_outputs
                .try_into()
                .map_err(|_| JobFactoryError::FailedToSerializeCoinbaseOutputs)?,
            coinbase_tx_locktime: template.coinbase_tx_locktime,
            merkle_path: template.merkle_path.clone(),
        };

        Ok(set_custom_mining_job)
    }

    /// Creates a new Extended Job from a SetCustomMiningJob message.
    ///
    /// Assumes that the SetCustomMiningJob message has already been validated, with the exception
    /// of its `coinbase_prefix` length: since that arrives from a downstream Job Declarator Client,
    /// it is bounded here rather than delegated to the caller.
    ///
    /// Returns [`JobFactoryError::ScriptSigSizeTooLarge`] if the message's `coinbase_prefix` and
    /// the full extranonce do not fit within [`MAX_SCRIPT_SIG_SIZE`]. Note that a custom job's
    /// `coinbase_prefix` already embeds the pool/miner tag, so no tag is added on top of it.
    ///
    /// To be used by Extended Channels on a Sv2 Pool Server.
    pub fn new_extended_job_from_custom_job(
        &mut self,
        set_custom_mining_job: SetCustomMiningJobOwned,
        extranonce_prefix: Vec<u8>,
        full_extranonce_size: usize,
    ) -> Result<ExtendedJob, JobFactoryError> {
        let serialized_outputs = set_custom_mining_job.coinbase_tx_outputs.to_owned_bytes();

        let coinbase_outputs = Vec::<TxOut>::consensus_decode(&mut serialized_outputs.as_slice())
            .map_err(|_| JobFactoryError::DeserializeCoinbaseOutputsError)?;

        let job_id = self.job_id_factory.next();

        let version = set_custom_mining_job.version;

        let coinbase_tx_prefix =
            self.custom_coinbase_tx_prefix(set_custom_mining_job.clone(), full_extranonce_size)?;
        let coinbase_tx_suffix =
            self.custom_coinbase_tx_suffix(set_custom_mining_job.clone(), full_extranonce_size)?;

        // strip bip141 bytes from coinbase_tx_prefix and coinbase_tx_suffix
        let (coinbase_tx_prefix_stripped_bip141, coinbase_tx_suffix_stripped_bip141) =
            try_strip_bip141(&coinbase_tx_prefix, &coinbase_tx_suffix)
                .map_err(|_| JobFactoryError::FailedToStripBip141)?
                .ok_or(JobFactoryError::FailedToStripBip141)?;

        let merkle_path = set_custom_mining_job.merkle_path.clone();

        let job_message = NewExtendedMiningJobOwned {
            channel_id: set_custom_mining_job.channel_id,
            job_id,
            min_ntime: Sv2OptionOwned::new(Some(set_custom_mining_job.min_ntime)),
            version,
            version_rolling_allowed: self.version_rolling_allowed,
            coinbase_tx_prefix: coinbase_tx_prefix_stripped_bip141
                .clone()
                .try_into()
                .map_err(|_| JobFactoryError::CoinbaseTxPrefixError)?,
            coinbase_tx_suffix: coinbase_tx_suffix_stripped_bip141
                .clone()
                .try_into()
                .map_err(|_| JobFactoryError::CoinbaseTxSuffixError)?,
            merkle_path,
        };

        let job = ExtendedJob::from_custom_job(
            set_custom_mining_job,
            extranonce_prefix,
            coinbase_outputs,
            coinbase_tx_prefix,
            coinbase_tx_suffix,
            job_message,
        );

        Ok(job)
    }
}

// impl block with private methods
impl JobFactory {
    // build a coinbase transaction from a SetCustomMiningJob
    // this is only used to extract coinbase_tx_prefix and coinbase_tx_suffix from the custom
    // coinbase
    fn custom_coinbase(
        &self,
        m: SetCustomMiningJobOwned,
        full_extranonce_size: usize,
    ) -> Result<Transaction, JobFactoryError> {
        // a custom job arrives from a downstream Job Declarator Client with the pool/miner tag
        // already embedded in `coinbase_prefix`, so the assembled scriptSig is just the prefix
        // followed by the extranonce, with no tag of ours to account for.
        //
        // this is untrusted input off the wire and nothing upstream of here bounds it, so the
        // check cannot be delegated to the caller the way it is for a locally built job. an
        // oversized prefix would otherwise yield a consensus-invalid coinbase, and past 252 bytes
        // it would also break the one-byte CompactSize assumption the prefix/suffix split indexes
        // rely on, silently mis-slicing the coinbase.
        if m.coinbase_prefix.len() + full_extranonce_size > MAX_SCRIPT_SIG_SIZE {
            return Err(JobFactoryError::ScriptSigSizeTooLarge);
        }

        let deserialized_outputs =
            Vec::<TxOut>::consensus_decode(&mut m.coinbase_tx_outputs.to_owned_bytes().as_slice())
                .map_err(|_| JobFactoryError::DeserializeCoinbaseOutputsError)?;

        let mut script_sig = vec![];
        script_sig.extend_from_slice(m.coinbase_prefix.as_bytes());
        script_sig.extend_from_slice(&vec![0; full_extranonce_size]);

        // Create transaction input
        let tx_in = TxIn {
            previous_output: OutPoint::null(),
            script_sig: script_sig.into(),
            sequence: Sequence(m.coinbase_tx_input_n_sequence),
            witness: Witness::from(vec![vec![0; 32]]), /* note: 32 bytes of zeros is only safe to
                                                        * assume now, this could change in future
                                                        * soft forks */
        };

        Ok(Transaction {
            version: Version::non_standard(m.coinbase_tx_version as i32),
            lock_time: LockTime::from_consensus(m.coinbase_tx_locktime),
            input: vec![tx_in],
            output: deserialized_outputs,
        })
    }

    fn custom_coinbase_tx_prefix(
        &self,
        m: SetCustomMiningJobOwned,
        full_extranonce_size: usize,
    ) -> Result<Vec<u8>, JobFactoryError> {
        let coinbase = self.custom_coinbase(m.clone(), full_extranonce_size)?;
        let serialized_coinbase = serialize(&coinbase);

        // the coinbase scriptSig is limited to 100 bytes by Bitcoin consensus rules, which is
        // always below the 253 byte threshold where CompactSize switches from a 1-byte to a
        // 3-byte encoding, so the script length prefix is unconditionally 1 byte
        let index = 4 // tx version
            + 2 // segwit
            + 1 // number of inputs
            + 32 // prev OutPoint
            + 4 // index
            + 1 // bytes in script
            + m.coinbase_prefix.len();

        let coinbase_tx_prefix = serialized_coinbase[0..index].to_vec();

        Ok(coinbase_tx_prefix)
    }

    fn custom_coinbase_tx_suffix(
        &self,
        m: SetCustomMiningJobOwned,
        full_extranonce_size: usize,
    ) -> Result<Vec<u8>, JobFactoryError> {
        let coinbase = self.custom_coinbase(m.clone(), full_extranonce_size)?;
        let serialized_coinbase = serialize(&coinbase);

        // the coinbase scriptSig is limited to 100 bytes by Bitcoin consensus rules, which is
        // always below the 253 byte threshold where CompactSize switches from a 1-byte to a
        // 3-byte encoding, so the script length prefix is unconditionally 1 byte
        let index = 4 // tx version
            + 2 // segwit
            + 1 // number of inputs
            + 32 // prev OutPoint
            + 4 // index
            + 1 // bytes in script
            + m.coinbase_prefix.len()
            + full_extranonce_size;

        let coinbase_tx_suffix = serialized_coinbase[index..].to_vec();

        Ok(coinbase_tx_suffix)
    }

    // build a coinbase transaction from some template in the JobFactory
    fn coinbase(
        &self,
        template: NewTemplateOwned,
        coinbase_reward_outputs: Vec<TxOut>,
        full_extranonce_size: usize,
    ) -> Result<Transaction, JobFactoryError> {
        // the template's coinbase_prefix is only known here, so this is the authoritative
        // scriptSig budget check; channel constructors can only check against the spec's
        // worst-case MAX_COINBASE_PREFIX_SIZE
        if self.script_sig_size(template.coinbase_prefix.len(), full_extranonce_size)
            > MAX_SCRIPT_SIG_SIZE
        {
            return Err(JobFactoryError::ScriptSigSizeTooLarge);
        }

        // check that the sum of the additional coinbase outputs is equal to the value remaining in
        // the active template
        let mut coinbase_reward_outputs_sum = Amount::from_sat(0);
        for output in coinbase_reward_outputs.iter() {
            coinbase_reward_outputs_sum = coinbase_reward_outputs_sum
                .checked_add(output.value)
                .ok_or(JobFactoryError::CoinbaseOutputsSumOverflow)?;
        }

        if template.coinbase_tx_value_remaining < coinbase_reward_outputs_sum.to_sat() {
            return Err(JobFactoryError::InvalidCoinbaseOutputsSum);
        }

        let mut outputs = vec![];

        for output in coinbase_reward_outputs.iter() {
            outputs.push(output.clone());
        }

        let mut template_outputs = deserialize_template_outputs(
            template.coinbase_tx_outputs.to_owned_bytes(),
            template.coinbase_tx_outputs_count,
        )
        .map_err(|_| JobFactoryError::DeserializeCoinbaseOutputsError)?;

        outputs.append(&mut template_outputs);

        let op_pushbytes_pool_miner_tag = self.op_pushbytes_pool_miner_tag()?;

        let mut script_sig = vec![];
        script_sig.extend_from_slice(template.coinbase_prefix.as_bytes());
        script_sig.extend_from_slice(&op_pushbytes_pool_miner_tag);
        script_sig.push(full_extranonce_size as u8); // OP_PUSHBYTES_X (for the full extranonce)
        script_sig.extend_from_slice(&vec![0; full_extranonce_size]);

        let tx_in = TxIn {
            previous_output: OutPoint::null(),
            script_sig: script_sig.into(),
            sequence: Sequence(template.coinbase_tx_input_sequence),
            witness: Witness::from(vec![vec![0; 32]]), /* note: 32 bytes of zeros is only safe to
                                                        * assume now, this could change in future
                                                        * soft forks */
        };

        Ok(Transaction {
            version: Version::non_standard(template.coinbase_tx_version as i32),
            lock_time: LockTime::from_consensus(template.coinbase_tx_locktime),
            input: vec![tx_in],
            output: outputs,
        })
    }

    fn coinbase_tx_prefix(
        &self,
        template: NewTemplateOwned,
        coinbase_reward_outputs: Vec<TxOut>,
        full_extranonce_size: usize,
    ) -> Result<Vec<u8>, JobFactoryError> {
        let coinbase = self.coinbase(
            template.clone(),
            coinbase_reward_outputs,
            full_extranonce_size,
        )?;
        let serialized_coinbase = serialize(&coinbase);

        // the full pool/miner tag length, including delimiters and OP_PUSHBYTES opcode
        let pool_miner_tag_len = self.pool_miner_tag_size();

        // the coinbase scriptSig is limited to 100 bytes by Bitcoin consensus rules, which is
        // always below the 253 byte threshold where CompactSize switches from a 1-byte to a
        // 3-byte encoding, so the script length prefix is unconditionally 1 byte
        let index = 4 // tx version
            + 2 // segwit bytes
            + 1 // number of inputs
            + 32 // prev OutPoint
            + 4 // index
            + 1 // bytes in script
            + template.coinbase_prefix.len()
            + pool_miner_tag_len
            + 1; // OP_PUSHBYTES_X (for the extranonce)

        let coinbase_tx_prefix = serialized_coinbase[0..index].to_vec();

        Ok(coinbase_tx_prefix)
    }

    fn coinbase_tx_suffix(
        &self,
        template: NewTemplateOwned,
        coinbase_reward_outputs: Vec<TxOut>,
        full_extranonce_size: usize,
    ) -> Result<Vec<u8>, JobFactoryError> {
        let coinbase = self.coinbase(
            template.clone(),
            coinbase_reward_outputs,
            full_extranonce_size,
        )?;
        let serialized_coinbase = serialize(&coinbase);

        // the full pool/miner tag length, including delimiters and OP_PUSHBYTES opcode
        let pool_miner_tag_len = self.pool_miner_tag_size();

        // the coinbase scriptSig is limited to 100 bytes by Bitcoin consensus rules, which is
        // always below the 253 byte threshold where CompactSize switches from a 1-byte to a
        // 3-byte encoding, so the script length prefix is unconditionally 1 byte
        let coinbase_tx_suffix = serialized_coinbase[4 // tx version
            + 2 // segwit bytes
            + 1 // number of inputs
            + 32 // prev OutPoint
            + 4 // index
            + 1 // bytes in script
            + template.coinbase_prefix.len()
            + pool_miner_tag_len
            + 1 // OP_PUSHBYTES_X (for the full extranonce)
            + full_extranonce_size..]
            .to_vec();

        Ok(coinbase_tx_suffix)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use bitcoin::ScriptBuf;
    use mining_sv2::NewExtendedMiningJobOwned as NewExtendedMiningJob;
    use template_distribution_sv2::NewTemplateOwned as NewTemplate;

    #[test]
    fn test_new_pool_job() {
        let mut job_factory = JobFactory::new(true, Some("Stratum V2 SRI Pool".to_string()), None);

        // note:
        // the messages on this test were collected from a sane message flow
        // we use them as test vectors to assert correct behavior of job creation

        let template = NewTemplate {
            template_id: 1,
            future_template: true,
            version: 536870912,
            coinbase_tx_version: 2,
            coinbase_prefix: vec![82, 0].try_into().unwrap(),
            coinbase_tx_input_sequence: 4294967295,
            coinbase_tx_value_remaining: 5000000000,
            coinbase_tx_outputs_count: 1,
            coinbase_tx_outputs: vec![
                0, 0, 0, 0, 0, 0, 0, 0, 38, 106, 36, 170, 33, 169, 237, 226, 246, 28, 63, 113, 209,
                222, 253, 63, 169, 153, 223, 163, 105, 83, 117, 92, 105, 6, 137, 121, 153, 98, 180,
                139, 235, 216, 54, 151, 78, 140, 249,
            ]
            .try_into()
            .unwrap(),
            coinbase_tx_locktime: 0,
            merkle_path: vec![].try_into().unwrap(),
        };

        // match the original script format used to generate the coinbase_reward_outputs for the
        // expected job
        let pubkey_hash = [
            235, 225, 183, 220, 194, 147, 204, 170, 14, 231, 67, 168, 111, 137, 223, 130, 88, 194,
            8, 252,
        ];
        let mut script_bytes = vec![0]; // SegWit version 0
        script_bytes.push(20); // Push 20 bytes (length of pubkey hash)
        script_bytes.extend_from_slice(&pubkey_hash);
        let script = ScriptBuf::from(script_bytes);
        let coinbase_reward_outputs = vec![TxOut {
            value: Amount::from_sat(5000000000),
            script_pubkey: script,
        }];

        // match the original extranonce_prefix used to generate the expected job
        let extranonce_prefix = [
            83, 116, 114, 97, 116, 117, 109, 32, 86, 50, 32, 83, 82, 73, 32, 80, 111, 111, 108, 0,
            0, 0, 0, 0, 0, 0, 1,
        ]
        .to_vec();

        let job = job_factory
            .new_extended_job(
                1,
                None,
                extranonce_prefix,
                template,
                coinbase_reward_outputs,
                32,
            )
            .unwrap();

        // we know that the provided template should generate this job
        let expected_job = NewExtendedMiningJob {
            channel_id: 1,
            job_id: 1,
            min_ntime: Sv2OptionOwned::new(None),
            version: 536870912,
            version_rolling_allowed: true,
            // contains scriptSig with Sv2/Stratum V2 SRI Pool//
            coinbase_tx_prefix: vec![
                2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 61, 82, 0, 25, 83, 118, 50, 47, 83,
                116, 114, 97, 116, 117, 109, 32, 86, 50, 32, 83, 82, 73, 32, 80, 111, 111, 108, 47,
                47, 32,
            ]
            .try_into()
            .unwrap(),
            coinbase_tx_suffix: vec![
                255, 255, 255, 255, 2, 0, 242, 5, 42, 1, 0, 0, 0, 22, 0, 20, 235, 225, 183, 220,
                194, 147, 204, 170, 14, 231, 67, 168, 111, 137, 223, 130, 88, 194, 8, 252, 0, 0, 0,
                0, 0, 0, 0, 0, 38, 106, 36, 170, 33, 169, 237, 226, 246, 28, 63, 113, 209, 222,
                253, 63, 169, 153, 223, 163, 105, 83, 117, 92, 105, 6, 137, 121, 153, 98, 180, 139,
                235, 216, 54, 151, 78, 140, 249, 0, 0, 0, 0,
            ]
            .try_into()
            .unwrap(),
            merkle_path: vec![].try_into().unwrap(),
        };

        assert_eq!(job.get_job_message(), &expected_job);
    }

    // builds a template with the provided `coinbase_prefix`, reusing the same vectors as
    // `test_new_pool_job` for everything else
    fn template_with_coinbase_prefix(coinbase_prefix: Vec<u8>) -> NewTemplate {
        NewTemplate {
            template_id: 1,
            future_template: true,
            version: 536870912,
            coinbase_tx_version: 2,
            coinbase_prefix: coinbase_prefix.try_into().unwrap(),
            coinbase_tx_input_sequence: 4294967295,
            coinbase_tx_value_remaining: 5000000000,
            coinbase_tx_outputs_count: 1,
            coinbase_tx_outputs: vec![
                0, 0, 0, 0, 0, 0, 0, 0, 38, 106, 36, 170, 33, 169, 237, 226, 246, 28, 63, 113, 209,
                222, 253, 63, 169, 153, 223, 163, 105, 83, 117, 92, 105, 6, 137, 121, 153, 98, 180,
                139, 235, 216, 54, 151, 78, 140, 249,
            ]
            .try_into()
            .unwrap(),
            coinbase_tx_locktime: 0,
            merkle_path: vec![].try_into().unwrap(),
        }
    }

    fn coinbase_reward_outputs() -> Vec<TxOut> {
        let pubkey_hash = [
            235, 225, 183, 220, 194, 147, 204, 170, 14, 231, 67, 168, 111, 137, 223, 130, 88, 194,
            8, 252,
        ];
        let mut script_bytes = vec![0]; // SegWit version 0
        script_bytes.push(20); // Push 20 bytes (length of pubkey hash)
        script_bytes.extend_from_slice(&pubkey_hash);
        vec![TxOut {
            value: Amount::from_sat(5000000000),
            script_pubkey: ScriptBuf::from(script_bytes),
        }]
    }

    #[test]
    fn test_coinbase_rejects_oversized_script_sig() {
        // a 52 char pool tag places the worst-case scriptSig exactly on the budget:
        // 8 (MAX_COINBASE_PREFIX_SIZE) + 1 + 3 ("Sv2") + 3 + 52 (tag) + 1 + 32 (extranonce) = 100
        let pool_tag_string = "x".repeat(52);
        let mut job_factory = JobFactory::new(true, Some(pool_tag_string), None);

        assert_eq!(
            job_factory.script_sig_size(MAX_COINBASE_PREFIX_SIZE, 32),
            MAX_SCRIPT_SIG_SIZE
        );

        // a spec-compliant 8 byte coinbase_prefix fits exactly
        let job = job_factory.new_extended_job(
            1,
            None,
            vec![0; 32],
            template_with_coinbase_prefix(vec![0xab; MAX_COINBASE_PREFIX_SIZE]),
            coinbase_reward_outputs(),
            32,
        );
        assert!(job.is_ok());

        // an out-of-spec Template Provider sending 9 bytes overflows the budget, and must be
        // rejected instead of yielding a consensus-invalid coinbase
        let job = job_factory.new_extended_job(
            1,
            None,
            vec![0; 32],
            template_with_coinbase_prefix(vec![0xab; MAX_COINBASE_PREFIX_SIZE + 1]),
            coinbase_reward_outputs(),
            32,
        );
        assert!(matches!(
            job.unwrap_err(),
            JobFactoryError::ScriptSigSizeTooLarge
        ));
    }

    #[test]
    fn test_new_extended_job_from_custom_job() {
        let jdc_job_factory = JobFactory::new(
            true,
            Some("Stratum V2 SRI Pool".to_string()),
            Some("Stratum V2 SRI Miner".to_string()),
        );

        let extranonce_prefix = [
            83, 116, 114, 97, 116, 117, 109, 32, 86, 50, 32, 83, 82, 73, 32, 80, 111, 111, 108, 0,
            0, 0, 0, 0, 0, 0, 1,
        ]
        .to_vec();

        let template = NewTemplate {
            template_id: 1,
            future_template: false,
            version: 536870912,
            coinbase_tx_version: 2,
            coinbase_prefix: vec![82, 0].try_into().unwrap(),
            coinbase_tx_input_sequence: 4294967295,
            coinbase_tx_value_remaining: 5000000000,
            coinbase_tx_outputs_count: 1,
            coinbase_tx_outputs: vec![
                0, 0, 0, 0, 0, 0, 0, 0, 38, 106, 36, 170, 33, 169, 237, 226, 246, 28, 63, 113, 209,
                222, 253, 63, 169, 153, 223, 163, 105, 83, 117, 92, 105, 6, 137, 121, 153, 98, 180,
                139, 235, 216, 54, 151, 78, 140, 249,
            ]
            .try_into()
            .unwrap(),
            coinbase_tx_locktime: 0,
            merkle_path: vec![].try_into().unwrap(),
        };

        // match the original script format used to generate the coinbase_reward_outputs for the
        // expected job
        let pubkey_hash = [
            235, 225, 183, 220, 194, 147, 204, 170, 14, 231, 67, 168, 111, 137, 223, 130, 88, 194,
            8, 252,
        ];
        let mut script_bytes = vec![0]; // SegWit version 0
        script_bytes.push(20); // Push 20 bytes (length of pubkey hash)
        script_bytes.extend_from_slice(&pubkey_hash);
        let script = ScriptBuf::from(script_bytes);
        let coinbase_reward_outputs = vec![TxOut {
            value: Amount::from_sat(5000000000),
            script_pubkey: script,
        }];

        let chain_tip = ChainTip::new(
            [
                200, 53, 253, 129, 214, 31, 43, 84, 179, 58, 58, 76, 128, 213, 24, 53, 38, 144,
                205, 88, 172, 20, 251, 22, 217, 141, 21, 221, 21, 0, 0, 0,
            ]
            .into(),
            503543726,
            1746839905,
        );

        let set_custom_mining_job = jdc_job_factory
            .new_custom_job(
                1,
                1,
                vec![0].try_into().unwrap(),
                chain_tip,
                template,
                coinbase_reward_outputs,
                32,
            )
            .unwrap();

        let mut pool_job_factory =
            JobFactory::new(true, Some("Stratum V2 SRI Pool".to_string()), None);

        let custom_job = pool_job_factory
            .new_extended_job_from_custom_job(set_custom_mining_job, extranonce_prefix, 32)
            .unwrap();

        let expected_job = NewExtendedMiningJob {
            channel_id: 1,
            job_id: 1,
            min_ntime: Sv2OptionOwned::new(Some(1746839905)),
            version: 536870912,
            version_rolling_allowed: true,
            // contains scriptSig with Sv2/Stratum V2 SRI Pool/Stratum V2 SRI Miner/
            coinbase_tx_prefix: vec![
                2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 81, 82, 0, 45, 83, 118, 50, 47, 83,
                116, 114, 97, 116, 117, 109, 32, 86, 50, 32, 83, 82, 73, 32, 80, 111, 111, 108, 47,
                83, 116, 114, 97, 116, 117, 109, 32, 86, 50, 32, 83, 82, 73, 32, 77, 105, 110, 101,
                114, 47, 32,
            ]
            .try_into()
            .unwrap(),
            coinbase_tx_suffix: vec![
                255, 255, 255, 255, 2, 0, 242, 5, 42, 1, 0, 0, 0, 22, 0, 20, 235, 225, 183, 220,
                194, 147, 204, 170, 14, 231, 67, 168, 111, 137, 223, 130, 88, 194, 8, 252, 0, 0, 0,
                0, 0, 0, 0, 0, 38, 106, 36, 170, 33, 169, 237, 226, 246, 28, 63, 113, 209, 222,
                253, 63, 169, 153, 223, 163, 105, 83, 117, 92, 105, 6, 137, 121, 153, 98, 180, 139,
                235, 216, 54, 151, 78, 140, 249, 0, 0, 0, 0,
            ]
            .try_into()
            .unwrap(),
            merkle_path: vec![].try_into().unwrap(),
        };

        assert_eq!(custom_job.get_job_message(), &expected_job);
    }

    // builds a `SetCustomMiningJob` with the given `coinbase_prefix`, bypassing `new_custom_job`
    // so the receiving side can be exercised with prefixes a well-behaved JDC would never send
    fn custom_job_with_coinbase_prefix(coinbase_prefix: Vec<u8>) -> SetCustomMiningJobOwned {
        SetCustomMiningJobOwned {
            channel_id: 1,
            request_id: 1,
            token: vec![0].try_into().unwrap(),
            version: 536870912,
            prev_hash: [0u8; 32].into(),
            min_ntime: 1746839905,
            nbits: 503543726,
            coinbase_tx_version: 2,
            coinbase_prefix: coinbase_prefix.try_into().unwrap(),
            coinbase_tx_input_n_sequence: 4294967295,
            coinbase_tx_outputs: serialize(&coinbase_reward_outputs()).try_into().unwrap(),
            coinbase_tx_locktime: 0,
            merkle_path: vec![].try_into().unwrap(),
        }
    }

    #[test]
    fn test_new_custom_job_rejects_oversized_script_sig() {
        // same boundary as `test_coinbase_rejects_oversized_script_sig`: a 52 char pool tag places
        // the worst-case scriptSig exactly on the budget
        let job_factory = JobFactory::new(true, Some("x".repeat(52)), None);
        let chain_tip = ChainTip::new([0u8; 32].into(), 503543726, 1746839905);

        let new_custom_job = |coinbase_prefix_len: usize| {
            job_factory.new_custom_job(
                1,
                1,
                vec![0].try_into().unwrap(),
                chain_tip.clone(),
                template_with_coinbase_prefix(vec![0xab; coinbase_prefix_len]),
                coinbase_reward_outputs(),
                32,
            )
        };

        // a spec-compliant 8 byte coinbase_prefix fits exactly
        assert!(new_custom_job(MAX_COINBASE_PREFIX_SIZE).is_ok());

        // one byte over must be rejected here, so the Job Declarator Client fails locally rather
        // than having the pool reject the `SetCustomMiningJob` it just sent
        assert!(matches!(
            new_custom_job(MAX_COINBASE_PREFIX_SIZE + 1).unwrap_err(),
            JobFactoryError::ScriptSigSizeTooLarge
        ));
    }

    #[test]
    fn test_job_id_wraps_to_zero_after_u32_max() {
        let mut job_factory = JobFactory::new(true, None, None);

        let new_job = |job_factory: &mut JobFactory| {
            job_factory
                .new_extended_job(
                    1,
                    None,
                    vec![0; 32],
                    template_with_coinbase_prefix(vec![82, 0]),
                    coinbase_reward_outputs(),
                    32,
                )
                .unwrap()
        };

        // place the private counter one below the last u32 ID
        job_factory.job_id_factory.state = u32::MAX - 1;
        assert_eq!(new_job(&mut job_factory).get_job_message().job_id, u32::MAX);

        // the next allocation must wrap to 0 and restart the sequence, identically across
        // build profiles (this test panics on overflow-checked builds without the explicit
        // wrapping arithmetic)
        assert_eq!(new_job(&mut job_factory).get_job_message().job_id, 0);
        assert_eq!(new_job(&mut job_factory).get_job_message().job_id, 1);
    }

    #[test]
    fn test_custom_job_rejects_oversized_script_sig() {
        // a custom job's coinbase_prefix already embeds the pool/miner tag, so the assembled
        // scriptSig is just the prefix plus the full extranonce: 68 + 32 = 100
        let mut job_factory = JobFactory::new(true, None, None);

        let job = job_factory.new_extended_job_from_custom_job(
            custom_job_with_coinbase_prefix(vec![0xab; MAX_SCRIPT_SIG_SIZE - 32]),
            vec![0; 32],
            32,
        );
        assert!(job.is_ok());

        // one byte over the budget yields a consensus-invalid coinbase
        let job = job_factory.new_extended_job_from_custom_job(
            custom_job_with_coinbase_prefix(vec![0xab; MAX_SCRIPT_SIG_SIZE - 32 + 1]),
            vec![0; 32],
            32,
        );
        assert!(matches!(
            job.unwrap_err(),
            JobFactoryError::ScriptSigSizeTooLarge
        ));

        // a hostile downstream can otherwise push the scriptSig past the 252 byte CompactSize
        // threshold, which would also mis-slice the prefix/suffix split
        let job = job_factory.new_extended_job_from_custom_job(
            custom_job_with_coinbase_prefix(vec![0xab; 250]),
            vec![0; 32],
            32,
        );
        assert!(matches!(
            job.unwrap_err(),
            JobFactoryError::ScriptSigSizeTooLarge
        ));
    }
}