def _decode_decodeSendList(stream, nbits, lut, block_index):
asset_id = stream.read('uintbe:64')
if nbits > 0:
numRecipients = stream.read('uint:%i' % nbits)
rangeLimit = numRecipients + 1
else:
numRecipients = 1
rangeLimit = numRecipients
sendList = []
asset = util.generate_asset_name(asset_id, block_index)
for i in range(0, rangeLimit):
if nbits > 0:
idx = stream.read('uint:%i' % nbits)
else:
idx = 0
addr = lut[idx]
amount = stream.read('uintbe:64')
memo, is_hex = _decode_memo(stream)
if memo is not None:
sendList.append((addr, amount, memo, is_hex))
else:
sendList.append((addr, amount))
return asset, sendList
def unpack(db, message, block_index):
try:
# account for memo bytes
memo_bytes_length = len(message) - LENGTH
if memo_bytes_length < 0:
raise exceptions.UnpackError('invalid message length')
if memo_bytes_length > MAX_MEMO_LENGTH:
raise exceptions.UnpackError('memo too long')
struct_format = FORMAT + ('{}s'.format(memo_bytes_length))
asset_id, quantity, short_address_bytes, memo_bytes = struct.unpack(
struct_format, message)
if len(memo_bytes) == 0:
memo_bytes = None
# unpack address
full_address = address.unpack(short_address_bytes)
# asset id to name
asset = util.generate_asset_name(asset_id, block_index)
if asset == config.BTC:
raise exceptions.AssetNameError('{} not allowed'.format(
config.BTC))
except (struct.error) as e:
logger.warning("enhanced send unpack error: {}".format(e))
raise exceptions.UnpackError('could not unpack')
except (exceptions.AssetNameError, exceptions.AssetIDError) as e:
logger.warning("enhanced send invalid asset id: {}".format(e))
raise exceptions.UnpackError('asset id invalid')
unpacked = {
'asset': asset,
'quantity': quantity,
'address': full_address,
'memo': memo_bytes,
}
return unpacked
def unpack(db, message, block_index):
try:
# account for memo bytes
memo_bytes_length = len(message) - LENGTH
if memo_bytes_length < 0:
raise exceptions.UnpackError('invalid message length')
if memo_bytes_length > MAX_MEMO_LENGTH:
raise exceptions.UnpackError('memo too long')
struct_format = FORMAT + ('{}s'.format(memo_bytes_length))
asset_id, quantity, short_address_bytes, memo_bytes = struct.unpack(struct_format, message)
if len(memo_bytes) == 0:
memo_bytes = None
# unpack address
full_address = address.unpack(short_address_bytes)
# asset id to name
asset = util.generate_asset_name(asset_id, block_index)
if asset == config.BTC:
raise exceptions.AssetNameError('{} not allowed'.format(config.BTC))
except (struct.error) as e:
logger.warning("enhanced send unpack error: {}".format(e))
raise exceptions.UnpackError('could not unpack')
except (exceptions.AssetNameError, exceptions.AssetIDError) as e:
logger.warning("enhanced send invalid asset id: {}".format(e))
raise exceptions.UnpackError('asset id invalid')
unpacked = {
'asset': asset,
'quantity': quantity,
'address': full_address,
'memo': memo_bytes,
}
return unpacked
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 not util.enabled('integer_overflow_fix', block_index=tx['block_index']) and '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['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,
}
if "integer overflow" not in 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)
else:
logger.warn("Not storing [issuance] tx [%s]: %s" % (tx['tx_hash'], status))
logger.debug("Bindings: %s" % (json.dumps(bindings), ))
# Credit.
if status == 'valid' and quantity:
util.credit(db, tx['source'], asset, quantity, action="issuance", event=tx['tx_hash'])
issuance_parse_cursor.close()
def parse(db, tx, message, message_type_id):
issuance_parse_cursor = db.cursor()
# Unpack message.
try:
subasset_longname = None
if message_type_id == SUBASSET_ID:
if not util.enabled('subassets', block_index=tx['block_index']):
logger.warn("subassets are not enabled at block %s" %
tx['block_index'])
raise exceptions.UnpackError
# parse a subasset original issuance message
asset_id, quantity, divisible, compacted_subasset_length = struct.unpack(
SUBASSET_FORMAT, message[0:SUBASSET_FORMAT_LENGTH])
description_length = len(
message) - SUBASSET_FORMAT_LENGTH - compacted_subasset_length
if description_length < 0:
logger.warn("invalid subasset length: [issuance] tx [%s]: %s" %
(tx['tx_hash'], compacted_subasset_length))
raise exceptions.UnpackError
messages_format = '>{}s{}s'.format(compacted_subasset_length,
description_length)
compacted_subasset_longname, description = struct.unpack(
messages_format, message[SUBASSET_FORMAT_LENGTH:])
subasset_longname = util.expand_subasset_longname(
compacted_subasset_longname)
callable_, call_date, call_price = False, 0, 0.0
try:
description = description.decode('utf-8')
except UnicodeDecodeError:
description = ''
elif (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'
# parse and validate the subasset from the message
subasset_parent = None
if status == 'valid' and subasset_longname is not None: # Protocol change.
try:
# ensure the subasset_longname is valid
util.validate_subasset_longname(subasset_longname)
subasset_parent, subasset_longname = util.parse_subasset_from_asset_name(
subasset_longname)
except exceptions.AssetNameError as e:
asset = None
status = 'invalid: bad subasset name'
reissuance = None
fee = 0
if status == 'valid':
call_date, call_price, problems, fee, description, divisible, reissuance, reissued_asset_longname = validate(
db,
tx['source'],
tx['destination'],
asset,
quantity,
divisible,
callable_,
call_date,
call_price,
description,
subasset_parent,
subasset_longname,
block_index=tx['block_index'])
if problems: status = 'invalid: ' + '; '.join(problems)
if not util.enabled('integer_overflow_fix',
block_index=tx['block_index']
) and '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['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'],
'asset_longname': subasset_longname,
}
sql = 'insert into assets values(:asset_id, :asset_name, :block_index, :asset_longname)'
issuance_parse_cursor.execute(sql, bindings)
if status == 'valid' and reissuance:
# when reissuing, add the asset_longname to the issuances table for API lookups
asset_longname = reissued_asset_longname
else:
asset_longname = subasset_longname
# 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,
'asset_longname': asset_longname,
}
if "integer overflow" not in 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, :asset_longname)'
issuance_parse_cursor.execute(sql, bindings)
else:
logger.warn("Not storing [issuance] tx [%s]: %s" %
(tx['tx_hash'], status))
logger.debug("Bindings: %s" % (json.dumps(bindings), ))
# Credit.
if status == 'valid' and quantity:
util.credit(db,
tx['source'],
asset,
quantity,
action="issuance",
event=tx['tx_hash'])
issuance_parse_cursor.close()
def parse (db, tx, message):
cursor = db.cursor()
# Unpack message.
try:
if len(message) != LENGTH:
raise exceptions.UnpackError
assetid, give_quantity, escrow_quantity, mainchainrate, dispenser_status = struct.unpack(FORMAT, message)
asset = util.generate_asset_name(assetid, util.CURRENT_BLOCK_INDEX)
status = 'valid'
except (exceptions.UnpackError, struct.error):
assetid, give_quantity, mainchainrate, asset = None, None, None, None
status = 'invalid: could not unpack'
if status == 'valid':
assetid, problems = validate (db, tx['source'], asset, give_quantity, escrow_quantity, mainchainrate, dispenser_status, tx['block_index'])
if problems: status = 'invalid: ' + '; '.join(problems)
if status == 'valid':
if dispenser_status == STATUS_OPEN:
cursor.execute('SELECT * FROM dispensers WHERE source=:source AND asset=:asset AND status=:status', {
'source': tx['source'],
'asset': asset,
'status': STATUS_OPEN
})
existing = cursor.fetchall()
if len(existing) == 0:
# Create the new dispenser
bindings = {
'tx_index': tx['tx_index'],
'tx_hash': tx['tx_hash'],
'block_index': tx['block_index'],
'source': tx['source'],
'asset': asset,
'give_quantity': give_quantity,
'escrow_quantity': escrow_quantity,
'satoshirate': mainchainrate,
'status': dispenser_status,
'give_remaining': escrow_quantity
}
try:
util.debit(db, tx['source'], asset, escrow_quantity, action='open dispenser', event=tx['tx_hash'])
sql = 'insert into dispensers values(:tx_index, :tx_hash, :block_index, :source, :asset, :give_quantity, :escrow_quantity, :satoshirate, :status, :give_remaining)'
cursor.execute(sql, bindings)
except (util.DebitError):
status = 'insufficient funds'
elif len(existing) == 1 and existing[0]['satoshirate'] == mainchainrate and existing[0]['give_quantity'] == give_quantity:
# Refill the dispenser by the given amount
bindings = {
'source': tx['source'],
'asset': asset,
'give_remaining': existing[0]['give_remaining'] + escrow_quantity,
'status': STATUS_OPEN,
'block_index': tx['block_index']
}
try:
util.debit(db, tx['source'], asset, escrow_quantity, action='refill dispenser', event=tx['tx_hash'])
sql = 'UPDATE dispensers SET give_remaining=:give_remaining \
WHERE source=:source AND asset=:asset AND status=:status'
cursor.execute(sql, bindings)
except (util.DebitError):
status = 'insufficient funds'
else:
status = 'can only have one open dispenser per asset per address'
elif dispenser_status == STATUS_CLOSED:
cursor.execute('SELECT give_remaining FROM dispensers WHERE source=:source AND asset=:asset AND status=:status', {
'source': tx['source'],
'asset': asset,
'status': STATUS_OPEN
})
existing = cursor.fetchall()
if len(existing) == 1:
util.credit(db, tx['source'], asset, existing[0]['give_remaining'], action='close dispenser', event=tx['tx_hash'])
bindings = {
'source': tx['source'],
'asset': asset,
'status': STATUS_CLOSED,
'block_index': tx['block_index']
}
sql = 'UPDATE dispensers SET give_remaining=0, status=:status WHERE source=:source AND asset=:asset'
cursor.execute(sql, bindings)
else:
status = 'dispenser inexistent'
else:
status = 'invalid: status must be one of OPEN or CLOSE'
def parse(db, tx, message):
cursor = db.cursor()
# Unpack message.
try:
action_address = tx['source']
assetid, give_quantity, escrow_quantity, mainchainrate, dispenser_status = struct.unpack(
FORMAT, message[0:LENGTH])
if dispenser_status == STATUS_OPEN_EMPTY_ADDRESS:
action_address = address.unpack(message[LENGTH:LENGTH + 21])
asset = util.generate_asset_name(assetid, util.CURRENT_BLOCK_INDEX)
status = 'valid'
except (exceptions.UnpackError, struct.error) as e:
assetid, give_quantity, mainchainrate, asset = None, None, None, None
status = 'invalid: could not unpack'
if status == 'valid':
if dispenser_status == STATUS_OPEN or dispenser_status == STATUS_OPEN_EMPTY_ADDRESS:
cursor.execute(
'SELECT * FROM dispensers WHERE source=:source AND asset=:asset AND status=:status',
{
'source': action_address,
'asset': asset,
'status': STATUS_OPEN
})
existing = cursor.fetchall()
if len(existing) == 0:
# Create the new dispenser
try:
if dispenser_status == STATUS_OPEN_EMPTY_ADDRESS:
cursor.execute(
'SELECT count(*) cnt FROM balances WHERE address=:address AND quantity > 0',
{'address': action_address})
counts = cursor.fetchall()[0]
if counts['cnt'] == 0:
util.debit(db,
tx['source'],
asset,
escrow_quantity,
action='open dispenser empty addr',
event=tx['tx_hash'])
util.credit(db,
action_address,
asset,
escrow_quantity,
action='open dispenser empty addr',
event=tx['tx_hash'])
util.debit(db,
action_address,
asset,
escrow_quantity,
action='open dispenser empty addr',
event=tx['tx_hash'])
else:
status = 'invalid: address not empty'
else:
util.debit(db,
tx['source'],
asset,
escrow_quantity,
action='open dispenser',
event=tx['tx_hash'])
except util.DebitError as e:
status = 'invalid: insufficient funds'
if status == 'valid':
bindings = {
'tx_index': tx['tx_index'],
'tx_hash': tx['tx_hash'],
'block_index': tx['block_index'],
'source': action_address,
'asset': asset,
'give_quantity': give_quantity,
'escrow_quantity': escrow_quantity,
'satoshirate': mainchainrate,
'status': STATUS_OPEN,
'give_remaining': escrow_quantity
}
sql = 'insert into dispensers values(:tx_index, :tx_hash, :block_index, :source, :asset, :give_quantity, :escrow_quantity, :satoshirate, :status, :give_remaining)'
cursor.execute(sql, bindings)
elif len(existing) == 1 and existing[0][
'satoshirate'] == mainchainrate and existing[0][
'give_quantity'] == give_quantity:
if tx["source"] == action_address:
# Refill the dispenser by the given amount
bindings = {
'source': tx['source'],
'asset': asset,
'status': dispenser_status,
'give_remaining':
existing[0]['give_remaining'] + escrow_quantity,
'status': STATUS_OPEN,
'block_index': tx['block_index']
}
try:
util.debit(db,
tx['source'],
asset,
escrow_quantity,
action='refill dispenser',
event=tx['tx_hash'])
sql = 'UPDATE dispensers SET give_remaining=:give_remaining \
WHERE source=:source AND asset=:asset AND status=:status'
cursor.execute(sql, bindings)
except (util.DebitError):
status = 'insufficient funds'
else:
status = 'invalid: can only refill dispenser from source'
else:
status = 'can only have one open dispenser per asset per address'
elif dispenser_status == STATUS_CLOSED:
cursor.execute(
'SELECT give_remaining FROM dispensers WHERE source=:source AND asset=:asset AND status=:status',
{
'source': tx['source'],
'asset': asset,
'status': STATUS_OPEN
})
existing = cursor.fetchall()
if len(existing) == 1:
util.credit(db,
tx['source'],
asset,
existing[0]['give_remaining'],
action='close dispenser',
event=tx['tx_hash'])
bindings = {
'source': tx['source'],
'asset': asset,
'status': STATUS_CLOSED,
'block_index': tx['block_index']
}
sql = 'UPDATE dispensers SET give_remaining=0, status=:status WHERE source=:source AND asset=:asset'
cursor.execute(sql, bindings)
else:
status = 'dispenser inexistent'
else:
status = 'invalid: status must be one of OPEN or CLOSE'
if status != 'valid':
logger.warn("Not storing [dispenser] tx [%s]: %s" %
(tx['tx_hash'], status))
cursor.close()
def parse (db, tx, message, message_type_id):
issuance_parse_cursor = db.cursor()
# Unpack message.
try:
subasset_longname = None
if message_type_id == SUBASSET_ID:
if not util.enabled('subassets', block_index=tx['block_index']):
logger.warn("subassets are not enabled at block %s" % tx['block_index'])
raise exceptions.UnpackError
# parse a subasset original issuance message
asset_id, quantity, divisible, compacted_subasset_length = struct.unpack(SUBASSET_FORMAT, message[0:SUBASSET_FORMAT_LENGTH])
description_length = len(message) - SUBASSET_FORMAT_LENGTH - compacted_subasset_length
if description_length < 0:
logger.warn("invalid subasset length: [issuance] tx [%s]: %s" % (tx['tx_hash'], compacted_subasset_length))
raise exceptions.UnpackError
messages_format = '>{}s{}s'.format(compacted_subasset_length, description_length)
compacted_subasset_longname, description = struct.unpack(messages_format, message[SUBASSET_FORMAT_LENGTH:])
subasset_longname = util.expand_subasset_longname(compacted_subasset_longname)
callable_, call_date, call_price = False, 0, 0.0
try:
description = description.decode('utf-8')
except UnicodeDecodeError:
description = ''
elif (tx['block_index'] > 283271 or config.TESTNET or config.REGTEST) 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'])
status = 'valid'
except exceptions.AssetIDError:
asset = None
status = 'invalid: bad asset name'
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'
# parse and validate the subasset from the message
subasset_parent = None
if status == 'valid' and subasset_longname is not None: # Protocol change.
try:
# ensure the subasset_longname is valid
util.validate_subasset_longname(subasset_longname)
subasset_parent, subasset_longname = util.parse_subasset_from_asset_name(subasset_longname)
except exceptions.AssetNameError as e:
asset = None
status = 'invalid: bad subasset name'
reissuance = None
fee = 0
if status == 'valid':
call_date, call_price, problems, fee, description, divisible, reissuance, reissued_asset_longname = validate(db, tx['source'], tx['destination'], asset, quantity, divisible, callable_, call_date, call_price, description, subasset_parent, subasset_longname, block_index=tx['block_index'])
if problems: status = 'invalid: ' + '; '.join(problems)
if not util.enabled('integer_overflow_fix', block_index=tx['block_index']) and '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['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'],
'asset_longname': subasset_longname,
}
sql='insert into assets values(:asset_id, :asset_name, :block_index, :asset_longname)'
issuance_parse_cursor.execute(sql, bindings)
if status == 'valid' and reissuance:
# when reissuing, add the asset_longname to the issuances table for API lookups
asset_longname = reissued_asset_longname
else:
asset_longname = subasset_longname
# 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,
'asset_longname': asset_longname,
}
if "integer overflow" not in 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, :asset_longname)'
issuance_parse_cursor.execute(sql, bindings)
else:
logger.warn("Not storing [issuance] tx [%s]: %s" % (tx['tx_hash'], status))
logger.debug("Bindings: %s" % (json.dumps(bindings), ))
# Credit.
if status == 'valid' and quantity:
util.credit(db, 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['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['source'],
asset,
quantity,
action="issuance",
event=tx['tx_hash'])
issuance_parse_cursor.close()
