def hash(self): """Returns the transaction's id. Equivalent to the hash for non SegWit transactions, it differs from it for SegWit ones. """ if self._hash is None: self._hash = format_hash(double_sha256(self.hex)) return self._hash
def serialize(self): result = NETWORK_MAGIC result += encode_command(self.command) result += int_to_little_endian(len(self.payload), 4) result += double_sha256(self.payload)[:4] result += self.payload return result
def parse_from_hex(self, raw_hex): offset = 4 self._version = decode_uint32(raw_hex[:4]) input_cnt, varint_size = decode_varint(raw_hex[offset:]) self.input_cnt = input_cnt offset += varint_size self._inputs = [] for i in range(input_cnt): tx_input = TransactionInput().parse_from_hex(raw_hex[offset:]) print tx_input.__repr__() offset += tx_input.size self._inputs.append(input) output_cnt, varint_size = decode_varint(raw_hex[offset:]) offset += varint_size self.output_cnt = output_cnt self._outputs = [] for i in range(output_cnt): tx_output = TransactionOutput().parse_from_hex(raw_hex[offset:]) print tx_output.__repr__() offset += tx_output.size self._outputs.append(tx_output) self.size = offset + 4 self.hash = format_hash(double_sha256(raw_hex[:self.size])) return self
def hash(self): '''Returns the double-sha256 interpreted little endian of the block''' # serialize s = self.serialize() # double-sha256 sha = double_sha256(s) # reverse return sha[::-1]
def address(self): """Returns the base58 encoded representation of this address""" if self._address is None: version = b'\x00' if self.type == "normal" else b'\x05' checksum = double_sha256(version + self.hash) self._address = base58.encode(version + self.hash + checksum[:4]) return self._address
async def read_message(reader): magic = await reader.read(4) if magic != NETWORK_MAGIC: raise RuntimeError("Network Magic not at beginning of stream") command = await reader.read(12) payload_length = little_endian_to_int(await reader.read(4)) checksum = await reader.read(4) payload = await reader.read(payload_length) if double_sha256(payload)[:4] != checksum: raise RuntimeError("Payload and Checksum do not match") return Message(command, payload)
def verify_block(self, block): """ 1. hash (block header + nonce) to see if the hash is correct - also verify merkel hash 2. input txns should exist as UTXO 2.1 check scripting signatures and pubkeyscript 2.2 diff of output and input amount == reward in coinbase txn of block this means: block is correct. """ serial = block.get_serialized_block_header(block.nonce) # verifying hash of block hash_hex = double_sha256(serial) if not (hash_hex == block.hash and block.merkle_root == block.get_merkle_root_hash()): return False # block.txns[0] is coinbase [ASSUMPTION] coinbase_future_reward = 0.0 for txn in block.txns[1:]: input_amount = 0.0 for inp_txn in txn.inp_txns: if not self.UTXOdb.search_by_txnid(inp_txn.txnid, inp_txn.vout): return False output_txn = self.UTXOdb.get_txn_by_txnid(inp_txn.txnid).out_txns[inp_txn.vout] if not ScriptInterpreter.verify_pay_to_pubkey_hash( inp_txn.signature_script, output_txn.script_pub_key, inp_txn.txnid ): return False input_amount += output_txn.amount output_amount = 0.0 for out_txn in txn.out_txns: output_amount += out_txn.amount if output_amount > input_amount: return False coinbase_future_reward += (input_amount - output_amount) # verify coinbase coinbase = block.txns[0] if not ((len(coinbase.inp_txns) == 1) and (int(coinbase.inp_txns[0].txnid, 16) == 0) and (int(coinbase.inp_txns[0].vout) == -1) and (len(coinbase.out_txns) == 1)): return False if coinbase.out_txns[0].amount > coinbase_future_reward + config.reward: return False return True
def parse_from_hex(self, raw_hex): assert (len(raw_hex) == 80) self._version = decode_uint32(raw_hex[:4]) self._previous_block_hash = format_hash(raw_hex[4:36]) self._merkle_root = format_hash(raw_hex[36:68]) self._timestamp = decode_uint32(raw_hex[68:72]) self._bits = decode_uint32(raw_hex[72:76]) self._nonce = decode_uint32(raw_hex[76:80]) self._difficulty = self.calc_difficulty(self._bits) self.hash = format_hash(double_sha256(raw_hex)) print self.__repr__() return self
def hash(self): """Returns the transaction's hash""" if self._hash is None: # segwit transactions have two transaction ids/hashes, txid and wtxid # txid is a hash of all of the legacy transaction fields only if self.is_segwit: txid = self.hex[:4] + self.hex[ 6:self._offset_before_tx_witnesses] + self.hex[-4:] else: txid = self.hex self._hash = format_hash(double_sha256(txid)) return self._hash
def txid(self): """Returns the transaction's id. Equivalent to the hash for non SegWit transactions, it differs from it for SegWit ones. """ if self._txid is None: # segwit transactions have two transaction ids/hashes, txid and wtxid # txid is a hash of all of the legacy transaction fields only if self.is_segwit: txid_data = self.hex[:4] + self.hex[ 6:self._offset_before_tx_witnesses] + self.hex[-4:] else: txid_data = self.hex self._txid = format_hash(double_sha256(txid_data)) return self._txid
def parse_from_hex(self, raw_hex): assert (len(raw_hex) == 80) self._version = decode_uint32(raw_hex[:4]) self._previous_block_hash = format_hash(raw_hex[4:36]) self._merkle_root = format_hash(raw_hex[36:68]) self._timestamp = decode_uint32(raw_hex[68:72]) # time_local = decode_uint32(raw_hex[68:72]) # time_local = time.localtime(time_local) # self._timestamp = time.strftime("%Y-%m-%d %H:%M:%S", time_local) self._bits = decode_uint32(raw_hex[72:76]) self._nonce = decode_uint32(raw_hex[76:80]) self._difficulty = self.calc_difficulty(self._bits) self.hash = format_hash(double_sha256(raw_hex)) # print(self.__repr__()) return self
def sign_vote(votestr, mnprivkey): privatekey = utils.wifToPrivateKey(mnprivkey) signingkey = Bip62SigningKey.from_string(privatekey.decode('hex'), curve=ecdsa.SECP256k1) public_key = signingkey.get_verifying_key() key = Key.from_text(mnprivkey) address = key.address(use_uncompressed=True) msghash = utils.double_sha256(utils.msg_magic(votestr)) signature = signingkey.sign_digest_deterministic( msghash, hashfunc=hashlib.sha256, sigencode=ecdsa.util.sigencode_string) assert public_key.verify_digest(signature, msghash, sigdecode=ecdsa.util.sigdecode_string) for i in range(4): sig = base64.b64encode(chr(27 + i) + signature) if verify_dash_signature(generator_secp256k1, address, msghash, sig): return sig
def parse(cls, s): magic = consume_stream(s, 4) if magic != NETWORK_MAGIC: raise ValueError('magic is not right') command = parse_command(consume_stream(s, 12)) payload_length = little_endian_to_int(consume_stream(s, 4)) checksum = consume_stream(s, 4) payload = consume_stream(s, payload_length) calculated_checksum = double_sha256(payload)[:4] if calculated_checksum != checksum: raise RuntimeError('checksum does not match') if payload_length != len(payload): raise RuntimeError( "Tried to read {payload_length} bytes, only received {len(payload)} bytes" ) return cls(command, payload)
def create_txid(self): data = self.get_txn_data() return double_sha256(data)
def get_hash(self, nonce): return double_sha256(self.block.get_serialized_block_header(nonce))
def pow(self): s = self.serialize() sha = double_sha256(s) return little_endian_to_int(sha)
def hash(self): """Returns the block's hash (double sha256 of its 80 bytes header""" if self._hash is None: self._hash = format_hash(double_sha256(self.hex[:80])) return self._hash