async def send_and_get_transaction(client, data, sender_pk):
if not data.get('nonce'):
data['nonce'] = await client.eth_getTransactionCount(
get_address(sender_pk), 'pending')
tx = MTransaction(**data)
signed_tx = tx.sign(sender_pk)
tx_id = await client.eth_sendRawTransaction(to_hex(signed_tx.raw))
print("Transaction hash: %s" % tx_id)
assert tx_id == to_hex(signed_tx.hash), 'Hashes are not equal'
tx_data = await client.eth_getTransactionByHash(tx_id)
print("Transaction data:")
pprint.pprint(tx_data)
print("Waiting until mined..")
tx_data = await get_tx_until_mined(client, tx_id)
print("Transaction data mined:")
pprint.pprint(tx_data)
return tx_data
def parse_directive_to_list(self, raw_asm_line: str):
directive = Directive(raw_instruction=raw_asm_line)
if directive.type in ('.word', '.byte'):
directive.value = to_hex(directive.value, num_bits=16)
return [directive]
elif directive.type == '.asciiz':
ascii_str = directive.value
ascii_str = self._undo_escape(ascii_str)
# Partitions string every 2 characters. I.e. '12345' => '12', '34', '5'
ascii_split_16bit = tuple(ascii_str[i: i + self._BYTES_PER_WORD]
for i in range(0, len(ascii_str), self._BYTES_PER_WORD))
directives_split_16bit = []
# Stores a list of directives, each storing 2 chars
# Converts each string into its hexadecimal ascii encoded format.
for ascii_word in ascii_split_16bit:
next_ascii_word = deepcopy(directive)
next_ascii_word.content = f"\"{ascii_word}\""
first_char = to_hex(ord(ascii_word[0]), num_bits=8)
second_char = to_hex(ord(ascii_word[-1]), num_bits=8)
next_ascii_word.value = second_char + first_char
directives_split_16bit.append(next_ascii_word)
# Padding null terminator.
# Create new if string len is even, pad at end if odd.
if len(ascii_str) % 2 == 0:
null_directive = deepcopy(directive)
null_directive.value = '0000'
null_directive.content = r'"\0\0"'
directives_split_16bit.append(null_directive)
else:
last_ascii = directives_split_16bit[-1]
ascii_encoded = last_ascii.value
len_half = len(ascii_encoded) // 2
# For debugging
error_msg = "Due to implementation, " \
"last directive should have stored two copies of same string"
assert ascii_encoded[:len_half] == ascii_encoded[len_half:], error_msg
# FIXME: Too convoluted and unintuitive
ascii_char = ascii_encoded[:len_half]
null_terminator = '00'
last_ascii.value = null_terminator + ascii_char
# Recovers original letter from hex encoding
last_ascii.content = "\"" + chr(int(ascii_char, 16)) + r'\0' + "\""
return directives_split_16bit
else:
raise SyntaxError(f"Expected .word or .byte of .asciiz, but got {directive.content}")
def main(args):
parser = bibtex.Parser()
bib_data = parser.parse_file(args.inp)
def sort_by_year(x):
return int(x[1].fields['year'])
bib_sorted = sorted(bib_data.entries.items(), key=sort_by_year)
papers = []
tags = {}
for key, value in bib_sorted:
print(key, value.fields['title'])
papers.append(value.fields['title'])
taglist = value.fields['swy'].split('.')
taglist = [TAGS[tag] for tag in taglist]
tags[value.fields['title']] = taglist
with open(args.out, 'w') as f:
f.writelines('var color = {\n')
for i, human in enumerate(TAGS.values()):
f.writelines(" '{}': \"{}\",\n".format(human, to_hex(rgb[i])))
f.writelines("};\n")
# write edges:
f.writelines('var data = [\n')
for i, human in enumerate(papers):
for val in tags[human]:
f.writelines(" ['{}', \"{}\", {}],\n".format(
val, human, width))
f.writelines("];\n")
def low_level_parse_logs(ct, tx_result, events=None):
if events is None:
events = ['Error(bytes32)', 'Success(bytes32)']
sha3_events = {to_hex(utils.sha3(event)): re.search('.*?(?=\()', event).group(0).encode('utf-8')
for event in events}
for log in tx_result['logs']:
if log['topics'][0] in sha3_events:
yield sha3_events[log['topics'][0]], utils.remove_0x_head(log['data']).rstrip('0')
def _sb_execute(self, r1: int, base: int, offset: int, comment: str):
base_addr = self._register[base]
target_addr = base_addr + offset
r1_value = self._register[r1]
val_as_hex = to_hex(value=r1_value, num_bits=16, debug_comment=comment)
one_byte = 2
low_byte = val_as_hex[one_byte:]
self._memory[target_addr] = low_byte
def to_string(self):
address = hex(self.address)[:-1]
raw_opc = to_hex_spaced(self.opc_bytes)
concs = ""
concs += "" if self.libcall is None else " Call:" + self.libcall.func_name
concs += "" if self.syscall is None else " " + str(self.syscall.id)
concs += "" if self.comment is None else " Comment:" + self.comment
for r_w, reg, value in self.registers:
val = hex(value) if isinstance(value, int) else to_hex(value)
concs += " " + r_w + "[" + reg + "]=" + val
for r_w, addr, value in self.memories:
concs += " " + r_w + "@[" + hex(addr) + "]=" + to_hex(value)
concs += " Next:" + hex(
self.nextaddr) if self.nextaddr is not None else ""
padding1 = " " * (25 - len(raw_opc))
padding2 = " " * (16 - len(self.opcode) + len(padding1) + len(raw_opc))
th = self.thread
return "%s t[%d] %s%s%s%s %s" % (address, th, raw_opc, padding1,
self.opcode, padding2, concs)
def deserialize_currency(self): currency = self.get_bytes(20) if currency == ALL_ZEROES: currency = self.native_currency elif _is_iso(currency): currency = currency[12:15] else: currency = utils.to_hex(currency) return currency
def to_string_generator(self):
for i in xrange(self.trace_index):
if i in self.metas:
for m in self.metas[i]:
name_id, arg1, arg2 = m
if name_id == "invalid":
print name_id
elif name_id == "exception":
print "Exception, type:" + str(
arg1) + " handler:" + to_hex(arg2)
elif name_id == "wave":
print "====================== Wave " + str(
arg1) + "======================"
yield "%d %s" % (i, self.instrs[i].to_string())
def __init__(self, wb, game):
self.game = game
self.sheet = wb['sheet1']
# 初始化
self.sheet.append(Config.title_top)
self.sheet.append(Config.title)
if self.game.team_colors is None:
Config.team_colors[self.game.team_names['left']] = utils.to_hex([255, 255, 255])
Config.team_colors[self.game.team_names['right']] = utils.to_hex([70, 70, 70])
Config.team_colors[self.game.team_names['left']] = utils.to_hex(self.game.team_colors['left'])
Config.team_colors[self.game.team_names['right']] = utils.to_hex(self.game.team_colors['right'])
# 上一帧所有玩家的大招状况
self.ultimate_status = {i: False for i in range(1, 13)}
# 上一帧所有玩家的 chara
self.previous_chara = [player.chara for player in self.game.frames[0].players]
# 下一帧所有玩家的 chara
self.next_chara = [player.chara for player in self.game.frames[1].players]
# 当前所有玩家的 玩家名以及信息， 如[(player, chara), ...]
self.player_and_chara = []
self.data = []
async def call_contract_method(client,
ct,
contract_address,
method,
args=None,
*,
sender_pk):
if args is None:
args = []
response = await client.eth_call(get_address(sender_pk),
contract_address,
data=to_hex(
ct.encode_function_call(method,
args)))
try:
result = ct.decode_function_result(method, response)[0]
except IndexError:
raise ValueError('Incorrect result for decoding')
print("Method '%s' result: %s" % (method, result))
return result
def deserialize_int64(self): return utils.to_hex(self.get_bytes(8))
def encode(self, instruction):
if instruction.instruct_type == 'comment':
return instruction.comment
elif instruction.instruct_type == 'directive':
encoded = str(instruction.value)
else:
assert instruction.instruct_type == 'instruction', \
"Instruction type should be a comment, directive, or instruction"
# Label assignment begin
if instruction.rd in self._symbol_table.keys():
instruction.rd = self._symbol_table[instruction.rd]
if instruction.rs in self._symbol_table.keys():
instruction.rs = self._symbol_table[instruction.rs]
if instruction.immediate in self._symbol_table.keys():
instruction.immediate = self._symbol_table[instruction.immediate]
if instruction.branch_addr in self._symbol_table.keys():
instruction.branch_addr = self._symbol_table[instruction.branch_addr]
if instruction.jump_addr in self._symbol_table.keys():
instruction.jump_addr = self._symbol_table[instruction.jump_addr]
# Label assignment end
encoded = ''
encoded += to_hex(instruction.opcode, debug_instruction=instruction)
# alu-type instructions all have 4-bit operands
if instruction.optype == 'alu':
for operand in (instruction.rd, instruction.rs, instruction.funct_code):
operand = self.return_if_int(operand, instruction=instruction)
encoded += to_hex(operand, num_bits=4)
# immediate instruction should have 4-bit registers, and 8 bit immediates
elif instruction.optype == 'alui':
instruction.rd = self.return_if_int(instruction.rd,
instruction=instruction)
instruction.immediate = self.return_if_int(instruction.immediate,
instruction=instruction)
encoded += to_hex(instruction.rd, num_bits=4)
encoded += to_hex(instruction.immediate, num_bits=8, debug_instruction=instruction)
# All fields of mem instructions have 4 bits
elif instruction.optype == 'mem':
for operand in (instruction.rd, instruction.rs, instruction.mem_offset):
operand = self.return_if_int(operand,
instruction=instruction)
encoded += to_hex(operand, num_bits=4)
# Branch offsets are calculated by target address - next pc address,
# then shifted right one bit
elif instruction.optype == 'branch':
instruction.rd = self.return_if_int(instruction.rd,
instruction=instruction)
instruction.branch_addr = self.return_if_int(instruction.branch_addr,
instruction=instruction)
encoded += to_hex(instruction.rd, num_bits=4)
# Calculation of branch offset
next_pc_addr = instruction.addr + self._BYTES_PER_WORD
branch_offset = instruction.branch_addr - next_pc_addr
branch_offset = branch_offset >> 1
encoded += to_hex(branch_offset, num_bits=8)
# Jump field should be 12 bits long.
# Jump addresses are also shifted left one bit.
elif instruction.opname in ('j', 'jal'):
instruction.jump_addr = self.return_if_int(instruction.jump_addr,
instruction=instruction)
if instruction.jump_addr < 0:
raise MemoryError(f"Expected memory value, got {instruction.jump_addr}\n"
f"Instruction: {instruction.content}")
# Calculation of jump addr
jump_addr = instruction.jump_addr >> 1
encoded += zero_extend(jump_addr, num_bits=12)
elif instruction.opname == 'jr':
instruction.jump_addr = self.return_if_int(instruction.jump_addr,
instruction=instruction)
encoded += zero_extend(instruction.jump_addr, num_bits=4)
encoded += '00'
# Parses li pseudoinstruction.
elif instruction.optype == 'pseudo':
assert 'li' in instruction.opname, "Only pseudoinstruction is li"
instruction.rd = self.return_if_int(instruction.rd,
instruction=instruction)
encoded += to_hex(instruction.rd, num_bits=4)
# Depending on lui or ori, takes the first two or last two hex digits.
if instruction.opname == 'li_lui':
instruction.immediate = self.return_if_int(instruction.immediate,
instruction=instruction)
immediate = to_twos_complement(instruction.immediate, num_bits=16)
encoded += to_hex(immediate, num_bits=16)[:2]
elif instruction.opname == 'li_ori':
instruction.immediate = self.return_if_int(instruction.immediate,
instruction=instruction)
immediate = to_twos_complement(instruction.immediate, num_bits=16)
encoded += to_hex(immediate, num_bits=16)[2:]
else:
print(f"Expected li instruction, got {instruction.opname}\n"
f"Instruction: {instruction.content}")
else:
raise SyntaxError(f"Expected proper optype, got {instruction.optype}\n"
f"Instruction: {instruction.content}")
# instructions in hex, so 4 * 4 = 16-bit words
assert len(encoded) == 4, f"Expected hex length 4, got {encoded}\n" \
f"Instruction: {instruction.content}"
# Comments and assembly code
encoded += '; -- ' + repr(instruction.content)
if instruction.comment:
encoded += instruction.comment
assert instruction.addr % 2 == 0, f"Expected word-aligned instruction, got {instruction.content}"
mif_index = zero_extend(instruction.addr // 2, num_bits=16)
encoded = mif_index + ' : ' + encoded
return encoded
def deserialize_hash256(self): return utils.to_hex(self.get_bytes(32))
def deserialize_hash128(self): return utils.to_hex(self.get_bytes(16))
import leveldb
import sys
from utils import to_hex
if __name__ == '__main__':
server_id = sys.argv[1]
idx_ETH = sys.argv[2]
idx_TOK = sys.argv[3]
masked_amt_ETH = to_hex(sys.argv[4])
masked_amt_TOK = to_hex(sys.argv[5])
file = f"Scripts/hbswap/data/Pool-P{server_id}.data"
pool_ETH, pool_TOK = 0, 0
with open(file, 'rb') as f:
pool_ETH = f.read(16)
pool_TOK = f.read(16)
db = leveldb.LevelDB(f"Scripts/hbswap/db/server{server_id}")
mask_share_ETH = bytes(db.Get(idx_ETH.encode()))
mask_share_TOK = bytes(db.Get(idx_TOK.encode()))
file = f"Persistence/Transactions-P{server_id}.data"
with open(file, 'wb') as f:
f.write(pool_ETH + pool_TOK + mask_share_ETH + mask_share_TOK +
masked_amt_ETH + masked_amt_TOK)
from utils import to_bin, to_hex, is_palindrome
with open("dane/dane.txt") as f:
lines = [int(line.strip()) for line in f.readlines()]
bin_palindrome_count = 0
hex_palindrome_count = 0
for num in lines:
num_bin = to_bin(num)
num_hex = to_hex(num)
if is_palindrome(str(num_bin)):
bin_palindrome_count += 1
if is_palindrome(str(num_hex)):
hex_palindrome_count += 1
print(f"{bin_palindrome_count=}, {hex_palindrome_count=}")
def deserialize_hash160(self): return utils.to_hex(self.get_bytes(20))
def parse_flow(flow):
# parse flow fields
# hex(int(mask, 16) & int(data, 16))
if flow['cookie']:
utils.to_hex(flow, 'cookie')
# parse instructions
for instruction in flow['instructions'].get('instruction', []):
if 'write-metadata' in instruction:
utils.to_hex(instruction['write-metadata'], 'metadata')
utils.to_hex(instruction['write-metadata'], 'metadata-mask')
if 'apply-actions' in instruction:
for action in instruction['apply-actions'].get('action', []):
if 'openflowplugin-extension-nicira-action:nx-reg-load' in action:
utils.to_hex(
action[
'openflowplugin-extension-nicira-action:nx-reg-load'],
'value')
# parse matches
if 'metadata' in flow['match']:
metadata = flow['match']['metadata']
utils.to_hex(metadata, 'metadata')
utils.to_hex(metadata, 'metadata-mask')
for ofex in flow['match'].get(
'openflowplugin-extension-general:extension-list', []):
if ofex['extension-key'] == 'openflowplugin-extension-nicira-match:nxm-nx-reg6-key':
utils.to_hex(
ofex['extension']
['openflowplugin-extension-nicira-match:nxm-nx-reg'], 'value')
return flow
def deserialize_vl(self): length = self.deserialize_vl_length() bytes = self.get_bytes(length) return utils.to_hex(bytes).upper()
