Classify the script type of a transaction output’s locking script.

Matches script_pubkey bytes against recognised Bitcoin script templates and returns the corresponding OutputScriptType.

Classification is per-script and structural. It does not determine whether the containing transaction satisfies a node’s configurable relay policy. It also does not extract, decode, or interpret embedded hashes, public keys, witness programs, multisig parameters, signatures, or data payloads. For caller-specific script analysis, use get_raw_script_bytes on the original script.

Classification

├─ 76 A9 14 [×20] 88 AC                  → P2PKH
├─ A9 14 [×20] 87                        → P2SH
├─ 00 14 [×20]                           → P2WPKH
├─ 00 20 [×32]                           → P2WSH
├─ 51 20 [×32]                           → P2TR
├─ 51 02 4E 73                           → P2A
├─ 21 [×33] AC                           → P2PK (33-byte payload)
├─ 41 [×65] AC                           → P2PK (65-byte payload)
├─ 6A …                                  (OP_RETURN prefix)
│   ├─ complete push-only operations     → NullData
│   └─ otherwise                         → Unrecognized
└─ (none matched)
    ├─ [51–60] [02–28] [×push_length]    → OtherWitnessProgram(version)
    └─ structural m-of-n (1 ≤ m ≤ n ≤ 20, minimal counts)
        ├─ AND key-payload count = n     → BareMultisig
        └─ otherwise                     → Unrecognized

Example

fn wallet_supports_output(output: Output) -> Bool {
  case classify_output_script(get_output_script_pubkey(output)) {
    P2WPKH | P2TR -> True
    _ -> False
  }
}

Compute the transaction’s BIP 141 base size in bytes.

This is the byte size of the complete canonical stripped serialization produced by serialize_stripped. For legacy transactions, it is identical to compute_total_size. For SegWit transactions, it excludes the marker, flag, and all witness stack bytes.

This calculation measures the existing transaction fields without allocating a serialized BitArray.

Compute the transaction’s BIP 141 total size in bytes.

This is the byte size of the complete canonical wire serialization produced by serialize. For legacy transactions, it is identical to compute_base_size. For SegWit transactions, it also includes the marker, flag, and all witness stack bytes.

This calculation measures the existing transaction fields without allocating a serialized BitArray.

Compute the transaction identifier (txid) for a transaction.

The txid is the double SHA-256 hash of the transaction’s stripped serialization. The returned hash uses the same little-endian byte order found on the Bitcoin wire.

Compute the transaction’s virtual size in virtual bytes (vbytes).

A virtual byte is four weight units. The result is the transaction’s BIP 141 weight divided by four and rounded up. For example, a transaction weighing 665 weight units has a virtual size of 167 vbytes.

This calculation does not allocate a serialized BitArray or enforce size or weight limits.

Compute the transaction’s BIP 141 weight in weight units.

Weight is calculated as base_size * 3 + total_size. Equivalently, each byte in the stripped serialization contributes four weight units and each byte present only in the complete serialization contributes one.

This calculation measures the existing transaction fields without allocating a serialized BitArray or measuring the base fields more than once.

This function only measures the transaction. It does not enforce the enclosing block’s consensus weight limit.

Compute the witness transaction identifier (wtxid) for a transaction.

The wtxid is the double SHA-256 hash of the transaction’s full wire serialization. The returned hash uses the same little-endian byte order found on the Bitcoin wire. For legacy transactions, the wtxid is identical to the txid.

Get the maximum transaction input count.

Get the maximum transaction output count.

Get the maximum serialized transaction size.

Get the maximum total witness item count across all input stacks.

Return a policy with a custom maximum transaction input count.

After the decoded count has been checked against the bytes remaining in the input, this limit is enforced before any input is decoded. It can bound input parsing and list allocation more tightly than the transaction-size limit alone.

Return a policy with a custom maximum transaction output count.

After the decoded count has been checked against the bytes remaining in the input, this limit is enforced before any output is decoded. It can bound output parsing and list allocation more tightly than the transaction-size limit alone.

Return a policy with a custom maximum serialized transaction size.

For byte-aligned input, this limit is checked before whole-value decoding begins and provides its primary byte envelope. It is not applied when a transaction is decoded as a prefix inside a block; the enclosing block policy owns that byte envelope.

Return a policy with a custom maximum total witness item count.

This limit counts items across all input stacks in one transaction, including zero-length items. After each stack’s count has been checked against the bytes remaining, its contribution to the cumulative count is checked before any of its items are decoded. Empty stacks contribute zero items.

The default transaction decoding policy.

Provides permissive limits, applied automatically when using deserialize or deserialize_hex. They indirectly bound heap usage during binary decoding by limiting serialized size and collection counts. Callers with stricter resource budgets can configure lower limits.

By default, whole-value decoding accepts serialized transactions up to 4,000,000 bytes, up to 100,000 inputs, up to 125,000 outputs, and up to 4,000,000 witness items in total across all input stacks, including zero-length items.

These defaults cover canonical encodings of consensus-valid transactions within Bitcoin’s 4,000,000-weight-unit block limit. Consensus validation is separate.

Deserialize a Bitcoin transaction from its canonical Bitcoin wire-format serialization.

This is the standard entry point for converting a complete serialized Bitcoin transaction into a typed value. The entire input must contain exactly one transaction; trailing bytes are rejected.

This function applies the permissive default_decode_policy limits on transaction size, input/output counts, and total witness item count.

For custom resource limits, use deserialize_with_policy instead.

The returned transaction is marked as Parsed, meaning its structure was successfully parsed but it has not yet been checked against Bitcoin consensus rules.

Returns

• Ok(Transaction(Parsed)): Successfully deserialized within the default policy limits.
• Error(DecodeError): The bytes were not a well-formed transaction encoding within the default policy limits.

Deserialize a Bitcoin transaction from its hexadecimal string representation.

This is a convenience function that combines hex-to-bytes conversion with transaction deserialization. It’s useful when working with transaction data in hexadecimal format, such as from block explorers, RPC responses, or test vectors.

This function applies default_decode_policy for resource limits. For custom resource limits, use deserialize_hex_with_policy instead.

Valid hex that exceeds the byte-size limit is rejected before conversion. Invalid hex takes precedence, including for oversized input. Checking an oversized string’s characters still requires work proportional to its length.

Returns

• Ok(Transaction(Parsed)): Successfully deserialized within the default policy limits.
• Error(InvalidHex): The hex string was invalid (odd length or invalid characters).
• Error(DecodeFailed(error)): The decoded bytes were not a well-formed transaction encoding within the default policy limits.

Deserialize a Bitcoin transaction from hexadecimal with custom resource limits.

This function combines hex-to-bytes conversion with policy-based transaction deserialization, providing both the convenience of hexadecimal input and fine-grained control over resource limits. Use this when working with hex-encoded transaction data that requires custom resource constraints.

Valid hex that exceeds the byte-size limit is rejected before conversion. Invalid hex takes precedence, including for oversized input. Checking an oversized string’s characters still requires work proportional to its length.

Returns

• Ok(Transaction(Parsed)): Successfully deserialized within the supplied policy limits.
• Error(InvalidHex): The hex string was invalid (odd length or invalid characters).
• Error(DecodeFailed(error)): The decoded bytes were not a well-formed transaction encoding within the supplied policy limits.

Deserialize a Bitcoin transaction with custom resource limits.

Like deserialize, but accepts a DecodePolicy to override the resource limits applied during decoding. Use default_decode_policy and the decode_policy_with_* builder functions to construct custom policies. Byte alignment is validated before resource limits. For byte-aligned inputs, limits that are exceeded produce a PolicyLimitExceeded error. See DecodePolicy and default_decode_policy for available options and defaults.

Returns

• Ok(Transaction(Parsed)): Successfully deserialized within the supplied policy limits.
• Error(DecodeError): The bytes were not a well-formed transaction encoding within the supplied policy limits.

Get the specific kind of decoding error that occurred.

Returns the DecodeErrorKind variant that categorizes what went wrong, such as UnexpectedEof, NonMinimalCompactSize, PolicyLimitExceeded, etc. This allows you to handle different error types differently.

Example

fn is_truncated(error: DecodeError) -> Bool {
  case get_decode_error_kind(error) {
    UnexpectedEof(_, _) -> True
    InsufficientBytes(_, _) -> True
    _ -> False
  }
}

Get the byte offset where a decoding error occurred.

The offset is a zero-based position into the input buffer, indicating where the decoder was reading when it encountered the error. This is useful for debugging and error reporting.

Get the structural path for a decoding error.

The path is derived from internal parser-location details and uses a stable, machine-friendly format rooted at transaction. Collection indices are zero-based and written in brackets.

For example, an error at the scriptSig length prefix of the third input produces transaction.inputs[2].script_sig.length.

The path identifies where the error occurred but does not include the byte offset or error kind. Use get_decode_error_offset and get_decode_error_kind for those details.

Get the number of inputs in a transaction.

Returns the decoded CompactSize input count from the transaction wire encoding.

Get the outpoint from an input.

Get the scriptSig from an input.

For non-coinbase inputs, the scriptSig may provide data used during script execution. This library does not execute or validate scripts.

Get the sequence number from an input.

Sequence values can participate in relative lock-time consensus rules and transaction replacement policy. This library exposes the value without interpreting those semantics.

Get the transaction inputs.

Returns the inputs in the same order they appear in the transaction serialization.

Get the unsigned 32-bit lock-time value from a transaction.

Values less than 500,000,000 encode block heights, values greater than or equal to 500,000,000 encode Unix timestamps, and zero encodes no lock-time constraint.

Whether this value constrains transaction finality also depends on the input sequence numbers and block context. This library exposes the value without evaluating finality.

Get the transaction ID from an outpoint.

The hash uses the same little-endian byte order found on the Bitcoin wire. For coinbase inputs, which do not reference a previous output, this returns an all-zero hash.

Get the output index from an outpoint.

Returns the zero-based index of the output within the referenced transaction. For coinbase inputs (which don’t reference a previous output), returns 0xFFFFFFFF, a special sentinel value indicating no previous output.

Get the number of outputs in a transaction.

Returns the decoded CompactSize output count from the transaction wire encoding.

Get the raw scriptPubKey from a transaction output.

A scriptPubKey encodes the conditions for spending an output. This library exposes the script bytes without executing or validating them.

Get the decoded value from a transaction output.

For an output from a Transaction(Parsed), this value may be negative or exceed Bitcoin’s consensus money range. Use validate_context_free_consensus to check the transaction’s output values.

Get the transaction outputs.

Returns the outputs in the same order they appear in the transaction serialization.

Get the raw bytes from a ScriptBytes.

Get the byte size of a ScriptBytes.

The size is measured from the raw script bytes and excludes the CompactSize length prefix used when the script is serialized in a transaction.

Get the transaction version.

The version may affect which consensus rules or transaction semantics apply.

The version field is encoded as 4 little-endian bytes in the transaction wire format. This function returns those bytes interpreted as an unsigned 32-bit integer in the range 0 through 4_294_967_295.

Some Bitcoin documentation and APIs have represented this field as a signed 32-bit integer. This function does not use that convention.

For example, raw version bytes ff ff ff ff are returned as 4_294_967_295, not -1.

Get the raw bytes from a witness item.

Get the witness items from a witness stack.

Returns the witness items in order as they appear in the serialization.

Get the witness stacks from a SegWit transaction.

For SegWit transactions, the witness stacks are returned in order, corresponding 1-to-1 with the transaction inputs by position.

Returns

• Ok(witnesses): The transaction uses SegWit serialization.
• Error(Nil): The transaction uses legacy serialization, which does not contain witness data.

Check whether a context-free-validated transaction has coinbase shape.

The ContextFreeValidated state guarantees that transaction-local consensus checks have already been applied. For this function, True means the transaction has the context-free coinbase structure:

• exactly one input
• the input uses the null outpoint
• the coinbase scriptSig length is within the consensus range

This does not prove that the transaction is valid as the coinbase transaction of a block. Block-level checks such as transaction position, block height, subsidy, and fees are outside the scope of this function.

Returns True if the transaction has coinbase shape, False otherwise.

Check whether an input contains the null outpoint.

The null outpoint is the structural coinbase input marker. This function does not establish that the containing transaction has valid coinbase shape. Use validate_context_free_consensus followed by has_coinbase_shape for that guarantee.

Check whether an outpoint is the null outpoint.

The null outpoint is the special previous output reference used as the coinbase input marker: an all-zero txid with vout 0xFFFFFFFF.

Check whether a transaction uses the SegWit format.

SegWit (Segregated Witness) transactions separate witness data from the main transaction structure, enabling features like improved scalability and transaction malleability fixes.

Returns True for SegWit transactions, False for legacy transactions.

Check whether a witness stack contains no items.

A stack containing a zero-length item is not empty. Emptiness refers to the number of items, not the number of bytes contained in those items.

Return an output amount’s exact eight bytes in little-endian wire order.

Attempt to convert an output amount to a native integer.

Always succeeds on the Erlang target. On the JavaScript target, succeeds only within the safe integer range -9_007_199_254_740_991 through 9_007_199_254_740_991, inclusive; otherwise returns Error(Nil) without rounding the amount.

This conversion does not check Bitcoin’s consensus money range. Output amounts from a transaction that passed validate_context_free_consensus are guaranteed to convert successfully on both targets.

Return an output amount’s exact signed base-10 representation.

This preserves the full value on both Erlang and JavaScript targets, including amounts outside Bitcoin’s consensus money range.

Serialize a transaction in its full wire form, including witness data.

Returns the complete serialization used when computing the wtxid: version, SegWit marker and flag (if applicable), inputs, outputs, witness stacks (if applicable), and lock_time. For legacy transactions, this is identical to serialize_stripped.

See Also

• compute_wtxid — hashes this serialization to produce the wtxid
• serialize_stripped — the no-witness serialization used for the txid

Serialize a transaction without witness data (the “stripped” form).

Returns the stripped transaction serialization used when computing the txid: version, inputs, outputs, and lock_time — with no SegWit marker, flag, or witness stacks, regardless of whether the transaction is SegWit.

See Also

• compute_txid — hashes this serialization to produce the txid
• serialize — the full wire serialization including witness data

Validate a transaction against context-free Bitcoin consensus rules.

“Context-free” means these checks require only the transaction itself — no UTXO set, no block context, and no knowledge of other transactions.

This function enforces all Bitcoin consensus rules that apply to an individual transaction and can be evaluated without UTXO, script-execution, block, or chain context.

The following consensus rules are enforced:

• At least one input
• At least one output
• Base (stripped) serialization is at most 1,000,000 bytes, matching Bitcoin Core’s transaction-level check. SegWit marker, flag, and witness bytes are excluded from this check but contribute to the enclosing block’s separate 4,000,000-WU weight limit.
• Output values are between 0 and 2,100,000,000,000,000 satoshis
• Cumulative output value does not exceed 2,100,000,000,000,000 satoshis
• Coinbase transactions contain exactly one input
• Coinbase scriptSig length is 2–100 bytes (inclusive)
• No two inputs reference the same previous output

Context-dependent checks — script execution, signature verification, input-spend validation against the UTXO set, and block-level rules — are not performed.

Returns

• Ok(Transaction(ContextFreeValidated)): The transaction passed all context-free consensus checks listed above.
• Error(violations): The transaction failed one or more context-free consensus checks. The list contains the detected violations.