def parse (db, tx, message):
status = 'valid'
try:
asset, quantity = unpack(message)
validate(db, tx['source'], tx['destination'], asset, quantity, tx['block_index'])
util.debit(db, tx['block_index'], tx['source'], asset, quantity, 'destroy', tx['tx_hash'])
except UnpackError as e:
asset, quantity = None, None
status = 'invalid: ' + ''.join(e.args)
except ValidateError as e:
status = 'invalid: ' + ''.join(e.args)
finally:
bindings = {
'tx_index': tx['tx_index'],
'tx_hash': tx['tx_hash'],
'block_index': tx['block_index'],
'source': tx['source'],
'asset': asset,
'quantity': quantity,
'tag': tag,
'status': status,
}
sql='insert into destructions values(:tx_index, :tx_hash, :block_index, :source, :asset, :quantity, :tag, :status)'
cursor = db.cursor()
cursor.execute(sql, bindings)
def parse(db, tx, message):
status = 'valid'
try:
asset, quantity = unpack(message)
validate(db, tx['source'], tx['destination'], asset, quantity,
tx['block_index'])
util.debit(db, tx['block_index'], tx['source'], asset, quantity,
'destroy', tx['tx_hash'])
except UnpackError as e:
asset, quantity = None, None
status = 'invalid: ' + ''.join(e.args)
except (ValidateError, BalanceError) as e:
status = 'invalid: ' + ''.join(e.args)
finally:
bindings = {
'tx_index': tx['tx_index'],
'tx_hash': tx['tx_hash'],
'block_index': tx['block_index'],
'source': tx['source'],
'asset': asset,
'quantity': quantity,
'tag': tag,
'status': status,
}
sql = 'insert into destructions values(:tx_index, :tx_hash, :block_index, :source, :asset, :quantity, :tag, :status)'
cursor = db.cursor()
cursor.execute(sql, bindings)
def parse (db, tx, message):
dividend_parse_cursor = db.cursor()
# Unpack message.
try:
if (tx['block_index'] > 288150 or config.TESTNET) and len(message) == LENGTH_2:
quantity_per_unit, asset_id, dividend_asset_id = struct.unpack(FORMAT_2, message)
asset = util.get_asset_name(asset_id, tx['block_index'])
dividend_asset = util.get_asset_name(dividend_asset_id, tx['block_index'])
status = 'valid'
elif len(message) == LENGTH_1:
quantity_per_unit, asset_id = struct.unpack(FORMAT_1, message)
asset = util.get_asset_name(asset_id, tx['block_index'])
dividend_asset = config.XCP
status = 'valid'
else:
raise exceptions.UnpackError
except (exceptions.UnpackError, exceptions.AssetNameError, struct.error) as e:
dividend_asset, quantity_per_unit, asset = None, None, None
status = 'invalid: could not unpack'
if dividend_asset == config.BTC:
status = 'invalid: cannot pay {} dividends within protocol'.format(config.BTC)
if status == 'valid':
# For SQLite3
quantity_per_unit = min(quantity_per_unit, config.MAX_INT)
dividend_total, outputs, problems, fee = validate(db, tx['source'], quantity_per_unit, asset, dividend_asset, block_index=tx['block_index'])
if problems: status = 'invalid: ' + '; '.join(problems)
if status == 'valid':
# Debit.
util.debit(db, tx['block_index'], tx['source'], dividend_asset, dividend_total, action='dividend', event=tx['tx_hash'])
if tx['block_index'] >= 330000 or config.TESTNET: # Protocol change.
util.debit(db, tx['block_index'], tx['source'], config.XCP, fee, action='dividend fee', event=tx['tx_hash'])
# Credit.
for output in outputs:
util.credit(db, tx['block_index'], output['address'], dividend_asset, output['dividend_quantity'], action='dividend', event=tx['tx_hash'])
# 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'],
'asset': asset,
'dividend_asset': dividend_asset,
'quantity_per_unit': quantity_per_unit,
'fee_paid': fee,
'status': status,
}
sql='insert into dividends values(:tx_index, :tx_hash, :block_index, :source, :asset, :dividend_asset, :quantity_per_unit, :fee_paid, :status)'
dividend_parse_cursor.execute(sql, bindings)
dividend_parse_cursor.close()
def parse (db, tx, message):
dividend_parse_cursor = db.cursor()
# Unpack message.
try:
if (tx['block_index'] > 288150 or config.TESTNET) and len(message) == LENGTH_2:
quantity_per_unit, asset_id, dividend_asset_id = struct.unpack(FORMAT_2, message)
asset = util.get_asset_name(db, asset_id, tx['block_index'])
dividend_asset = util.get_asset_name(db, dividend_asset_id, tx['block_index'])
status = 'valid'
elif len(message) == LENGTH_1:
quantity_per_unit, asset_id = struct.unpack(FORMAT_1, message)
asset = util.get_asset_name(db, asset_id, tx['block_index'])
dividend_asset = config.XCP
status = 'valid'
else:
raise exceptions.UnpackError
except (exceptions.UnpackError, exceptions.AssetNameError, struct.error) as e:
dividend_asset, quantity_per_unit, asset = None, None, None
status = 'invalid: could not unpack'
if dividend_asset == config.BTC:
status = 'invalid: cannot pay {} dividends within protocol'.format(config.BTC)
if status == 'valid':
# For SQLite3
quantity_per_unit = min(quantity_per_unit, config.MAX_INT)
dividend_total, outputs, problems, fee = validate(db, tx['source'], quantity_per_unit, asset, dividend_asset, block_index=tx['block_index'])
if problems: status = 'invalid: ' + '; '.join(problems)
if status == 'valid':
# Debit.
util.debit(db, tx['block_index'], tx['source'], dividend_asset, dividend_total, action='dividend', event=tx['tx_hash'])
if tx['block_index'] >= 330000 or config.TESTNET: # Protocol change.
util.debit(db, tx['block_index'], tx['source'], config.XCP, fee, action='dividend fee', event=tx['tx_hash'])
# Credit.
for output in outputs:
util.credit(db, tx['block_index'], output['address'], dividend_asset, output['dividend_quantity'], action='dividend', event=tx['tx_hash'])
# 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'],
'asset': asset,
'dividend_asset': dividend_asset,
'quantity_per_unit': quantity_per_unit,
'fee_paid': fee,
'status': status,
}
sql='insert into dividends values(:tx_index, :tx_hash, :block_index, :source, :asset, :dividend_asset, :quantity_per_unit, :fee_paid, :status)'
dividend_parse_cursor.execute(sql, bindings)
dividend_parse_cursor.close()
def expire (db, block_index):
cursor = db.cursor()
# Expire rps and give refunds for the quantity wager.
cursor.execute('''SELECT * FROM rps WHERE (status = ? AND expire_index < ?)''', ('open', block_index))
for rps in cursor.fetchall():
cancel_rps(db, rps, 'expired', block_index)
# Record rps expiration.
bindings = {
'rps_index': rps['tx_index'],
'rps_hash': rps['tx_hash'],
'source': rps['source'],
'block_index': block_index
}
sql = '''INSERT INTO rps_expirations VALUES (:rps_index, :rps_hash, :source, :block_index)'''
cursor.execute(sql, bindings)
# Expire rps matches
expire_bindings = ('pending', 'pending and resolved', 'resolved and pending', block_index)
cursor.execute('''SELECT * FROM rps_matches WHERE (status IN (?, ?, ?) AND match_expire_index < ?)''', expire_bindings)
for rps_match in cursor.fetchall():
new_rps_match_status = 'expired'
# pending loses against resolved
if rps_match['status'] == 'pending and resolved':
new_rps_match_status = 'concluded: second player wins'
elif rps_match['status'] == 'resolved and pending':
new_rps_match_status = 'concluded: first player wins'
update_rps_match_status(db, rps_match, new_rps_match_status, block_index)
# Record rps match expiration.
bindings = {
'rps_match_id': rps_match['id'],
'tx0_address': rps_match['tx0_address'],
'tx1_address': rps_match['tx1_address'],
'block_index': block_index
}
sql = '''INSERT INTO rps_match_expirations VALUES (:rps_match_id, :tx0_address, :tx1_address, :block_index)'''
cursor.execute(sql, bindings)
# Rematch not expired and not resolved RPS
if new_rps_match_status == 'expired':
sql = '''SELECT * FROM rps WHERE tx_hash IN (?, ?) AND status = ? AND expire_index >= ?'''
bindings = (rps_match['tx0_hash'], rps_match['tx1_hash'], 'matched', block_index)
matched_rps = list(cursor.execute(sql, bindings))
for rps in matched_rps:
cursor.execute('''UPDATE rps SET status = ? WHERE tx_index = ?''', ('open', rps['tx_index']))
# Re-debit XCP refund by close_rps_match.
util.debit(db, block_index, rps['source'], 'XCP', rps['wager'], action='reopen RPS after matching expiration', event=rps_match['id'])
# Rematch
match(db, {'tx_index': rps['tx_index']}, block_index)
cursor.close()
def parse(db, tx, message):
rps_parse_cursor = db.cursor()
# Unpack message.
try:
if len(message) != LENGTH:
raise exceptions.UnpackError
(possible_moves, wager, move_random_hash, expiration) = struct.unpack(FORMAT, message)
status = 'open'
except (exceptions.UnpackError, struct.error):
(possible_moves, wager, move_random_hash, expiration) = 0, 0, '', 0
status = 'invalid: could not unpack'
if status == 'open':
move_random_hash = binascii.hexlify(move_random_hash).decode('utf8')
# Overbet
rps_parse_cursor.execute('''SELECT * FROM balances \
WHERE (address = ? AND asset = ?)''', (tx['source'], 'XCP'))
balances = list(rps_parse_cursor)
if not balances:
wager = 0
else:
balance = balances[0]['quantity']
if balance < wager:
wager = balance
problems = validate(db, tx['source'], possible_moves, wager, move_random_hash, expiration, tx['block_index'])
if problems: status = 'invalid: {}'.format(', '.join(problems))
# Debit quantity wagered. (Escrow.)
if status == 'open':
util.debit(db, tx['block_index'], tx['source'], 'XCP', wager, action="open RPS", event=tx['tx_hash'])
# 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'],
'possible_moves': possible_moves,
'wager': wager,
'move_random_hash': move_random_hash,
'expiration': expiration,
'expire_index': tx['block_index'] + expiration,
'status': status,
}
sql = '''INSERT INTO rps VALUES (:tx_index, :tx_hash, :block_index, :source, :possible_moves, :wager, :move_random_hash, :expiration, :expire_index, :status)'''
rps_parse_cursor.execute(sql, bindings)
# Match.
if status == 'open':
match(db, tx, tx['block_index'])
rps_parse_cursor.close()
def parse (db, tx, message):
callback_parse_cursor = db.cursor()
# Unpack message.
try:
if len(message) != LENGTH:
raise exceptions.UnpackError
fraction, asset_id = struct.unpack(FORMAT, message)
asset = util.get_asset_name(asset_id, tx['block_index'])
status = 'valid'
except (exceptions.UnpackError, exceptions.AssetNameError, struct.error) as e:
fraction, asset = None, None
status = 'invalid: could not unpack'
if status == 'valid':
call_price, callback_total, outputs, problems = validate(db, tx['source'], fraction, asset, tx['block_time'], tx['block_index'], parse=True)
if problems: status = 'invalid: ' + '; '.join(problems)
if status == 'valid':
# Issuer.
assert call_price * callback_total == int(call_price * callback_total)
util.debit(db, tx['block_index'], tx['source'], config.XCP, int(call_price * callback_total), action='callback', event=tx['tx_hash'])
util.credit(db, tx['block_index'], tx['source'], asset, callback_total, action='callback', event=tx['tx_hash'])
# Holders.
for output in outputs:
assert call_price * output['callback_quantity'] == int(call_price * output['callback_quantity'])
util.debit(db, tx['block_index'], output['address'], asset, output['callback_quantity'], action='callback', event=tx['tx_hash'])
util.credit(db, tx['block_index'], output['address'], config.XCP, int(call_price * output['callback_quantity']), action='callback', event=tx['tx_hash'])
# 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'],
'fraction': fraction,
'asset': asset,
'status': status,
}
sql='insert into callbacks values(:tx_index, :tx_hash, :block_index, :source, :fraction, :asset, :status)'
callback_parse_cursor.execute(sql, bindings)
callback_parse_cursor.close()
def parse (db, tx, message):
callback_parse_cursor = db.cursor()
# Unpack message.
try:
if len(message) != LENGTH:
raise exceptions.UnpackError
fraction, asset_id = struct.unpack(FORMAT, message)
asset = util.get_asset_name(db, asset_id, tx['block_index'])
status = 'valid'
except (exceptions.UnpackError, exceptions.AssetNameError, struct.error) as e:
fraction, asset = None, None
status = 'invalid: could not unpack'
if status == 'valid':
call_price, callback_total, outputs, problems = validate(db, tx['source'], fraction, asset, tx['block_time'], tx['block_index'], parse=True)
if problems: status = 'invalid: ' + '; '.join(problems)
if status == 'valid':
# Issuer.
assert call_price * callback_total == int(call_price * callback_total)
util.debit(db, tx['block_index'], tx['source'], config.XCP, int(call_price * callback_total), action='callback', event=tx['tx_hash'])
util.credit(db, tx['block_index'], tx['source'], asset, callback_total, action='callback', event=tx['tx_hash'])
# Holders.
for output in outputs:
assert call_price * output['callback_quantity'] == int(call_price * output['callback_quantity'])
util.debit(db, tx['block_index'], output['address'], asset, output['callback_quantity'], action='callback', event=tx['tx_hash'])
util.credit(db, tx['block_index'], output['address'], config.XCP, int(call_price * output['callback_quantity']), action='callback', event=tx['tx_hash'])
# 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'],
'fraction': fraction,
'asset': asset,
'status': status,
}
sql='insert into callbacks values(:tx_index, :tx_hash, :block_index, :source, :fraction, :asset, :status)'
callback_parse_cursor.execute(sql, bindings)
callback_parse_cursor.close()
def transfer_value(self,
tx,
source,
destination,
quantity,
asset=config.XCP):
if source:
util.debit(self.db,
tx.block_index,
source,
asset,
quantity,
action='transfer value',
event=tx.tx_hash)
if destination:
util.credit(self.db,
tx.block_index,
destination,
asset,
quantity,
action='transfer value',
event=tx.tx_hash)
return True
def transfer_value(self, tx, source, destination, quantity, asset=config.XCP):
if source:
util.debit(self.db, tx.block_index, source, asset, quantity, action='transfer value', event=tx.tx_hash)
if destination:
util.credit(self.db, tx.block_index, destination, asset, quantity, action='transfer value', event=tx.tx_hash)
return True
def parse(db, tx, message):
bet_parse_cursor = db.cursor()
# Unpack message.
try:
if len(message) != LENGTH:
raise exceptions.UnpackError
(bet_type, deadline, wager_quantity, counterwager_quantity,
target_value, leverage, expiration) = struct.unpack(FORMAT, message)
status = 'open'
except (exceptions.UnpackError, struct.error):
(bet_type, deadline, wager_quantity, counterwager_quantity,
target_value, leverage, expiration,
fee_fraction_int) = 0, 0, 0, 0, 0, 0, 0, 0
status = 'invalid: could not unpack'
odds, fee_fraction = 0, 0
feed_address = tx['destination']
if status == 'open':
try:
odds = util.price(wager_quantity, counterwager_quantity,
tx['block_index'])
except ZeroDivisionError:
odds = 0
fee_fraction = get_fee_fraction(db, feed_address)
# Overbet
bet_parse_cursor.execute(
'''SELECT * FROM balances \
WHERE (address = ? AND asset = ?)''',
(tx['source'], config.XCP))
balances = list(bet_parse_cursor)
if not balances:
wager_quantity = 0
else:
balance = balances[0]['quantity']
if balance < wager_quantity:
wager_quantity = balance
counterwager_quantity = int(
util.price(wager_quantity, odds, tx['block_index']))
problems, leverage = validate(db, tx['source'], feed_address, bet_type,
deadline, wager_quantity,
counterwager_quantity, target_value,
leverage, expiration, tx['block_index'])
if problems: status = 'invalid: ' + '; '.join(problems)
# Debit quantity wagered. (Escrow.)
if status == 'open':
util.debit(db,
tx['block_index'],
tx['source'],
config.XCP,
wager_quantity,
action='bet',
event=tx['tx_hash'])
# 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'],
'feed_address': feed_address,
'bet_type': bet_type,
'deadline': deadline,
'wager_quantity': wager_quantity,
'wager_remaining': wager_quantity,
'counterwager_quantity': counterwager_quantity,
'counterwager_remaining': counterwager_quantity,
'target_value': target_value,
'leverage': leverage,
'expiration': expiration,
'expire_index': tx['block_index'] + expiration,
'fee_fraction_int': fee_fraction * 1e8,
'status': status,
}
sql = 'insert into bets values(:tx_index, :tx_hash, :block_index, :source, :feed_address, :bet_type, :deadline, :wager_quantity, :wager_remaining, :counterwager_quantity, :counterwager_remaining, :target_value, :leverage, :expiration, :expire_index, :fee_fraction_int, :status)'
bet_parse_cursor.execute(sql, bindings)
# Match.
if status == 'open' and tx['block_index'] != config.MEMPOOL_BLOCK_INDEX:
match(db, tx)
bet_parse_cursor.close()
def parse (db, tx, message):
order_parse_cursor = db.cursor()
# Unpack message.
try:
if len(message) != LENGTH:
raise exceptions.UnpackError
give_id, give_quantity, get_id, get_quantity, expiration, fee_required = struct.unpack(FORMAT, message)
give_asset = util.get_asset_name(give_id, tx['block_index'])
get_asset = util.get_asset_name(get_id, tx['block_index'])
status = 'open'
except (exceptions.UnpackError, exceptions.AssetNameError, struct.error) as e:
give_asset, give_quantity, get_asset, get_quantity, expiration, fee_required = 0, 0, 0, 0, 0, 0
status = 'invalid: could not unpack'
price = 0
if status == 'open':
try:
price = util.price(get_quantity, give_quantity, tx['block_index'])
except ZeroDivisionError:
price = 0
# Overorder
order_parse_cursor.execute('''SELECT * FROM balances \
WHERE (address = ? AND asset = ?)''', (tx['source'], give_asset))
balances = list(order_parse_cursor)
if give_asset != config.BTC:
if not balances:
give_quantity = 0
else:
balance = balances[0]['quantity']
if balance < give_quantity:
give_quantity = balance
get_quantity = int(price * give_quantity)
problems = validate(db, tx['source'], give_asset, give_quantity, get_asset, get_quantity, expiration, fee_required, tx['block_index'])
if problems: status = 'invalid: ' + '; '.join(problems)
# Debit give quantity. (Escrow.)
if status == 'open':
if give_asset != config.BTC: # No need (or way) to debit BTC.
util.debit(db, tx['block_index'], tx['source'], give_asset, give_quantity, action='open order', event=tx['tx_hash'])
# 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'],
'give_asset': give_asset,
'give_quantity': give_quantity,
'give_remaining': give_quantity,
'get_asset': get_asset,
'get_quantity': get_quantity,
'get_remaining': get_quantity,
'expiration': expiration,
'expire_index': tx['block_index'] + expiration,
'fee_required': fee_required,
'fee_required_remaining': fee_required,
'fee_provided': tx['fee'],
'fee_provided_remaining': tx['fee'],
'status': status,
}
sql='insert into orders values(:tx_index, :tx_hash, :block_index, :source, :give_asset, :give_quantity, :give_remaining, :get_asset, :get_quantity, :get_remaining, :expiration, :expire_index, :fee_required, :fee_required_remaining, :fee_provided, :fee_provided_remaining, :status)'
order_parse_cursor.execute(sql, bindings)
# Match.
if status == 'open' and tx['block_index'] != config.MEMPOOL_BLOCK_INDEX:
match(db, tx)
order_parse_cursor.close()
def parse(db, tx, message):
rps_parse_cursor = db.cursor()
# Unpack message.
try:
if len(message) != LENGTH:
raise exceptions.UnpackError
(possible_moves, wager, move_random_hash,
expiration) = struct.unpack(FORMAT, message)
status = 'open'
except (exceptions.UnpackError, struct.error):
(possible_moves, wager, move_random_hash, expiration) = 0, 0, '', 0
status = 'invalid: could not unpack'
if status == 'open':
move_random_hash = binascii.hexlify(move_random_hash).decode('utf8')
# Overbet
rps_parse_cursor.execute(
'''SELECT * FROM balances \
WHERE (address = ? AND asset = ?)''',
(tx['source'], 'XCP'))
balances = list(rps_parse_cursor)
if not balances:
wager = 0
else:
balance = balances[0]['quantity']
if balance < wager:
wager = balance
problems = validate(db, tx['source'], possible_moves, wager,
move_random_hash, expiration, tx['block_index'])
if problems: status = 'invalid: {}'.format(', '.join(problems))
# Debit quantity wagered. (Escrow.)
if status == 'open':
util.debit(db,
tx['block_index'],
tx['source'],
'XCP',
wager,
action="open RPS",
event=tx['tx_hash'])
# 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'],
'possible_moves': possible_moves,
'wager': wager,
'move_random_hash': move_random_hash,
'expiration': expiration,
'expire_index': tx['block_index'] + expiration,
'status': status,
}
sql = '''INSERT INTO rps VALUES (:tx_index, :tx_hash, :block_index, :source, :possible_moves, :wager, :move_random_hash, :expiration, :expire_index, :status)'''
rps_parse_cursor.execute(sql, bindings)
# Match.
if status == 'open':
match(db, tx, tx['block_index'])
rps_parse_cursor.close()
def parse (db, tx, message):
bet_parse_cursor = db.cursor()
# Unpack message.
try:
if len(message) != LENGTH:
raise exceptions.UnpackError
(bet_type, deadline, wager_quantity,
counterwager_quantity, target_value, leverage,
expiration) = struct.unpack(FORMAT, message)
status = 'open'
except (exceptions.UnpackError, struct.error):
(bet_type, deadline, wager_quantity,
counterwager_quantity, target_value, leverage,
expiration, fee_fraction_int) = 0, 0, 0, 0, 0, 0, 0, 0
status = 'invalid: could not unpack'
odds, fee_fraction = 0, 0
feed_address = tx['destination']
if status == 'open':
try:
odds = util.price(wager_quantity, counterwager_quantity, tx['block_index'])
except ZeroDivisionError:
odds = 0
fee_fraction = get_fee_fraction(db, feed_address)
# Overbet
bet_parse_cursor.execute('''SELECT * FROM balances \
WHERE (address = ? AND asset = ?)''', (tx['source'], config.XCP))
balances = list(bet_parse_cursor)
if not balances:
wager_quantity = 0
else:
balance = balances[0]['quantity']
if balance < wager_quantity:
wager_quantity = balance
counterwager_quantity = int(util.price(wager_quantity, odds, tx['block_index']))
problems, leverage = validate(db, tx['source'], feed_address, bet_type, deadline, wager_quantity,
counterwager_quantity, target_value, leverage, expiration, tx['block_index'])
if problems: status = 'invalid: ' + '; '.join(problems)
# Debit quantity wagered. (Escrow.)
if status == 'open':
util.debit(db, tx['block_index'], tx['source'], config.XCP, wager_quantity, action='bet', event=tx['tx_hash'])
# 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'],
'feed_address': feed_address,
'bet_type': bet_type,
'deadline': deadline,
'wager_quantity': wager_quantity,
'wager_remaining': wager_quantity,
'counterwager_quantity': counterwager_quantity,
'counterwager_remaining': counterwager_quantity,
'target_value': target_value,
'leverage': leverage,
'expiration': expiration,
'expire_index': tx['block_index'] + expiration,
'fee_fraction_int': fee_fraction * 1e8,
'status': status,
}
sql='insert into bets values(:tx_index, :tx_hash, :block_index, :source, :feed_address, :bet_type, :deadline, :wager_quantity, :wager_remaining, :counterwager_quantity, :counterwager_remaining, :target_value, :leverage, :expiration, :expire_index, :fee_fraction_int, :status)'
bet_parse_cursor.execute(sql, bindings)
# Match.
if status == 'open' and tx['block_index'] != config.MEMPOOL_BLOCK_INDEX:
match(db, tx)
bet_parse_cursor.close()
def expire(db, block_index):
cursor = db.cursor()
# Expire rps and give refunds for the quantity wager.
cursor.execute(
'''SELECT * FROM rps WHERE (status = ? AND expire_index < ?)''',
('open', block_index))
for rps in cursor.fetchall():
cancel_rps(db, rps, 'expired', block_index)
# Record rps expiration.
bindings = {
'rps_index': rps['tx_index'],
'rps_hash': rps['tx_hash'],
'source': rps['source'],
'block_index': block_index
}
sql = '''INSERT INTO rps_expirations VALUES (:rps_index, :rps_hash, :source, :block_index)'''
cursor.execute(sql, bindings)
# Expire rps matches
expire_bindings = ('pending', 'pending and resolved',
'resolved and pending', block_index)
cursor.execute(
'''SELECT * FROM rps_matches WHERE (status IN (?, ?, ?) AND match_expire_index < ?)''',
expire_bindings)
for rps_match in cursor.fetchall():
new_rps_match_status = 'expired'
# pending loses against resolved
if rps_match['status'] == 'pending and resolved':
new_rps_match_status = 'concluded: second player wins'
elif rps_match['status'] == 'resolved and pending':
new_rps_match_status = 'concluded: first player wins'
update_rps_match_status(db, rps_match, new_rps_match_status,
block_index)
# Record rps match expiration.
bindings = {
'rps_match_id': rps_match['id'],
'tx0_address': rps_match['tx0_address'],
'tx1_address': rps_match['tx1_address'],
'block_index': block_index
}
sql = '''INSERT INTO rps_match_expirations VALUES (:rps_match_id, :tx0_address, :tx1_address, :block_index)'''
cursor.execute(sql, bindings)
# Rematch not expired and not resolved RPS
if new_rps_match_status == 'expired':
sql = '''SELECT * FROM rps WHERE tx_hash IN (?, ?) AND status = ? AND expire_index >= ?'''
bindings = (rps_match['tx0_hash'], rps_match['tx1_hash'],
'matched', block_index)
matched_rps = list(cursor.execute(sql, bindings))
for rps in matched_rps:
cursor.execute(
'''UPDATE rps SET status = ? WHERE tx_index = ?''',
('open', rps['tx_index']))
# Re-debit XCP refund by close_rps_match.
util.debit(db,
block_index,
rps['source'],
'XCP',
rps['wager'],
action='reopen RPS after matching expiration',
event=rps_match['id'])
# Rematch
match(db, {'tx_index': rps['tx_index']}, block_index)
cursor.close()
def parse(db, tx, message):
issuance_parse_cursor = db.cursor()
# Unpack message.
try:
if (tx['block_index'] > 283271 or config.TESTNET
) and len(message) >= LENGTH_2: # Protocol change.
if len(message) - LENGTH_2 <= 42:
curr_format = FORMAT_2 + '{}p'.format(len(message) - LENGTH_2)
else:
curr_format = FORMAT_2 + '{}s'.format(len(message) - LENGTH_2)
asset_id, quantity, divisible, callable_, call_date, call_price, description = struct.unpack(
curr_format, message)
call_price = round(call_price, 6) # TODO: arbitrary
try:
description = description.decode('utf-8')
except UnicodeDecodeError:
description = ''
else:
if len(message) != LENGTH_1:
raise exceptions.UnpackError
asset_id, quantity, divisible = struct.unpack(FORMAT_1, message)
callable_, call_date, call_price, description = False, 0, 0.0, ''
try:
asset = util.generate_asset_name(asset_id, tx['block_index'])
except exceptions.AssetNameError:
asset = None
status = 'invalid: bad asset name'
status = 'valid'
except exceptions.UnpackError as e:
asset, quantity, divisible, callable_, call_date, call_price, description = None, None, None, None, None, None, None
status = 'invalid: could not unpack'
fee = 0
if status == 'valid':
call_date, call_price, problems, fee, description, divisible, reissuance = validate(
db,
tx['source'],
tx['destination'],
asset,
quantity,
divisible,
callable_,
call_date,
call_price,
description,
block_index=tx['block_index'])
if problems: status = 'invalid: ' + '; '.join(problems)
if 'total quantity overflow' in problems:
quantity = 0
if tx['destination']:
issuer = tx['destination']
transfer = True
quantity = 0
else:
issuer = tx['source']
transfer = False
# Debit fee.
if status == 'valid':
util.debit(db,
tx['block_index'],
tx['source'],
config.XCP,
fee,
action="issuance fee",
event=tx['tx_hash'])
# Lock?
lock = False
if status == 'valid':
if description and description.lower() == 'lock':
lock = True
cursor = db.cursor()
issuances = list(
cursor.execute(
'''SELECT * FROM issuances \
WHERE (status = ? AND asset = ?)
ORDER BY tx_index ASC''',
('valid', asset)))
cursor.close()
description = issuances[-1][
'description'] # Use last description. (Assume previous issuance exists because tx is valid.)
timestamp, value_int, fee_fraction_int = None, None, None
if not reissuance:
# Add to table of assets.
bindings = {
'asset_id': str(asset_id),
'asset_name': str(asset),
'block_index': tx['block_index'],
}
sql = 'insert into assets values(:asset_id, :asset_name, :block_index)'
issuance_parse_cursor.execute(sql, bindings)
# Add parsed transaction to message-type–specific table.
bindings = {
'tx_index': tx['tx_index'],
'tx_hash': tx['tx_hash'],
'block_index': tx['block_index'],
'asset': asset,
'quantity': quantity,
'divisible': divisible,
'source': tx['source'],
'issuer': issuer,
'transfer': transfer,
'callable': callable_,
'call_date': call_date,
'call_price': call_price,
'description': description,
'fee_paid': fee,
'locked': lock,
'status': status,
}
sql = 'insert into issuances values(:tx_index, :tx_hash, :block_index, :asset, :quantity, :divisible, :source, :issuer, :transfer, :callable, :call_date, :call_price, :description, :fee_paid, :locked, :status)'
issuance_parse_cursor.execute(sql, bindings)
# Credit.
if status == 'valid' and quantity:
util.credit(db,
tx['block_index'],
tx['source'],
asset,
quantity,
action="issuance",
event=tx['tx_hash'])
issuance_parse_cursor.close()
def parse (db, tx, message):
issuance_parse_cursor = db.cursor()
# Unpack message.
try:
if (tx['block_index'] > 283271 or config.TESTNET) and len(message) >= LENGTH_2: # Protocol change.
if len(message) - LENGTH_2 <= 42:
curr_format = FORMAT_2 + '{}p'.format(len(message) - LENGTH_2)
else:
curr_format = FORMAT_2 + '{}s'.format(len(message) - LENGTH_2)
asset_id, quantity, divisible, callable_, call_date, call_price, description = struct.unpack(curr_format, message)
call_price = round(call_price, 6) # TODO: arbitrary
try:
description = description.decode('utf-8')
except UnicodeDecodeError:
description = ''
else:
if len(message) != LENGTH_1:
raise exceptions.UnpackError
asset_id, quantity, divisible = struct.unpack(FORMAT_1, message)
callable_, call_date, call_price, description = False, 0, 0.0, ''
try:
asset = util.generate_asset_name(asset_id, tx['block_index'])
except exceptions.AssetNameError:
asset = None
status = 'invalid: bad asset name'
status = 'valid'
except exceptions.UnpackError as e:
asset, quantity, divisible, callable_, call_date, call_price, description = None, None, None, None, None, None, None
status = 'invalid: could not unpack'
fee = 0
if status == 'valid':
call_date, call_price, problems, fee, description, divisible, reissuance = validate(db, tx['source'], tx['destination'], asset, quantity, divisible, callable_, call_date, call_price, description, block_index=tx['block_index'])
if problems: status = 'invalid: ' + '; '.join(problems)
if 'total quantity overflow' in problems:
quantity = 0
if tx['destination']:
issuer = tx['destination']
transfer = True
quantity = 0
else:
issuer = tx['source']
transfer = False
# Debit fee.
if status == 'valid':
util.debit(db, tx['block_index'], tx['source'], config.XCP, fee, action="issuance fee", event=tx['tx_hash'])
# Lock?
lock = False
if status == 'valid':
if description and description.lower() == 'lock':
lock = True
cursor = db.cursor()
issuances = list(cursor.execute('''SELECT * FROM issuances \
WHERE (status = ? AND asset = ?)
ORDER BY tx_index ASC''', ('valid', asset)))
cursor.close()
description = issuances[-1]['description'] # Use last description. (Assume previous issuance exists because tx is valid.)
timestamp, value_int, fee_fraction_int = None, None, None
if not reissuance:
# Add to table of assets.
bindings= {
'asset_id': str(asset_id),
'asset_name': str(asset),
'block_index': tx['block_index'],
}
sql='insert into assets values(:asset_id, :asset_name, :block_index)'
issuance_parse_cursor.execute(sql, bindings)
# Add parsed transaction to message-type–specific table.
bindings= {
'tx_index': tx['tx_index'],
'tx_hash': tx['tx_hash'],
'block_index': tx['block_index'],
'asset': asset,
'quantity': quantity,
'divisible': divisible,
'source': tx['source'],
'issuer': issuer,
'transfer': transfer,
'callable': callable_,
'call_date': call_date,
'call_price': call_price,
'description': description,
'fee_paid': fee,
'locked': lock,
'status': status,
}
sql='insert into issuances values(:tx_index, :tx_hash, :block_index, :asset, :quantity, :divisible, :source, :issuer, :transfer, :callable, :call_date, :call_price, :description, :fee_paid, :locked, :status)'
issuance_parse_cursor.execute(sql, bindings)
# Credit.
if status == 'valid' and quantity:
util.credit(db, tx['block_index'], tx['source'], asset, quantity, action="issuance", event=tx['tx_hash'])
issuance_parse_cursor.close()
def parse (db, tx, message):
order_parse_cursor = db.cursor()
# Unpack message.
try:
if len(message) != LENGTH:
raise exceptions.UnpackError
give_id, give_quantity, get_id, get_quantity, expiration, fee_required = struct.unpack(FORMAT, message)
give_asset = util.get_asset_name(db, give_id, tx['block_index'])
get_asset = util.get_asset_name(db, get_id, tx['block_index'])
status = 'open'
except (exceptions.UnpackError, exceptions.AssetNameError, struct.error) as e:
give_asset, give_quantity, get_asset, get_quantity, expiration, fee_required = 0, 0, 0, 0, 0, 0
status = 'invalid: could not unpack'
price = 0
if status == 'open':
try:
price = util.price(get_quantity, give_quantity, tx['block_index'])
except ZeroDivisionError:
price = 0
# Overorder
order_parse_cursor.execute('''SELECT * FROM balances \
WHERE (address = ? AND asset = ?)''', (tx['source'], give_asset))
balances = list(order_parse_cursor)
if give_asset != config.BTC:
if not balances:
give_quantity = 0
else:
balance = balances[0]['quantity']
if balance < give_quantity:
give_quantity = balance
get_quantity = int(price * give_quantity)
problems = validate(db, tx['source'], give_asset, give_quantity, get_asset, get_quantity, expiration, fee_required, tx['block_index'])
if problems: status = 'invalid: ' + '; '.join(problems)
# Debit give quantity. (Escrow.)
if status == 'open':
if give_asset != config.BTC: # No need (or way) to debit BTC.
util.debit(db, tx['block_index'], tx['source'], give_asset, give_quantity, action='open order', event=tx['tx_hash'])
# 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'],
'give_asset': give_asset,
'give_quantity': give_quantity,
'give_remaining': give_quantity,
'get_asset': get_asset,
'get_quantity': get_quantity,
'get_remaining': get_quantity,
'expiration': expiration,
'expire_index': tx['block_index'] + expiration,
'fee_required': fee_required,
'fee_required_remaining': fee_required,
'fee_provided': tx['fee'],
'fee_provided_remaining': tx['fee'],
'status': status,
}
sql='insert into orders values(:tx_index, :tx_hash, :block_index, :source, :give_asset, :give_quantity, :give_remaining, :get_asset, :get_quantity, :get_remaining, :expiration, :expire_index, :fee_required, :fee_required_remaining, :fee_provided, :fee_provided_remaining, :status)'
order_parse_cursor.execute(sql, bindings)
# Match.
if status == 'open' and tx['block_index'] != config.MEMPOOL_BLOCK_INDEX:
match(db, tx)
order_parse_cursor.close()