rostrum 14.0.1

An efficient implementation of Electrum Server with token support
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

from decimal import Decimal
import time

from test_framework.bch.script import anycanspend_locking_script

from .nodemessages import CBlock, CTransaction, CTxIn, COutPoint, CTxOut
from ..script import CScript
from ..constants import COIN
from ..serialize import ser_string, serialize_script_num

COINBASE_REWARD = Decimal("50.00000000")


def create_block(hashprev, coinbase, n_time: int | None = None, txns=None) -> CBlock:
    """
    Create a block (with regtest difficulty)
    """
    block = CBlock()
    if n_time is None:
        block.n_time = int(time.time() + 600)
    else:
        block.n_time = n_time
    if isinstance(hashprev, str):
        hashprev = int(hashprev, 16)
    block.hash_prev_block = hashprev
    block.n_bits = 0x207FFFFF  # Will break after a difficulty adjustment...
    if coinbase:
        block.vtx.append(coinbase)
    if txns:
        txns.sort(key=lambda x: x.hash)
        block.vtx += txns
    block.hash_merkle_root = block.calc_merkle_root()
    block.rehash()
    return block


def create_coinbase(height) -> CTransaction:
    """
    Create a coinbase transaction, assuming no miner fees.
    If pubkey is passed in, the coinbase output will be a P2PK output;
    otherwise an anyone-can-spend output.
    """

    coinbase = CTransaction()
    coinbase.vin.append(
        CTxIn(
            COutPoint(0, 0xFFFFFFFF),
            ser_string(serialize_script_num(height)),
            0xFFFFFFFF,
        )
    )
    coinbaseoutput = CTxOut()
    coinbaseoutput.n_value = int(COINBASE_REWARD) * COIN
    halvings = int(height / 150)  # regtest
    coinbaseoutput.n_value >>= halvings

    script_pubkey = anycanspend_locking_script()
    coinbaseoutput.script_pubkey = CScript(script_pubkey)
    coinbase.vout = [coinbaseoutput]

    # Make sure the coinbase is at least 100 bytes
    coinbase_size = len(coinbase.serialize())
    if coinbase_size < 100:
        coinbase.vin[0].script_sig += b"x" * (100 - coinbase_size)

    coinbase.calc_sha256()
    return coinbase


PADDED_ANY_SPEND = (
    b"\x61" * 50
)  # add a bunch of OP_NOPs to make sure this tx is long enough


# out_type not used on BCH; but accepted paramter for compatibility with nex
# pylint: disable=too-many-positional-arguments,too-many-arguments,unused-argument
def create_transaction(
    prevtx: CTransaction, n, sig, value, out=PADDED_ANY_SPEND, out_type=0
) -> CTransaction:
    """
    Create a transaction with an anyone-can-spend output, that spends the
    nth output of prevtx.  pass a single integer value to make one output,
    or a list to create multiple outputs
    """
    prevtx.calc_sha256()
    if not isinstance(value, list):
        value = [value]
    tx = CTransaction()
    assert n < len(prevtx.vout)
    tx.vin.append(CTxIn(COutPoint(prevtx.sha256, n), sig, 0xFFFFFFFF))
    for v in value:
        tx.vout.append(CTxOut(v, out))
    tx.rehash()
    return tx