send_on_chain builds a 0-fee transaction → broadcast rejected with "min relay fee not met"

[Jeezman]

Client::send_on_chain produces a transaction that pays zero fee, so broadcasting it fails on any standard node:

sendrawtransaction RPC error: {"code":-26, "message": "min relay fee not met, 0 < 17"}

The let fee = Amount::from_sat(1_000) inside create_send_on_chain_transaction_inner is only used to overselect inputs during coin selection, it is never deducted from the transaction. The actual builder, create_unilateral_exit_transaction, sends every selected sat to the
destination + change, so sum(outputs) == sum(inputs) and the fee is 0. The sweep is effectively unusable on mainnet/signet today.

Environment

• ark-client / ark-core v0.9.3 (also present in v0.9.0–v0.9.2).
• Any backend that enforces a min-relay-fee (i.e. all of them): sendrawtransaction / esplora POST /tx.

Reproduction

1. Have one or more spendable boarding outputs / unilaterally-exited VTXOs.
2. Call client.send_on_chain(addr, amount) with amount < total_selected(so a change output is produced — though it fails with or without change).
3. The returned/broadcast transaction is rejected: min relay fee not met, 0 < N.

Root cause

create_send_on_chain_transaction_inner (ark-client) selects inputs with a 1000-sat margin, then hands the builder only to_amount:

// TODO: Do not use an arbitrary fee.
let fee = Amount::from_sat(1_000);
let (onchain_inputs, vtxo_inputs) = coin_select_for_onchain(self, to_amount + fee).await?;
// ...
let tx = create_unilateral_exit_transaction(
    to_address,
    to_amount,            // <-- the only amount the builder ever sees
    change_address,
    &onchain_inputs,
    &vtxo_inputs,
    sign,
)?;

create_unilateral_exit_transaction (ark-core, ark-core/src/unilateral_exit.rs) then computes change as everything that isn't to_amount:

let total_amount: Amount = onchain_inputs.iter().map(|o| o.amount)
    .chain(vtxo_inputs.iter().map(|v| v.witness_utxo.value))
    .sum();

// change = total - to_amount  (no fee term)
let change_amount = total_amount.checked_sub(to_amount).ok_or_else(/* ... */)?;

let mut output = vec![TxOut { value: to_amount, script_pubkey: to_address.script_pubkey() }];
if change_amount > Amount::ZERO {
    output.push(TxOut { value: change_amount, script_pubkey: change_address.script_pubkey() });
}

So outputs = to_amount + (total − to_amount) = total = inputs, and fee = inputs − outputs = 0. The 1000-sat fee used for selection is handed straight back to the user as change. There is no argument to create_unilateral_exit_transaction that reserves a fee, it is structurally a 0-fee builder.

[arkana-ai-bot]

Arkana debug analysis 🤖

Root cause confirmed. The fee computed in ark-client/src/unilateral_exit.rs is used only for coin selection overselection and is never passed to create_unilateral_exit_transaction in ark-core/src/unilateral_exit.rs.

The gap (ark-core/src/unilateral_exit.rs ~line 179):

let change_amount = total_amount.checked_sub(to_amount)…;
// change = total_inputs − to_amount  ← fee never subtracted

So outputs = to_amount + change_amount = total_inputs, and the miner fee is always 0.

Minimal fix — pass fee into the builder:

// ark-client/src/unilateral_exit.rs — create_send_on_chain_transaction_inner
let tx = create_unilateral_exit_transaction(
    to_address,
    to_amount,
    change_address,
    fee,           // ← add a fee param
    &onchain_inputs,
    &vtxo_inputs,
    sign,
)?;

// ark-core/src/unilateral_exit.rs — create_unilateral_exit_transaction
pub fn create_unilateral_exit_transaction<S>(
    to_address: Address,
    to_amount: Amount,
    change_address: Address,
    fee: Amount,    // ← new param
    …
) {
    …
    let change_amount = total_amount
        .checked_sub(to_amount + fee)   // ← deduct fee
        …;

The TODO comment // TODO: Do not use an arbitrary fee. signals this was a placeholder. A proper fee estimator (weight-based, using feerate from the explorer) should eventually replace the hardcoded 1000 sat, but even passing the constant through fixes the broadcast failure today.

Affected files:

• ark-client/src/unilateral_exit.rs (~line 258, call to create_unilateral_exit_transaction)
• ark-core/src/unilateral_exit.rs (~line 179, change_amount calculation)

[arkana-ai-bot]

Debug analysis (Arkana)

Root cause confirmed — create_send_on_chain_transaction_inner (ark-client/src/unilateral_exit.rs) collects a 1 000-sat fee for coin selection but never passes it to create_unilateral_exit_transaction, which computes change as total_inputs − to_amount. Because coin_select_for_onchain selected to_amount + fee sats, the missing fee returns entirely as change and the miner fee is 0.

Relevant code (current main):

// unilateral_exit.rs — create_send_on_chain_transaction_inner
let fee = Amount::from_sat(1_000);
let (onchain_inputs, vtxo_inputs) = coin_select_for_onchain(self, to_amount + fee).await?;
// ...
let tx = create_unilateral_exit_transaction(
    to_address,
    to_amount,   // <-- fee is NOT deducted here
    change_address,
    &onchain_inputs,
    &vtxo_inputs,
    sign,
)?;

create_unilateral_exit_transaction (ark-core) computes:

let change_amount = total_amount.checked_sub(to_amount)...;
// change = total_inputs − to_amount = (to_amount + fee) − to_amount = fee
// → fee in tx = inputs − outputs = 0

Fix direction — pass to_amount + fee to the builder so change absorbs the delta, OR subtract fee from change explicitly. The cleanest fix is to add a fee: Amount parameter to create_unilateral_exit_transaction and deduct it from the change output:

let change_amount = total_amount
    .checked_sub(to_amount + fee)
    .ok_or_else(|| ...)?;

Long-term the // TODO: Do not use an arbitrary fee should be replaced with proper fee estimation (weight × fee-rate), since a static 1 000 sat fee will be insufficient at high fee rates.

Severity — broadcast fails with min relay fee not met on every real network (signet/mainnet/testnet). The function is effectively unusable today.

[arkana-ai-bot]

Arkana debug analysis 🤖

Root cause confirmed — ark-client/src/unilateral_exit.rs

The fee variable (line 263) is used to size the coin selection but is never deducted from the change output, so the full fee amount flows into the change output instead of staying as a miner fee:

// unilateral_exit.rs ~263
// TODO: Do not use an arbitrary fee.
let fee = Amount::from_sat(1_000);

// Coin selection asks for to_amount + fee worth of inputs ✓
let (onchain_inputs, vtxo_inputs) = coin_select_for_onchain(self, to_amount + fee).await?;

// But create_unilateral_exit_transaction doesn't receive the fee parameter:
let tx = create_unilateral_exit_transaction(
    to_address,
    to_amount,       // outputs exactly to_amount
    change_address,  // change = total_inputs - to_amount (= fee amount → 1000 sat change output)
    &onchain_inputs,
    &vtxo_inputs,
    sign,
)?;

In ark-core/src/unilateral_exit.rs, create_unilateral_exit_transaction computes:

let change_amount = total_amount.checked_sub(to_amount)?;
if change_amount > Amount::ZERO {
    // ← the 1000 sat "fee" ends up here, miner fee = 0
}

Fix approach: Pass fee to create_unilateral_exit_transaction (or a new variant) and deduct it before computing change:

let change_amount = total_amount
    .checked_sub(to_amount + fee)
    .ok_or_else(|| ...)?;

A follow-up improvement is to replace the hardcoded 1 000 sat with a fee-rate × estimated vsize calculation (the TODO comment already notes this). There is prior art in the codebase: ark-core/src/unilateral_exit.rs:~795 already has a fee-rate-aware helper (select_coins_fn / fee_rate) that could be reused here.

Scanned: ark-client/src/unilateral_exit.rs and ark-core/src/unilateral_exit.rs.