The descriptor string in ASCII format. It may include a "*" to denote an arbitrary index (aka ranged descriptors).
Optionalindex?: numberThe descriptor's index in the case of a range descriptor (must be an integer >=0).
OptionalchecksumRequired?: booleanAn optional flag indicating whether the descriptor is required to include a checksum.
OptionalallowMiniscriptInP2SH?: booleanA flag indicating whether this instance can parse and generate script satisfactions for sh(miniscript) top-level expressions of miniscripts. This is not recommended.
Optionalnetwork?: NetworkOne of bitcoinjs-lib networks (or another one following the same interface).
Optionalpreimages?: Preimage[]An array of preimages if the miniscript-based descriptor uses them.
This info is necessary to finalize Psbts. Leave it undefined if your
miniscript-based descriptor does not use preimages or you don't know
or don't wanto use them.
You can also leave it undefined if only need to generate the
scriptPubKey or address for a descriptor.
OptionalsignersPubKeys?: Buffer<ArrayBufferLike>[]An array of the public keys used for signing the transaction when spending the previous output associated with this descriptor.
This parameter is only used if the descriptor object is being used to finalize a transaction. It is necessary to specify the spending path when working with miniscript-based expressions that have multiple spending paths.
Set this parameter to an array containing the public
keys involved in the desired spending path. Leave it undefined if you
only need to generate the scriptPubKey or address for a descriptor,
or if all the public keys involved in the descriptor will sign the
transaction. In the latter case, the satisfier will automatically
choose the most optimal spending path (if more than one is available).
For more details on using this parameter, refer to this Stack Exchange answer.
Creates and returns an instance of bitcoinjs-lib
Payment's interface with the scriptPubKey of this Output.
Returns the Bitcoin Address of this Output.
Returns this Output's scriptPubKey.
Returns the compiled Script Satisfaction if this Output was created
using a miniscript-based descriptor.
The Satisfaction is the unlocking script that fulfills
(satisfies) this Output and it is derived using the Safisfier algorithm
described here.
Important: As mentioned above, note that this function only applies to miniscript descriptors.
An array with all the signatures needed to
build the Satisfaction of this miniscript-based Output.
signatures must be passed using this format (pairs of pubKey/signature):
interface PartialSig { pubkey: Buffer; signature: Buffer; }
'DANGEROUSLY_USE_FAKE_SIGNATURES'. This will generate script satisfactions
using 72-byte zero-padded signatures. While this can be useful in
modules like coinselector that require estimating transaction size before
signing, it is critical to understand the risks:⚠️ Warning: Misuse of 'DANGEROUSLY_USE_FAKE_SIGNATURES' can lead to security vulnerabilities, including but not limited to invalid transaction generation. Ensure you fully understand the implications before use.
Gets the nSequence required to fulfill this Output.
Gets the nLockTime required to fulfill this Output.
Gets the witnessScript required to fulfill this Output. Only applies to
Segwit outputs.
Gets the redeemScript required to fullfill this Output. Only applies to
SH outputs: sh(wpkh), sh(wsh), sh(lockingScript).
Gets the bitcoinjs-lib network used to create this Output.
Whether this Output is Segwit.
NOTE: When the descriptor in an input is addr(address), it is assumed
that any addr(SH_TYPE_ADDRESS) is in fact a Segwit SH_WPKH
(Script Hash-Witness Public Key Hash).
For inputs using arbitrary scripts (not standard addresses),
use a descriptor in the format sh(MINISCRIPT).
Whether this Output is Taproot.
Attempts to determine the type of output script by testing it against various payment types.
This method tries to identify if the output is one of the following types:
An object { isPKH: boolean; isWPKH: boolean; isSH: boolean; isWSH: boolean; isTR: boolean;} with boolean properties indicating the detected output type
Computes the Weight Unit contributions of this Output as if it were the input in a tx.
NOTE: When the descriptor in an input is addr(address), it is assumed
that any addr(SH_TYPE_ADDRESS) is in fact a Segwit SH_WPKH
(Script Hash-Witness Public Key Hash).
, Also any addr(SINGLE_KEY_ADDRESS) * is assumed to be a single key Taproot
address (like those defined in BIP86).
For inputs using arbitrary scripts (not standard addresses),
use a descriptor in the format sh(MINISCRIPT) or tr(MINISCRIPT).
Note however that tr(MINISCRIPT) is not yet supported for non-single-key
expressions.
Indicates if the transaction is a Segwit transaction. If a transaction isSegwitTx, a single byte is then also required for non-witness inputs to encode the length of the empty witness stack: encodeLength(0) + 0 = 1 Read more: https://gist.github.com/junderw/b43af3253ea5865ed52cb51c200ac19c?permalink_comment_id=4760512#gistcomment-4760512
Computes the Weight Unit contributions of this Output as if it were the output in a tx.
Sets this output as an input of the provided psbt and updates the
psbt locktime if required by the descriptor.
psbt and vout are mandatory. Include txHex as well. The pair
vout and txHex define the transaction and output number this instance
pertains to.
Though not advised, for Segwit inputs you can pass txId and value
in lieu of txHex. If doing so, ensure value accuracy to avoid
potential fee attacks -
See this issue.
Note: Hardware wallets need the full txHex for Segwit.
When unsure, always use txHex, and skip txId and value for safety.
Use rbf to mark whether this tx can be replaced with another with
higher fee while being in the mempool. Note that a tx will automatically
be marked as replacable if a single input requests it.
Note that any transaction using a relative timelock (nSequence < 0x80000000)
also falls within the RBF range (nSequence < 0xFFFFFFFE), making it
inherently replaceable. So don't set rbf to false if this is tx uses
relative time locks.
A finalizer function to be used after signing the psbt.
This function ensures that this input is properly finalized.
The finalizer has this signature:
( { psbt, validate = true } : { psbt: Psbt; validate: boolean | undefined } ) => void
Adds this output as an output of the provided psbt with the given
value.
The parameters for the method.
The Partially Signed Bitcoin Transaction.
The value for the output in satoshis.
Finalizes a PSBT input by adding the necessary unlocking script that satisfies this Output's
spending conditions.
🔴 IMPORTANT 🔴
It is STRONGLY RECOMMENDED to use the finalizer function returned by
updatePsbtAsInput instead
of calling this method directly.
This approach eliminates the need to manage the Output instance and the
input's index, simplifying the process.
The finalizePsbtInput method completes a PSBT input by adding the
unlocking script (scriptWitness or scriptSig) that satisfies
this Output's spending conditions. Bear in mind that both
scriptSig and scriptWitness incorporate signatures. As such, you
should complete all necessary signing operations before calling this
method.
For each unspent output from a previous transaction that you're
referencing in a psbt as an input to be spent, apply this method as
follows: output.finalizePsbtInput({ index, psbt }).
It's essential to specify the exact position (or index) of the input in
the psbt that references this unspent Output. This index should
align with the value returned by the updatePsbtAsInput method.
Note:
The index corresponds to the position of the input in the psbt.
To get this index, right after calling updatePsbtAsInput(), use:
index = psbt.data.inputs.length - 1.
Optionalvalidate?: booleanRuns further test on the validity of the signatures. It speeds down the finalization process but makes sure the psbt will be valid.
Decomposes the descriptor used to form this Output into its elemental
parts. See ExpansionMap for a detailed explanation.
The
Outputclass is the central component for managing descriptors. It facilitates the creation of outputs to receive funds and enables the signing and finalization of PSBTs (Partially Signed Bitcoin Transactions) for spending UTXOs (Unspent Transaction Outputs).