def validate(db, source, timestamp, value, fee_fraction_int, text,
block_index):
problems = []
# For SQLite3
if timestamp > config.MAX_INT or value > config.MAX_INT or fee_fraction_int > config.MAX_INT:
problems.append('integer overflow')
if util.enabled('max_fee_fraction'):
if fee_fraction_int >= config.UNIT:
problems.append('fee fraction greater than or equal to 1')
else:
if fee_fraction_int > 4294967295:
problems.append('fee fraction greater than 42.94967295')
if timestamp < 0: problems.append('negative timestamp')
if not source:
problems.append('null source address')
# Check previous broadcast in this feed.
cursor = db.cursor()
broadcasts = list(
cursor.execute(
'''SELECT * FROM broadcasts WHERE (status = ? AND source = ?) ORDER BY tx_index ASC''',
('valid', source)))
cursor.close()
if broadcasts:
last_broadcast = broadcasts[-1]
if last_broadcast['locked']:
problems.append('locked feed')
elif timestamp <= last_broadcast['timestamp']:
problems.append('feed timestamps not monotonically increasing')
if not (block_index >= 317500 or config.TESTNET
or config.REGTEST): # Protocol change.
if len(text) > 52:
problems.append('text too long')
if util.enabled('options_require_memo') and text and text.lower(
).startswith('options'):
try:
# Check for options and if they are valid.
options = util.parse_options_from_string(text)
if options is not False:
util.validate_address_options(options)
except exceptions.OptionsError as e:
problems.append(str(e))
return problems
def parse(db, tx, message):
cursor = db.cursor()
# Unpack message.
status = 'valid' # might be invalidate later.
try:
if util.enabled('broadcast_pack_text', tx['block_index']):
timestamp, value, fee_fraction_int, rawtext = struct.unpack(
FORMAT + '{}s'.format(len(message) - LENGTH), message)
textlen = VarIntSerializer.deserialize(rawtext)
if textlen == 0:
text = b''
else:
text = rawtext[-textlen:]
if len(text) != textlen:
status = 'invalid: text length mismatch'
else:
if len(message) - LENGTH <= 52:
curr_format = FORMAT + '{}p'.format(len(message) - LENGTH)
else:
curr_format = FORMAT + '{}s'.format(len(message) - LENGTH)
timestamp, value, fee_fraction_int, text = struct.unpack(
curr_format, message)
try:
text = text.decode('utf-8')
except UnicodeDecodeError:
text = ''
except (struct.error) as e:
timestamp, value, fee_fraction_int, text = 0, None, 0, None
status = 'invalid: could not unpack'
if status == 'valid':
# For SQLite3
timestamp = min(timestamp, config.MAX_INT)
value = min(value, config.MAX_INT)
problems = validate(db, tx['source'], timestamp, value,
fee_fraction_int, text, tx['block_index'])
if problems: status = 'invalid: ' + '; '.join(problems)
# Lock?
lock = False
if text and text.lower() == 'lock':
lock = True
timestamp, value, fee_fraction_int, text = 0, None, None, None
else:
lock = False
# Add parsed transaction to message-type–specific table.
bindings = {
'tx_index': tx['tx_index'],
'tx_hash': tx['tx_hash'],
'block_index': tx['block_index'],
'source': tx['source'],
'timestamp': timestamp,
'value': value,
'fee_fraction_int': fee_fraction_int,
'text': text,
'locked': lock,
'status': status,
}
if "integer overflow" not in status:
sql = 'insert into broadcasts values(:tx_index, :tx_hash, :block_index, :source, :timestamp, :value, :fee_fraction_int, :text, :locked, :status)'
cursor.execute(sql, bindings)
else:
logger.warn("Not storing [broadcast] tx [%s]: %s" %
(tx['tx_hash'], status))
logger.debug("Bindings: %s" % (json.dumps(bindings), ))
# stop processing if broadcast is invalid for any reason
if util.enabled('broadcast_invalid_check') and status != 'valid':
return
# Options? Should not fail to parse due to above checks.
if util.enabled('options_require_memo') and text and text.lower(
).startswith('options'):
options = util.parse_options_from_string(text)
if options is not False:
op_bindings = {
'block_index': tx['block_index'],
'address': tx['source'],
'options': options
}
sql = 'insert or replace into addresses(address, options, block_index) values(:address, :options, :block_index)'
cursor = db.cursor()
cursor.execute(sql, op_bindings)
# Negative values (default to ignore).
if value is None or value < 0:
# Cancel Open Bets?
if value == -2:
cursor.execute(
'''SELECT * FROM bets \
WHERE (status = ? AND feed_address = ?)''',
('open', tx['source']))
for i in list(cursor):
bet.cancel_bet(db, i, 'dropped', tx['block_index'])
# Cancel Pending Bet Matches?
if value == -3:
cursor.execute(
'''SELECT * FROM bet_matches \
WHERE (status = ? AND feed_address = ?)''',
('pending', tx['source']))
for bet_match in list(cursor):
bet.cancel_bet_match(db, bet_match, 'dropped',
tx['block_index'])
cursor.close()
return
# stop processing if broadcast is invalid for any reason
# @TODO: remove this check once broadcast_invalid_check has been activated
if util.enabled('max_fee_fraction') and status != 'valid':
return
# Handle bet matches that use this feed.
cursor.execute(
'''SELECT * FROM bet_matches \
WHERE (status=? AND feed_address=?)
ORDER BY tx1_index ASC, tx0_index ASC''',
('pending', tx['source']))
for bet_match in cursor.fetchall():
broadcast_bet_match_cursor = db.cursor()
bet_match_id = util.make_id(bet_match['tx0_hash'],
bet_match['tx1_hash'])
bet_match_status = None
# Calculate total funds held in escrow and total fee to be paid if
# the bet match is settled. Escrow less fee is amount to be paid back
# to betters.
total_escrow = bet_match['forward_quantity'] + bet_match[
'backward_quantity']
if util.enabled('inmutable_fee_fraction'):
fee_fraction = bet_match['fee_fraction_int'] / config.UNIT
else:
fee_fraction = fee_fraction_int / config.UNIT
fee = int(fee_fraction * total_escrow) # Truncate.
escrow_less_fee = total_escrow - fee
# Get known bet match type IDs.
cfd_type_id = util.BET_TYPE_ID['BullCFD'] + util.BET_TYPE_ID['BearCFD']
equal_type_id = util.BET_TYPE_ID['Equal'] + util.BET_TYPE_ID['NotEqual']
# Get the bet match type ID of this bet match.
bet_match_type_id = bet_match['tx0_bet_type'] + bet_match[
'tx1_bet_type']
# Contract for difference, with determinate settlement date.
if bet_match_type_id == cfd_type_id:
# Recognise tx0, tx1 as the bull, bear (in the right direction).
if bet_match['tx0_bet_type'] < bet_match['tx1_bet_type']:
bull_address = bet_match['tx0_address']
bear_address = bet_match['tx1_address']
bull_escrow = bet_match['forward_quantity']
bear_escrow = bet_match['backward_quantity']
else:
bull_address = bet_match['tx1_address']
bear_address = bet_match['tx0_address']
bull_escrow = bet_match['backward_quantity']
bear_escrow = bet_match['forward_quantity']
leverage = Fraction(bet_match['leverage'], 5040)
initial_value = bet_match['initial_value']
bear_credit = bear_escrow - (
value - initial_value) * leverage * config.UNIT
bull_credit = escrow_less_fee - bear_credit
bear_credit = round(bear_credit)
bull_credit = round(bull_credit)
# Liquidate, as necessary.
if bull_credit >= escrow_less_fee or bull_credit <= 0:
if bull_credit >= escrow_less_fee:
bull_credit = escrow_less_fee
bear_credit = 0
bet_match_status = 'settled: liquidated for bull'
util.credit(db,
bull_address,
config.XCP,
bull_credit,
action='bet {}'.format(bet_match_status),
event=tx['tx_hash'])
elif bull_credit <= 0:
bull_credit = 0
bear_credit = escrow_less_fee
bet_match_status = 'settled: liquidated for bear'
util.credit(db,
bear_address,
config.XCP,
bear_credit,
action='bet {}'.format(bet_match_status),
event=tx['tx_hash'])
# Pay fee to feed.
util.credit(db,
bet_match['feed_address'],
config.XCP,
fee,
action='feed fee',
event=tx['tx_hash'])
# For logging purposes.
bindings = {
'bet_match_id': bet_match_id,
'bet_match_type_id': bet_match_type_id,
'block_index': tx['block_index'],
'settled': False,
'bull_credit': bull_credit,
'bear_credit': bear_credit,
'winner': None,
'escrow_less_fee': None,
'fee': fee
}
sql = 'insert into bet_match_resolutions values(:bet_match_id, :bet_match_type_id, :block_index, :settled, :bull_credit, :bear_credit, :winner, :escrow_less_fee, :fee)'
cursor.execute(sql, bindings)
# Settle (if not liquidated).
elif timestamp >= bet_match['deadline']:
bet_match_status = 'settled'
util.credit(db,
bull_address,
config.XCP,
bull_credit,
action='bet {}'.format(bet_match_status),
event=tx['tx_hash'])
util.credit(db,
bear_address,
config.XCP,
bear_credit,
action='bet {}'.format(bet_match_status),
event=tx['tx_hash'])
# Pay fee to feed.
util.credit(db,
bet_match['feed_address'],
config.XCP,
fee,
action='feed fee',
event=tx['tx_hash'])
# For logging purposes.
bindings = {
'bet_match_id': bet_match_id,
'bet_match_type_id': bet_match_type_id,
'block_index': tx['block_index'],
'settled': True,
'bull_credit': bull_credit,
'bear_credit': bear_credit,
'winner': None,
'escrow_less_fee': None,
'fee': fee
}
sql = 'insert into bet_match_resolutions values(:bet_match_id, :bet_match_type_id, :block_index, :settled, :bull_credit, :bear_credit, :winner, :escrow_less_fee, :fee)'
cursor.execute(sql, bindings)
# Equal[/NotEqual] bet.
elif bet_match_type_id == equal_type_id and timestamp >= bet_match[
'deadline']:
# Recognise tx0, tx1 as the bull, bear (in the right direction).
if bet_match['tx0_bet_type'] < bet_match['tx1_bet_type']:
equal_address = bet_match['tx0_address']
notequal_address = bet_match['tx1_address']
else:
equal_address = bet_match['tx1_address']
notequal_address = bet_match['tx0_address']
# Decide who won, and credit appropriately.
if value == bet_match['target_value']:
winner = 'Equal'
bet_match_status = 'settled: for equal'
util.credit(db,
equal_address,
config.XCP,
escrow_less_fee,
action='bet {}'.format(bet_match_status),
event=tx['tx_hash'])
else:
winner = 'NotEqual'
bet_match_status = 'settled: for notequal'
util.credit(db,
notequal_address,
config.XCP,
escrow_less_fee,
action='bet {}'.format(bet_match_status),
event=tx['tx_hash'])
# Pay fee to feed.
util.credit(db,
bet_match['feed_address'],
config.XCP,
fee,
action='feed fee',
event=tx['tx_hash'])
# For logging purposes.
bindings = {
'bet_match_id': bet_match_id,
'bet_match_type_id': bet_match_type_id,
'block_index': tx['block_index'],
'settled': None,
'bull_credit': None,
'bear_credit': None,
'winner': winner,
'escrow_less_fee': escrow_less_fee,
'fee': fee
}
sql = 'insert into bet_match_resolutions values(:bet_match_id, :bet_match_type_id, :block_index, :settled, :bull_credit, :bear_credit, :winner, :escrow_less_fee, :fee)'
cursor.execute(sql, bindings)
# Update the bet match’s status.
if bet_match_status:
bindings = {
'status':
bet_match_status,
'bet_match_id':
util.make_id(bet_match['tx0_hash'], bet_match['tx1_hash'])
}
sql = 'update bet_matches set status = :status where id = :bet_match_id'
cursor.execute(sql, bindings)
log.message(db, tx['block_index'], 'update', 'bet_matches',
bindings)
broadcast_bet_match_cursor.close()
cursor.close()