minting_testcases.py

import copy
from random import randint, choice
from test_framework.mininode import COIN

BAD_REWARD_COMMON                = 'non-mandatory-script-verify-flag (Bad reward'
BAD_REWARD_ROBBERY               = 'non-mandatory-script-verify-flag (Bad reward. Everybody be cool, this is a robbery!!!)'
BAD_REWARD_NOT_MATURE            = 'non-mandatory-script-verify-flag (Bad reward, not matured)'
BAD_REWARD_BEN_AMOUNT_TOO_HIGH   = 'non-mandatory-script-verify-flag (Bad reward, BIG BEN)'
BAD_REWARD_LIMIT_EXCEEDED        = 'non-mandatory-script-verify-flag (Bad reward, limit exceeded)'
BAD_REWARD_CERT_EXPIRED          = 'non-mandatory-script-verify-flag (Bad reward, cert expired)'
BAD_REWARD_MANY_MONEYBOX_INPUTS  = 'non-mandatory-script-verify-flag (Bad reward, too many moneybox inputs)'
BAD_REWARD_MANY_MONEYBOX_OUTPUTS = 'non-mandatory-script-verify-flag (Bad reward, too many moneybox outputs)'
BAD_REWARD_MANY_USER_OUTPUTS     = 'non-mandatory-script-verify-flag (Bad reward, too many user outputs)'
BAD_REWARD_MANY_BEN_OUTPUTS      = 'non-mandatory-script-verify-flag (Bad reward, too many beneficiary outputs)'
BAD_REWARD_SCRIPT                = 'non-mandatory-script-verify-flag (Bad reward, script)'
BAD_REWARD_ZERO_REPCENT          = 'non-mandatory-script-verify-flag (Bad reward, zero percent)'


'''
Parameters description:

'name': 'any_name',                 # name of testcase, string. May be used to run testcase with this name: 'minting.py --runtestcase=name'
'rootcertamount': 1 * COIN,         # amount to transfer in root certificate, int in satoshi, string or Decimal in coins
'greenflag': True,                  # greenflag, True or False 
'ca3certamount': 1000000,           # amount to transfer in ca3 certificate, int in satoshi, string or Decimal in coins, 1000000 means 10 percent
'ben_enabled': False,               # beneficiary pubkey enabled, True or False  
'ca3_age': 22 * 60 * 60,            # age of ca3 certificate, in seconds
'usermoney_age': 24 * 60 * 60,      # age of user money, in seconds
'useramount': 100 * COIN,           # amount of user money, int in satoshi, string or Decimal in coins
'reward_to': 'ben+other'            # destination where reward outputs will be sent to in mint transaction, string, see @destination_type@ below
                                    #   'user': reward amount will be added to user amount, without creating separate output 
'rewardamount': COIN // 365,        # reward amount, int in satoshi, string or Decimal in coins
'fee_total': 'auto',                # total fee in minting transaction, int in satoshi, string or Decimal in coins, or may be 'auto'
'fee_user_percent': 0,              # what percent of fee_total user will pay, must be int 0 <= x <= 100, or may be 'auto'
'refill_moneybox': 'node',          # who will refill moneybox, may be one of: 'node', 'script', 'random'
'keys_count_total': randint(1,15),  # total keys count in user multisig P2SH address in M of N scheme (keys_count_total == N), int, 1 <= x <= 15
'keys_count_required': 'random',    # required keys count in user multisig P2SH address in M of N scheme (keys_count_required == M), int, 
                                    # in regular workflow is (1 <= x <= keys_count_total), also may be None, 0 or 'random'
                                    #     None or 0 means that this field is not set in certificate, this means (keys_count_required == keys_count_total) by default
                                    #     'random' means random value in range (1 <= x <= keys_count_total)
'keys_count_used': 'auto',          # used keys count in user multisig P2SH address in M of N scheme, in regular workflow is (keys_count_used == keys_count_required), int, may be 'auto'
                                    #     'auto' means (keys_count_used == keys_count_required)
'accepted': True,                   # whether minting transaction is valid and will be accepted by the node, True or False


Optional parameters (may absent):

'revoke_root_cert': True,           # Root certificate is revoked, True or False, default False
'revoke_user_cert': False,          # User certificate is revoked, True or False, default False
'invalid_root_cert_ref': 1          # Invalid reference to root certificate in mint transaction, int, possible values:
                                    #   1: non-existing transaction (certificate) 
                                    #   2: regular P2PKH transaction, not certificate
                                    #   3: invalid certificate: transfers money to another P2PKH address, not to itself
                                    #   4: another root certificate, not a parent of user certificate (CA3 keys in root and user certificates are different)
                                    #   5: invalid root certificate, with unknown root key not mentioned in genezis block
                                    #   6: root certificate with root key mentioned in genezis block, but not in the first entry (in the second entry)
'invalid_user_cert_ref': 1          # Invalid reference to user certificate in mint transaction, int, possible values:
                                    #   1: non-existing transaction (certificate)
                                    #   2: regular P2PKH transaction, not certificate
                                    #   3: invalid certificate: transfers money to another P2PKH address, not to itself
                                    #   4: another user certificate, not a parent of used user keys (user keys used in minting transaction and given in this certificate are different)
                                    #   5: invalid user coins (not mentioned in CA3 certificate), but valid user keys for signing moneybox outputs in minting tx. In other words, user tries to mint coins from another address using correct certificate.
'invalid_refill_moneybox': 1        # Refill moneybox in invalid way, int, possible values:
                                    #   1: Don't refill moneybox
                                    #   2: Refill moneybox on 1 satoshi less than required
                                    #   3: Refill moneybox on 1 satoshi more than required
                                    #   4: Refill moneybox with too low granularity: number of outputs is more than (sum/gran + 1)
                                    #   5: Refill moneybox with too high granularity (more than 10 PLC)
'refill_moneybox_dest': 'user'      # Destination where moneybox outputs will be sent when refilling moneybox, string, see @destination_type@ below
'refill_moneybox_accepted': False   # Result of acceptance of a new block when refilling moneybox, True or False, default True 
'green_flag_in_user_cert': True     # Set up green flag in user certificate (in default workflow it is always False), True or False
'extra_moneybox_inputs_count': 2    # Number of extra moneybox inputs count (besides those that are needed to cover required amount), in regular workflow must be 0, int
'more_useramount1': 5 * COIN        # One more user input, see 'useramount'
'more_useramount2': 200000          # One more user input, see 'useramount'
'moneybox_change_dest': 'user+ben'  # Destination where moneybox change outputs will be sent to in mint transaction, string, see @destination_type@ below
'user_outputs_dest': 'ben'          # Destination where user outputs will be sent to in mint transaction, string, see @destination_type@ below 
'ca3_expiration_offset': 3600       # Expiration date offset in ca3 certificate due to block timestamp this certificate is mined in, int, in seconds
                                    # If None, no expiration date field presents in certificate. Default None.
                                    #    'ca3_expiration_offset' < 0: expiration date is X seconds less than the block timestamp (expires before the block this certificate is mined in)
                                    #    'ca3_expiration_offset' == 0: expiration date is equal to the block timestamp
                                    #    'ca3_expiration_offset' > 0: expiration date is X seconds more than the block timestamp 
'ca3_minting_limit': 10 * COIN      # Minting limit in ca3 certificate, int in satoshi, string or Decimal in coins, None means that it is not set, default None.

'step2_enabled':                    # Step 2 is enabled (compose and send one more minting transaction), True/False, default False
'step2_wait_interval':              # Step 2: wait interval, in seconds
'step2_rewardamount': COIN // 365,  # Step 2: reward amount, int in satoshi, string or Decimal in coins
'step2_reward_to': 'user'           # Step 2: destination where reward outputs will be sent to in mint transaction, string, see @destination_type@ below
'step2_accepted': True              # Step 2: whether minting transaction is valid and will be accepted by the node, True or False 

'step3_enabled':                    # Step 3 is enabled (compose and send one more minting transaction), True/False, default False
'step3_wait_interval':              # Step 3: wait interval, in seconds
'step3_rewardamount': COIN // 365,  # Step 3: reward amount, int in satoshi, string or Decimal in coins
'step3_reward_to': 'user'           # Step 3: destination where reward outputs will be sent to in mint transaction, string, see @destination_type@ below
'step3_accepted': True              # Step 3: whether minting transaction is valid and will be accepted by the node, True or False

'error': (64, 'error-message'),     # Error code and error message, any value from this pair may be None. Actual only when 'accepted' == False, otherwise is ignored.
                                    #     Ensures that received error code is equal to this one (if not None), 
                                    #     and received error message starts with the given string (if not None).


'@destination_type@': 'user+ben'    # Destination where outputs will be sent, string, may be expression with '+' and given values:
                                    #   'user': to user multisig P2SH address (regular user address)
                                    #   'user_shuffled': to user multisig P2SH address, but user keys are in wrong order (must be 'keys_count' > 1)
                                    #   'user_pure_multisig': to user pure multisig address, not P2SH 
                                    #   'ben': to ben P2PKH address ('ben_enabled' parameter must be True)
                                    #   'moneybox': to moneybox P2SH address
                                    #   'other_p2pkh' or 'other': random P2PKH address 
                                    #   'other_p2sh': random P2SH address
                                    #   'op_true': to address [OP_TRUE], anyone can spend
                                    #   'op_false': to address [OP_FALSE], noone can spend
                                    # Examples:
                                    #   'moneybox+moneybox+moneybox': creates 3 moneybox outputs
                                    #   'moneybox+user+ben': sends coins to moneybox, user and ben simultaneously, 1 output per each
                                    #   'ben': sends coins to ben
                                    #   '': (empty string) doesn't send coins, no outputs


In any parameters instead of value there may be array of values of the same type.
This will be transformed to all possible combinations of these values.
Example:
'parameter_a' : [True, False]
'parameter_b' : [1,2,3]
Result: (True, 1), (True, 2), (True, 3), (False, 1), (False, 2), (False, 3)
'''

testcases_templates = \
[
    {
        # (all keys_count from 1 to 15 and all reward_to (user, ben, other) in positive scenario): accepted
        'name': 'base00',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 22 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': ['user', 'ben', 'other'],
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15],
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': True,
    },
    {
        # base00, rewardamount +1 satoshi more than allowed): rejected
        'name': 'base00e',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 22 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': ['user', 'ben', 'other'],
        'rewardamount': COIN * 10 // 365 + 1,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': False,
        'error': (64, BAD_REWARD_COMMON), # BAD_REWARD_ROBBERY for user and ben, BAD_REWARD_BEN_AMOUNT_TOO_HIGH for other
    },
    {
        # (usermoney_age < 23h, greenflag: any, ca3_age: any): rejected
        'name': 'm00',
        'rootcertamount': 1 * COIN,
        'greenflag': [True, False],
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': [0, 24 * 60 * 60],
        'usermoney_age': 23 * 60 * 60 - 60,
        'useramount': 1000 * COIN,
        'reward_to': ['user', 'ben', 'other'],
        'rewardamount': COIN * 10 * 22 // 24 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': False,
        'error': (64, BAD_REWARD_NOT_MATURE),
    },

    #
    # greenflag == True
    #
    {
        # (usermoney_age == 23h, greenflag == True): accepted
        # + add parameter green_flag_in_user_cert=[False,True], it must be ignored, ensure that result is the same
        'name': 'm01',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 0,
        'usermoney_age': 23 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': choice(['user', 'other']),
        'rewardamount': COIN * 10 * 23 // 24 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'green_flag_in_user_cert': [ False, True ],
        'accepted': True,
    },
    {
        # (based on m01, greenflag=False, green_flag_in_user_cert=True, use green flag in user cert instead of root cert): rejected
        'name': 'm01A',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 0,
        'usermoney_age': 23 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': choice(['user', 'other']),
        'rewardamount': COIN * 10 * 23 // 24 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'green_flag_in_user_cert': True,
        'accepted': False,
        'error': (64, BAD_REWARD_NOT_MATURE),
    },
    {
        # (m01, rewardamount +1 satoshi more than allowed): rejected
        'name': 'm01e',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 0,
        'usermoney_age': 23 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': choice(['user', 'other']),
        'rewardamount': COIN * 10 * 23 // 24 // 365 + 1,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': False,
        'error': (64, BAD_REWARD_COMMON), # BAD_REWARD_ROBBERY for user and ben, BAD_REWARD_BEN_AMOUNT_TOO_HIGH for other
    },
    {
        # (23h < usermoney_age < 30d, greenflag == True): accepted
        'name': 'm03',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 0,
        'usermoney_age': 12 * 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': ['user', 'other'],
        'rewardamount': COIN * 10 * 12 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': True,
    },
    {
        # m03, rewardamount +1 satoshi more than allowed: rejected
        'name': 'm03e',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 0,
        'usermoney_age': 23 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': ['user', 'other'],
        'rewardamount': COIN * 10 * 12 // 365 + 1,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': False,
        'error': (64, BAD_REWARD_ROBBERY),
    },
    {
        # (usermoney_age >= 30d, greenflag == True): accepted
        'name': 'm05',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 0,
        'usermoney_age': [ 30 * 24 * 60 * 60, 31 * 24 * 60 * 60 ],
        'useramount': 100 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 10 * 30 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': True,
    },
    {
        # m05, rewardamount +1 satoshi more than allowed: rejected
        'name': 'm05e',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 0,
        'usermoney_age': [ 30 * 24 * 60 * 60, 31 * 24 * 60 * 60 ],
        'useramount': 100 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 10 * 30 // 365 + 1,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': False,
        'error': (64, BAD_REWARD_ROBBERY),
    },

    #
    # greenflag == False
    #
    {
        # (usermoney_age < 20d, 20d < ca3_age < 30d, greenflag == False): rejected
        'name': 'm09',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 21 * 24 * 60 * 60,
        'usermoney_age': 20 * 24 * 60 * 60 - 60,
        'useramount': 100 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 10 * 19 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': False,
        'error': (64, BAD_REWARD_NOT_MATURE),
    },
    {
        # (ca3_age < 20d, 20d < usermoney_age < 30d, greenflag == False): accepted (ca3_age must be used)
        'name': 'm10',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 18 * 24 * 60 * 60,
        'usermoney_age': 22 * 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': choice(['user', 'ben', 'other']),
        'rewardamount': COIN * 10 * 18 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': True,
    },
    {
        # m10, rewardamount +1 satoshi more than allowed: rejected
        'name': 'm10e',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 18 * 24 * 60 * 60,
        'usermoney_age': 22 * 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': choice(['user', 'ben', 'other']),
        'rewardamount': COIN * 10 * 18 // 365 + 1,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': False,
        'error': (64, BAD_REWARD_COMMON), # BAD_REWARD_ROBBERY for user and ben, BAD_REWARD_BEN_AMOUNT_TOO_HIGH for other
    },
    {
        # (usermoney_age == 20d, ca3_age == 20d, greenflag == False): accepted
        'name': 'm11',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 20 * 24 * 60 * 60,
        'usermoney_age': 20 * 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 10 * 20 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': True,
    },
    {
        # m11, rewardamount +1 satoshi more than allowed: rejected
        'name': 'm11e',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 20 * 24 * 60 * 60,
        'usermoney_age': 20 * 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 10 * 20 // 365 + 1,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': False,
        'error': (64, BAD_REWARD_ROBBERY),
    },
    {
        # (usermoney_age == 20d, 20d < ca3_age < 30d, greenflag == False): accepted
        'name': 'm13',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 21 * 24 * 60 * 60,
        'usermoney_age': 20 * 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 10 * 20 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': True,
    },
    {
        # m13, rewardamount +1 satoshi more than allowed: rejected
        'name': 'm13e',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 21 * 24 * 60 * 60,
        'usermoney_age': 20 * 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 10 * 20 // 365 + 1,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': False,
        'error': (64, BAD_REWARD_ROBBERY),
    },
    {
        # (20d < usermoney_age < 30d, ca3_age == 20d, greenflag == False): accepted
        'name': 'm15',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 20 * 24 * 60 * 60,
        'usermoney_age': 23 * 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 10 * 20 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': True,
    },
    {
        # m15, rewardamount +1 satoshi more than allowed): rejected
        'name': 'm15e',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 20 * 24 * 60 * 60,
        'usermoney_age': 23 * 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 10 * 20 // 365 + 1,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': False,
        'error': (64, BAD_REWARD_ROBBERY),
    },
    {
        # (20d < usermoney_age < 30d, 20d < ca3_age < 30d, usermoney_age > ca3_age, greenflag == False): accepted
        'name': 'm17',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 23 * 24 * 60 * 60,
        'usermoney_age': 25 * 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 10 * 23 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': True,
    },
    {
        # m17, rewardamount +1 satoshi more than allowed: rejected
        'name': 'm17e',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 23 * 24 * 60 * 60,
        'usermoney_age': 25 * 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 10 * 23 // 365 + 1,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': False,
        'error': (64, BAD_REWARD_ROBBERY),
    },
    {
        # (20d < usermoney_age < 30d, 20d < ca3_age < 30d, ca3_age > usermoney_age, greenflag == False): accepted
        'name': 'm19',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 29 * 24 * 60 * 60,
        'usermoney_age': 25 * 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 10 * 25 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': True,
    },
    {
        # m19, rewardamount +1 satoshi more than allowed: rejected
        'name': 'm19e',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 29 * 24 * 60 * 60,
        'usermoney_age': 25 * 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 10 * 25 // 365 + 1,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': False,
        'error': (64, BAD_REWARD_ROBBERY),
    },
    {
        # (usermoney_age == 30d, 20d < ca3_age < 30d, greenflag == False): accepted
        'name': 'm21',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 21 * 24 * 60 * 60,
        'usermoney_age': 30 * 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 10 * 21 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': True,
    },
    {
        # m21, rewardamount +1 satoshi more than allowed: rejected
        'name': 'm21e',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 21 * 24 * 60 * 60,
        'usermoney_age': 30 * 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 10 * 21 // 365 + 1,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': False,
        'error': (64, BAD_REWARD_ROBBERY),
    },
    {
        # (20d < usermoney_age < 30d, ca3_age == 30d, greenflag == False): accepted
        'name': 'm23',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 30 * 24 * 60 * 60,
        'usermoney_age': 23 * 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 10 * 23 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': True,
    },
    {
        # m23, rewardamount +1 satoshi more than allowed: rejected
        'name': 'm23e',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 30 * 24 * 60 * 60,
        'usermoney_age': 23 * 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 10 * 23 // 365 + 1,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': False,
        'error': (64, BAD_REWARD_ROBBERY),
    },
    {
        # (usermoney_age == 30d, ca3_age == 30d, greenflag == False): accepted
        'name': 'm25',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 30 * 24 * 60 * 60,
        'usermoney_age': 30 * 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 10 * 30 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': True,
    },
    {
        # m25, rewardamount +1 satoshi more than allowed: rejected
        'name': 'm25e',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 30 * 24 * 60 * 60,
        'usermoney_age': 30 * 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 10 * 30 // 365 + 1,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': False,
        'error': (64, BAD_REWARD_ROBBERY),
    },
    {
        # (usermoney_age == 30d, ca3_age > 30d, greenflag == False): accepted
        'name': 'm27',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 31 * 24 * 60 * 60,
        'usermoney_age': 30 * 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 10 * 30 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': True,
    },
    {
        # m27, rewardamount +1 satoshi more than allowed: rejected
        'name': 'm27e',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 31 * 24 * 60 * 60,
        'usermoney_age': 30 * 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 10 * 30 // 365 + 1,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': False,
        'error': (64, BAD_REWARD_ROBBERY),
    },
    {
        # (usermoney_age > 30d, ca3_age == 30d, greenflag == False): accepted
        'name': 'm29',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 30 * 24 * 60 * 60,
        'usermoney_age': 37 * 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 10 * 30 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': True,
    },
    {
        # m29, rewardamount +1 satoshi more than allowed: rejected
        'name': 'm29e',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 30 * 24 * 60 * 60,
        'usermoney_age': 37 * 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 10 * 30 // 365 + 1,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': False,
        'error': (64, BAD_REWARD_ROBBERY),
    },
    {
        # (usermoney_age > 30d, ca3_age > 30d, usermoney_age > ca3_age, greenflag == False): accepted
        'name': 'm31',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 31 * 24 * 60 * 60,
        'usermoney_age': 35 * 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 10 * 30 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': True,
    },
    {
        # m31, rewardamount +1 satoshi more than allowed: rejected
        'name': 'm31e',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 31 * 24 * 60 * 60,
        'usermoney_age': 35 * 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 10 * 30 // 365 + 1,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': False,
        'error': (64, BAD_REWARD_ROBBERY),
    },
    {
        # (usermoney_age > 30d, ca3_age > 30d, ca3_age > usermoney_age, greenflag == False): accepted
        'name': 'm33',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 38 * 24 * 60 * 60,
        'usermoney_age': 35 * 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 10 * 30 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': True,
    },
    {
        # m33, rewardamount +1 satoshi more than allowed: rejected
        'name': 'm33e',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 38 * 24 * 60 * 60,
        'usermoney_age': 35 * 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 10 * 30 // 365 + 1,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': False,
        'error': (64, BAD_REWARD_ROBBERY),
    },
    {
        # (the same as m33, but large useramount is used): accepted
        'name': 'm33A',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 38 * 24 * 60 * 60,
        'usermoney_age': 35 * 24 * 60 * 60,
        'useramount': 5000 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 500 * 30 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': True,
    },
    {
        # (m33A, rewardamount +1 satoshi more than allowed): rejected
        'name': 'm33Ae',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 38 * 24 * 60 * 60,
        'usermoney_age': 35 * 24 * 60 * 60,
        'useramount': 5000 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 500 * 30 // 365 + 1,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': False,
        'error': (64, BAD_REWARD_ROBBERY),
    },
    {
        # (the same as m33, but large useramount is used, close to limit 10*10 PLC): accepted
        'name': 'm33B',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 38 * 24 * 60 * 60,
        'usermoney_age': 35 * 24 * 60 * 60,
        'useramount': 10000 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 1000 * 30 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': True,
    },
    {
        # (m33B, rewardamount +1 satoshi more than allowed): rejected
        'name': 'm33Be',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 38 * 24 * 60 * 60,
        'usermoney_age': 35 * 24 * 60 * 60,
        'useramount': 10000 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 1000 * 30 // 365 + 1,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': False,
        'error': (64, BAD_REWARD_ROBBERY),
    },
    {
        # (the same as m33, rewardamount is 2 times less than must be): accepted
        'name': 'm33C',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 38 * 24 * 60 * 60,
        'usermoney_age': 35 * 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 10 * 30 // 365 // 2,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': True,
    },
    # other cases
    {
        # (rootcertamount < ca3certamount): accepted, rootcertamount is used
        'name': 'm35',
        'rootcertamount': 1000000,
        'greenflag': True,
        'ca3certamount': 1200000,
        'ben_enabled': False,
        'ca3_age': 38 * 24 * 60 * 60,
        'usermoney_age': 35 * 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 10 * 30 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': True,
    },
    {
        # m35, rewardamount +1 satoshi more than allowed: rejected
        'name': 'm35e',
        'rootcertamount': 1000000,
        'greenflag': True,
        'ca3certamount': 1200000,
        'ben_enabled': False,
        'ca3_age': 38 * 24 * 60 * 60,
        'usermoney_age': 35 * 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 10 * 30 // 365 + 1,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': False,
        'error': (64, BAD_REWARD_ROBBERY),
    },
    {
        # reward to [user, ben], fee_user_percent [50%, 100%]: accepted (not needed user to pay fee, but not forbidden)
        'name': 'm38',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 38 * 24 * 60 * 60,
        'usermoney_age': 35 * 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': ['user', 'ben'],
        'rewardamount': COIN * 10 * 30 // 365,
        'fee_total': '0.01',
        'fee_user_percent': [ 50, 100 ],
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': True,
    },
    {
        # (reward to other, fee_user_percent == 60%, 100%): accepted (user must pay ~45-52%, not needed user to pay more, but not forbidden)
        'name': 'm42',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 38 * 24 * 60 * 60,
        'usermoney_age': 35 * 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'other',
        'rewardamount': COIN * 10 * 30 // 365,
        'fee_total': '0.01',
        'fee_user_percent': [ 60, 100 ],
        'refill_moneybox': 'random',
        'keys_count_total': randint(3,5),
        'keys_count_required': 3,
        'keys_count_used': 'auto',
        'accepted': True,
    },
    {
        # (reward to other, fee_user_percent == 0%, 35%): rejected (user must pay ~45-49% fee)
        'name': 'm44',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 38 * 24 * 60 * 60,
        'usermoney_age': 35 * 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'other',
        'rewardamount': COIN * 10 * 30 // 365,
        'fee_total': '0.01',
        'fee_user_percent': [ 0, 35 ],
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': False,
        'error': (64, BAD_REWARD_BEN_AMOUNT_TOO_HIGH),
    },
    {
        # (rewardamount = 0): accepted
        'name': 'm45',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 22 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'user',
        'rewardamount': 0,
        'fee_total': '0.01',
        'fee_user_percent': 0,
        'refill_moneybox': ['node', 'script'],
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': True,
    },
    {
        # based on base00, 2 user inputs (useramount + more_useramount1), 2 user outputs (user_outputs_count == 2): accepted
        'name': 'm46',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 22 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': ['user', 'ben', 'other'],
        'rewardamount': COIN * 30 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'more_useramount1': 200 * COIN,
        'user_outputs_dest': 'user+user', # means (user_outputs_count == 2)
        'accepted': True,
    },
    {
        # m46, rewardamount +1 satoshi more than allowed: rejected
        'name': 'm46e',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 22 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': choice(['user', 'ben']),
        'rewardamount': COIN * 30 // 365 + 1,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'more_useramount1': 200 * COIN,
        'user_outputs_dest': 'user+user', # means (user_outputs_count == 2)
        'accepted': False,
        'error': (64, BAD_REWARD_ROBBERY),
    },
    {
        # based on base00, 3 user inputs (more_useramount1 and more_useramount2 are used), 2 user outputs (user_outputs_count == 2): accepted
        'name': 'm47',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 22 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': ['user', 'ben', 'other'],
        'rewardamount': COIN * 60 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'more_useramount1': 300 * COIN,
        'more_useramount2': 200 * COIN,
        'user_outputs_dest': 'user+user', # means (user_outputs_count == 2)
        'accepted': True,
    },
    {
        # m47, rewardamount +1 satoshi more than allowed: rejected
        'name': 'm47e',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 22 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': choice(['user', 'ben']),
        'rewardamount': COIN * 60 // 365 + 1,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'more_useramount1': 300 * COIN,
        'more_useramount2': 200 * COIN,
        'user_outputs_dest': 'user+user', # means (user_outputs_count == 2)
        'accepted': False,
        'error': (64, BAD_REWARD_ROBBERY),
    },
    {
        # based on base00, reward_to ben+other: accepted
        'name': 'm48',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 22 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'more_useramount1': 200 * COIN,
        'reward_to': 'ben+other',
        'rewardamount': COIN * 30 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'user_outputs_dest': 'user+user', # means (user_outputs_count == 2)
        'accepted': True,
    },
    {
        # rewardamount < fee_total: accepted
        'name': 'm49',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 22 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 1 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN // 10 // 365, # less than 0.001
        'fee_total': '0.005',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': True,
    },
    {
        # based on base00, reward_to: 'user+other', 'user+ben+other': accepted
        'name': 'm50',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 22 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'more_useramount1': 200 * COIN,
        'reward_to': [ 'user+other', 'user+ben+other' ],
        'rewardamount': COIN * 30 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 50,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'user_outputs_dest': 'user+user',  # means (user_outputs_count == 2)
        'accepted': True,
    },
    {
        # based on base00, reward_to: 'user+ben: accepted
        'name': 'm51',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 22 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'user+ben',
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': True,
    },
    {
        # based on base00, (keys_count_required is not set, by default keys_count_required == keys_count_total): accepted
        'name': 'm52',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 22 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': choice(['user', 'ben', 'other']),
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': [ 0, None ],
        'keys_count_used': 'auto',
        'accepted': True,
    },
    {
        # m52, (keys_count_used != keys_count_required): rejected
        'name': 'm52e1',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 22 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': choice(['user', 'ben', 'other']),
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': 5,
        'keys_count_required': 3,
        'keys_count_used': [ 1, 2, 4, 5 ],
        'accepted': False,
        'error': (64, BAD_REWARD_SCRIPT),
    },
    {
        # m52, (keys_count_required > keys_count_total): rejected
        'name': 'm52e2',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 22 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': choice(['user', 'ben', 'other']),
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': 5,
        'keys_count_required': 6,
        'keys_count_used': 5,
        'accepted': False,
        'error': (64, BAD_REWARD_SCRIPT),
    },

    #
    # Step2 series: tests with 2 steps of minting, user output of the first step is user input for the second one:
    #
    {
        # (reward_to ben, useramount between steps is without changes): accepted
        'name': 'step2_01',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 22 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'ben',
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': True,
        'step2_enabled': True,
        'step2_wait_interval': 24 * 60 * 60,
        'step2_rewardamount': COIN * 10 // 365,
        'step2_reward_to': choice(['user', 'ben']),
        'step2_accepted': True,
    },
    {
        # step2_01, reward_to ben, step2_rewardamount +1 satoshi more than allowed: rejected
        'name': 'step2_01e',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 22 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'ben',
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': True,
        'step2_enabled': True,
        'step2_wait_interval': 24 * 60 * 60,
        'step2_rewardamount': COIN * 10 // 365 + 1,
        'step2_reward_to': choice(['user', 'ben']),
        'step2_accepted': False,
        'error': (64, BAD_REWARD_ROBBERY),
    },
    {
        # (reward_to user, useramount between steps is accumulated): accepted
        'name': 'step2_02',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 22 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': True,
        'step2_enabled': True,
        'step2_wait_interval': 24 * 60 * 60,
        'step2_rewardamount': (COIN * 10 + COIN // 365) // 365,
        'step2_reward_to': 'user',
        'step2_accepted': True,
    },
    {
        # step2_02, reward_to user, step2_rewardamount +1 satoshi more than allowed: rejected
        'name': 'step2_02e',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 22 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': True,
        'step2_enabled': True,
        'step2_wait_interval': 24 * 60 * 60,
        'step2_rewardamount': (COIN * 10 + COIN // 365) // 365 + 1,
        'step2_reward_to': 'user',
        'step2_accepted': False,
        'error': (64, BAD_REWARD_ROBBERY),
    },

    #
    # L series (Limits): tests with cert expiration date and minting limits:
    #
    {
        # (rewardamount <= ca3_minting_limit): accepted
        'name': 'L01',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 0,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': choice(['user', 'other']),
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'ca3_minting_limit': [ COIN * 10 // 365, COIN * 10 // 365 + 1000 ],
        'accepted': True,
    },
    {
        # (rewardamount > ca3_minting_limit): rejected
        # (ca3_minting_limit <= 0): rejected
        'name': 'L01e',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 0,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': choice(['user', 'other']),
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'ca3_minting_limit': [ COIN * 10 // 365 - 1, 0, -100 ],
        'accepted': False,
        'error': (64, BAD_REWARD_LIMIT_EXCEEDED),
    },
    {
        # sum(rewardamount) <= ca3_minting_limit: accepted
        'name': 'L02',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 0,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'ben',
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'ca3_minting_limit': [ COIN * 10 // 365 * 2, COIN * 10 // 365 * 2 + 1, COIN * 10 // 365 * 200 ],
        'accepted': True,
        'step2_enabled': True,
        'step2_wait_interval': 24 * 60 * 60,
        'step2_rewardamount': COIN * 10 // 365,
        'step2_reward_to': choice(['user', 'ben']),
        'step2_accepted': True,
    },
    {
        # sum(rewardamount) > ca3_minting_limit: rejected
        # Example: minting limit L=100
        # M1=100, M2=50: rejected (M1 + M2 > L) where (M1 == L)
        # M1=60, M2=50: rejected (M1 + M2 > L)
        'name': 'L02e1',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 0,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'ben',
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'ca3_minting_limit': [ COIN * 10 // 365, COIN * 10 // 365 + 1, COIN * 10 // 365 * 2 - 1 ],
        'accepted': True,
        'step2_enabled': True,
        'step2_wait_interval': 24 * 60 * 60,
        'step2_rewardamount': COIN * 10 // 365,
        'step2_reward_to': choice(['user', 'ben']),
        'step2_accepted': False,
        'error': (64, BAD_REWARD_LIMIT_EXCEEDED),
    },
    {
        # last_rewardamount > ca3_minting_limit: rejected
        # Example: minting limit L=100
        # M1=50, M2=150: rejected (M2 > L)
        'name': 'L02e2',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 0,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'ben',
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'ca3_minting_limit': COIN * 10 // 365 * 2,
        'accepted': True,
        'step2_enabled': True,
        'step2_wait_interval': 24 * 3 * 60 * 60,
        'step2_rewardamount': COIN * 10 // 365 * 2 + 1,
        'step2_reward_to': choice(['user', 'ben']),
        'step2_accepted': False,
        'error': (64, BAD_REWARD_LIMIT_EXCEEDED),
    },
    {
        # sum(rewardamount) <= ca3_minting_limit: accepted
        'name': 'L03',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 0,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'ben',
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'ca3_minting_limit': [ COIN * 10 // 365 * 3, COIN * 10 // 365 * 3 + 1, COIN * 10 // 365 * 300 ],
        'accepted': True,
        'step2_enabled': True,
        'step2_wait_interval': 24 * 60 * 60,
        'step2_rewardamount': COIN * 10 // 365,
        'step2_reward_to': 'ben',
        'step2_accepted': True,
        'step3_enabled': True,
        'step3_wait_interval': 24 * 60 * 60,
        'step3_rewardamount': COIN * 10 // 365,
        'step3_reward_to': choice(['user', 'ben']),
        'step3_accepted': True,
    },
    {
        # sum(rewardamount) > ca3_minting_limit: rejected
        'name': 'L03e',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 0,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'ben',
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'ca3_minting_limit': [ COIN * 10 // 365 * 2, COIN * 10 // 365 * 2 + 1, COIN * 10 // 365 * 3 - 1  ],
        'accepted': True,
        'step2_enabled': True,
        'step2_wait_interval': 24 * 60 * 60,
        'step2_rewardamount': COIN * 10 // 365,
        'step2_reward_to': 'ben',
        'step2_accepted': True,
        'step3_enabled': True,
        'step3_wait_interval': 24 * 60 * 60,
        'step3_rewardamount': COIN * 10 // 365,
        'step3_reward_to': choice(['user', 'ben']),
        'step3_accepted': False,
        'error': (64, BAD_REWARD_LIMIT_EXCEEDED),
    },
    {
        # (ca3_block_timestamp + ca3_expiration_offset + 23h > mint_tx_time): accepted
        'name': 'L04',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 24 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': choice(['user', 'other']),
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'ca3_expiration_offset': 3600 + 120,
        'accepted': True,
    },
    {
        # (ca3_block_timestamp + ca3_expiration_offset + 23h < mint_tx_time): rejected
        'name': 'L04e',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 24 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': choice(['user', 'other']),
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'ca3_expiration_offset': [3600 - 30, 0, -100],
        'accepted': False,
        'error': (64, BAD_REWARD_CERT_EXPIRED),
    },
    {
        # step2: (ca3_block_timestamp + ca3_expiration_offset + 23h > mint_tx_time): accepted
        'name': 'L05',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 24 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'ben',
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'ca3_expiration_offset': 3600 * 25 + 120,
        'accepted': True,
        'step2_enabled': True,
        'step2_wait_interval': 24 * 60 * 60,
        'step2_rewardamount': COIN * 10 // 365,
        'step2_reward_to': choice(['user', 'ben']),
        'step2_accepted': True,
    },
    {
        # step2: (ca3_block_timestamp + ca3_expiration_offset + 23h < mint_tx_time): rejected
        'name': 'L05e',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 24 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'ben',
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'ca3_expiration_offset': 3600 * 25 - 30,
        'accepted': True,
        'step2_enabled': True,
        'step2_wait_interval': 24 * 60 * 60,
        'step2_rewardamount': COIN * 10 // 365,
        'step2_reward_to': choice(['user', 'ben']),
        'step2_accepted': False,
        'error': (64, BAD_REWARD_CERT_EXPIRED),
    },
    {
        # (rewardamount <= ca3_minting_limit && ca3_block_timestamp + ca3_expiration_offset + 23h > mint_tx_time): accepted
        'name': 'L06',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 0,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': choice(['user', 'other']),
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'ca3_minting_limit': COIN * 1000,
        'ca3_expiration_offset': 120,
        'accepted': True,
    },
    {
        # sum(allowed_rewardamount) > ca3_minting_limit and sum(actual_rewardamount) <= ca3_minting_limit: accepted
        # allowed_rewardamount: COIN * 10 // 365,
        'name': 'L07',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 0,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'ben',
        'rewardamount': [COIN * 10 // 365 - 10000, COIN * 10 // 365 - 20000],
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1, 15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'ca3_minting_limit': COIN * 10 // 365 - 10000,
        'accepted': True,
    },

    #
    # E (error) series:
    #
    {
        # (revoke_root_cert): rejected
        'name': 'e00',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 24 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'ben',
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'revoke_root_cert': True,
        'accepted': False,
        'error': (64, BAD_REWARD_ZERO_REPCENT),
    },
    {
        # (revoke_user_cert): rejected
        'name': 'e01',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 24 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'ben',
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'revoke_user_cert': True,
        'accepted': False,
        'error': (64, BAD_REWARD_ZERO_REPCENT),
    },
    {
        # (invalid_root_cert_ref, scenarios 1-6): rejected
        'name': 'e02',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 24 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'ben',
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'invalid_root_cert_ref': [ 1, 2, 3, 4, 5, 6 ],
        'accepted': False,
        'error': (64, BAD_REWARD_ZERO_REPCENT),
    },
    {
        # (invalid_user_cert_ref, scenarios 1-4): rejected
        'name': 'e03',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 24 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'ben',
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'invalid_user_cert_ref': [ 1, 2, 3, 4 ],
        'accepted': False,
        'error': (64, BAD_REWARD_ZERO_REPCENT),
    },
    {
        # (invalid_user_cert_ref, scenario 5): rejected
        'name': 'e03A',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 24 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'ben',
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'random',
        'keys_count_total': randint(1, 15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'invalid_user_cert_ref': 5,
        'accepted': False,
        'error': (64, BAD_REWARD_SCRIPT),
    },
    {
        # (based on m33A, invalid_refill_moneybox, scenarios 1-5): minting is accepted, refill_moneybox is rejected
        'name': 'e04',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': False,
        'ca3_age': 38 * 24 * 60 * 60,
        'usermoney_age': 35 * 24 * 60 * 60,
        'useramount': 5000 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 500 * 30 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'script',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'invalid_refill_moneybox': [ 1, 2, 3, 4, 5 ],
        'accepted': True,
        'refill_moneybox_accepted': False,
    },
    {
        # (based on m33A, refill_moneybox_dest): minting is accepted, refill_moneybox is rejected
        'name': 'e04A',
        'rootcertamount': 1 * COIN,
        'greenflag': False,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 38 * 24 * 60 * 60,
        'usermoney_age': 35 * 24 * 60 * 60,
        'useramount': 5000 * COIN,
        'reward_to': 'user',
        'rewardamount': COIN * 500 * 30 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 0,
        'refill_moneybox': 'script',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'refill_moneybox_dest': [ 'user', 'ben', 'other', 'other_p2sh', 'op_true', 'op_false' ],
        'accepted': True,
        'refill_moneybox_accepted': False,
    },
    {
        # (based on base00, moneybox_outputs_count == 2): rejected
        'name': 'e05',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 22 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': ['user', 'ben', 'other'],
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'moneybox_change_dest': 'moneybox+moneybox', # means (moneybox_outputs_count == 2)
        'accepted': False,
        'error': (64, BAD_REWARD_MANY_MONEYBOX_OUTPUTS),
    },
    {
        # (based on base00, user_outputs_count == 2, more than user inputs): rejected
        'name': 'e06',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 22 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': ['user', 'ben', 'other'],
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'user_outputs_dest': 'user+user', # means (user_outputs_count == 2)
        'accepted': False,
        'error': (64, BAD_REWARD_MANY_USER_OUTPUTS),
    },
    {
        # based on base00, user_inputs_count == 2 (useramount + more_useramount1), user_outputs_count == 3, more than user inputs: rejected
        'name': 'e07',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 22 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': choice(['user', 'ben', 'other']),
        'rewardamount': COIN * 30 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'more_useramount2': 200 * COIN,
        'user_outputs_dest': 'user+user+user', # means (user_outputs_count == 3)
        'accepted': False,
        'error': (64, BAD_REWARD_MANY_USER_OUTPUTS),
    },
    {
        # based on base00, moneybox_change_dest == [forbidden combinations]: rejected
        'name': 'e08',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 22 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'more_useramount1': 100 * COIN,  # to avoid error BAD_REWARD_MANY_USER_OUTPUTS for (moneybox_change_dest == 'user')
        'reward_to': 'user',             # to avoid error BAD_REWARD_MANY_BEN_OUTPUTS for (moneybox_change_dest to ben/other)
        'rewardamount': COIN * 10 // 365 * 2,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'moneybox_change_dest': [ 'user', 'ben', 'other_p2pkh', 'other_p2sh', 'op_true', 'op_false', 'user+ben', 'moneybox+op_false' ],
        'accepted': False,
        'error': (64, BAD_REWARD_ROBBERY),
    },
    {
        # based on base00, reward to ben/other and moneybox_change_dest to ben/other: rejected
        'name': 'e08A',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 22 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': ['ben', 'other'],
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1, 15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'moneybox_change_dest': [ 'ben', 'other_p2pkh', 'other_p2sh' ],
        'accepted': False,
        'error': (64, BAD_REWARD_MANY_BEN_OUTPUTS),
    },
    {
        # based on base00, moneybox_outputs_count == 0 (don't return change to moneybox, leave 1/2 of it to miner): accepted
        'name': 'e09',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 22 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': ['user', 'ben'],
        'rewardamount': COIN * 10 // 365,
        'fee_total': '0.01',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'script',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'moneybox_change_dest': '',
        'accepted': True,
        'refill_moneybox_accepted': False,
    },
    {
        # based on base00, moneybox_outputs_count == 0 (don't return change to moneybox, leave 1/2 of it to miner),
        # but when reward_to 'other' - rejected
        'name': 'e09A',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 22 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': 'other',
        'rewardamount': COIN * 10 // 365,
        'fee_total': '0.01',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'moneybox_change_dest': '',
        'accepted': False,
    },
    {
        # based on base00, extra_moneybox_inputs_count == 1: rejected
        'name': 'e10',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 22 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': choice(['user', 'ben', 'other']),
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'extra_moneybox_inputs_count': 1,
        'moneybox_change_dest': 'moneybox',
        'accepted': False,
        'error': (16, 'bad-txns-moneybox-value-toolarge'),
    },
    {
        # based on base00, extra_moneybox_inputs_count == 1: rejected
        'name': 'e10A',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 22 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': choice(['user', 'ben', 'other']),
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1, 15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'extra_moneybox_inputs_count': 1,
        'moneybox_change_dest': 'moneybox+moneybox',
        'accepted': False,
        'error': (64, BAD_REWARD_MANY_MONEYBOX_INPUTS),
    },
    {
        # based on base00, different forbidden combinations for user_outputs_dest: rejected
        'name': 'e11',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 22 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': choice(['user', 'ben', 'other']),
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'user_outputs_dest': [ 'moneybox', 'ben', 'other_p2pkh', 'other_p2sh', 'op_true', 'op_false', 'user+moneybox', 'user+ben', 'user+other', '' ],
        'accepted': False,
    },
    {
        # based on base00, both (user_outputs_dest and moneybox_change_dest) == nothing: rejected
        'name': 'e12',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 22 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': choice(['ben', 'other']),
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'user_outputs_dest': '',
        'moneybox_change_dest': '',
        'accepted': False,
        # error: 'non-mandatory-script-verify-flag (unknown error)'
    },
    {
        # based on base00, forbidden user_outputs_dest combinations: rejected
        'name': 'e14',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 22 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': ['user', 'ben'],
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(2,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'user_outputs_dest': ['user_shuffled', 'user_pure_multisig'],
        'accepted': False,
        # error:
        #   for (reward_to == user): 'non-mandatory-script-verify-flag (unknown error)'
        #   for (reward_to == ben): BAD_REWARD_MANY_BEN_OUTPUTS
    },
    {
        # based on base00, reward_outputs > user_outputs: rejected
        'name': 'e15',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 22 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'reward_to': [ 'ben+ben', 'other+other', 'ben+other' ],
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'accepted': False,
        'error': (64, BAD_REWARD_MANY_BEN_OUTPUTS)
    },

    #
    # Special series:
    #
    {
        # minting_limit is checked always, but is applied only when generating a block;
        # so many transactions less or equal to limit each will be accepted to mempool and they all will enter a block
        # Testcase: send one by one 3 transactions with minted amount equal to minting limit,
        # and generate a new block after it. Summary minting limit is exceeded, but they
        # all will be included into this block, because limit is applied only when generating a new block.
        # [accepted]
        'name': 'special_minting_limit_mempool',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 24 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'more_useramount1': 100 * COIN,
        'more_useramount2': 100 * COIN,
        'reward_to': choice(['user', 'ben']),
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'random',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'ca3_minting_limit': COIN * 10 // 365,
        'accepted': True,
    },
    {
        # [accepted]
        'name': 'special_minting_limit_fork_blocks',
        'rootcertamount': 1 * COIN,
        'greenflag': True,
        'ca3certamount': 1000000,
        'ben_enabled': True,
        'ca3_age': 24 * 60 * 60,
        'usermoney_age': 24 * 60 * 60,
        'useramount': 100 * COIN,
        'more_useramount1': 100 * COIN,
        'more_useramount2': 100 * COIN,
        'reward_to': choice(['user', 'ben']),
        'rewardamount': COIN * 10 // 365,
        'fee_total': 'auto',
        'fee_user_percent': 'auto',
        'refill_moneybox': 'script',
        'keys_count_total': randint(1,15),
        'keys_count_required': 'random',
        'keys_count_used': 'auto',
        'ca3_minting_limit': COIN * 10 // 365 * 2,
        'accepted': True,
    }
]


testcases_map = {}

def expand_parameter(testcases_array, t, param_name):
    if param_name in t and isinstance(t[param_name], list):
        assert (param_name != 'name')  # name cannot be expanded
        for v in t[param_name]:
            t2 = copy.deepcopy(t)
            t2[param_name] = v
            t2['name'] += ('_' + param_name + '_' + str(v))
            expand_testcase(testcases_array, t2)
        return True
    return False

def expand_testcase(testcases_array, t):
    expanded = False
    keys = [*t]
    keys.sort()
    for param in keys:
        if expand_parameter(testcases_array, t, param):
            expanded = True
            break
    if not expanded:
        testcases_array.append(t)

def get_minting_testcases():
    global testcases_map
    if len(testcases_map) > 0:
        return testcases_map
    testcases_array = []
    for t in testcases_templates:
        expand_testcase(testcases_array, t)
    for t in testcases_array:
        if t['name'] in testcases_map:
            raise AssertionError('Duplicated name in testcases: {}'.format(t['name']))
        testcases_map[t['name']] = t
    return testcases_map