Constructors

Synopses

Declared in <script/miniscript.h>

Deleted copy constructor; use Clone() instead.

Node(Node const& other) = delete;

Move constructor.

Node(Node&& other) noexcept = default;

Constructs a leaf node with only a k value, performing the duplicate key check.

template<typename Ctx>
Node(
    Ctx const& ctx,
    Fragment nt,
    uint32_t val = 0);

Constructs a leaf node with only a k value, bypassing the duplicate key check.

Node(
    /* implementation-defined */ no_dup_check,
    MiniscriptContext script_ctx,
    Fragment nt,
    uint32_t val = 0);

Constructs a node with keys, performing the duplicate key check.

template<typename Ctx>
Node(
    Ctx const& ctx,
    Fragment nt,
    std::vector<Key> key,
    uint32_t val = 0);

Constructs a node with subexpressions, performing the duplicate key check.

template<typename Ctx>
Node(
    Ctx const& ctx,
    Fragment nt,
    std::vector<Node> sub,
    uint32_t val = 0);

Constructs a node with data bytes, performing the duplicate key check.

template<typename Ctx>
Node(
    Ctx const& ctx,
    Fragment nt,
    std::vector<unsigned char> arg,
    uint32_t val = 0);

Constructs a node with keys, bypassing the duplicate key check.

Node(
    /* implementation-defined */ no_dup_check,
    MiniscriptContext script_ctx,
    Fragment nt,
    std::vector<Key> key,
    uint32_t val = 0);

Constructs a node with subexpressions, bypassing the duplicate key check.

Node(
    /* implementation-defined */ no_dup_check,
    MiniscriptContext script_ctx,
    Fragment nt,
    std::vector<Node> sub,
    uint32_t val = 0);

Constructs a node with data bytes, bypassing the duplicate key check.

Node(
    /* implementation-defined */ no_dup_check,
    MiniscriptContext script_ctx,
    Fragment nt,
    std::vector<unsigned char> arg,
    uint32_t val = 0);

Constructs a node with subexpressions and keys, performing the duplicate key check.

template<typename Ctx>
Node(
    Ctx const& ctx,
    Fragment nt,
    std::vector<Node> sub,
    std::vector<Key> key,
    uint32_t val = 0);

Constructs a node with subexpressions and data bytes, performing the duplicate key check.

template<typename Ctx>
Node(
    Ctx const& ctx,
    Fragment nt,
    std::vector<Node> sub,
    std::vector<unsigned char> arg,
    uint32_t val = 0);

Constructs a node with subexpressions and keys, bypassing the duplicate key check.

Node(
    /* implementation-defined */ no_dup_check,
    MiniscriptContext script_ctx,
    Fragment nt,
    std::vector<Node> sub,
    std::vector<Key> key,
    uint32_t val = 0);

Constructs a node with subexpressions and data bytes, bypassing the duplicate key check.

Node(
    /* implementation-defined */ no_dup_check,
    MiniscriptContext script_ctx,
    Fragment nt,
    std::vector<Node> sub,
    std::vector<unsigned char> arg,
    uint32_t val = 0);

Parameters

Name

Description

other

The node that would be copied.

ctx

Context providing the script context and key comparator.

nt

The fragment (node type).

val

The k value (timelock value or threshold).

no_dup_check

Tag selecting the constructor that skips the duplicate key check.

script_ctx

The script context (P2WSH or Tapscript).

key

The keys.

sub

The subexpressions.

arg

The data bytes.

Created with MrDocs