idx int64 0 251k | question stringlengths 53 3.53k | target stringlengths 5 1.23k | len_question int64 20 893 | len_target int64 3 238 |
|---|---|---|---|---|
224,600 | def get_subdomain_resolver ( name , db_path = None , zonefiles_dir = None ) : opts = get_blockstack_opts ( ) if not is_subdomains_enabled ( opts ) : log . warn ( "Subdomain support is disabled" ) return None if db_path is None : db_path = opts [ 'subdomaindb_path' ] if zonefiles_dir is None : zonefiles_dir = opts [ 'zonefiles' ] db = SubdomainDB ( db_path , zonefiles_dir ) resolver_url = db . get_domain_resolver ( name ) return resolver_url | Static method for determining the last - known resolver for a domain name . Returns the resolver URL on success Returns None on error | 144 | 26 |
224,601 | def get_subdomains_count ( db_path = None , zonefiles_dir = None ) : opts = get_blockstack_opts ( ) if not is_subdomains_enabled ( opts ) : log . warn ( "Subdomain support is disabled" ) return None if db_path is None : db_path = opts [ 'subdomaindb_path' ] if zonefiles_dir is None : zonefiles_dir = opts [ 'zonefiles' ] db = SubdomainDB ( db_path , zonefiles_dir ) return db . get_subdomains_count ( ) | Static method for getting count of all subdomains Return number of subdomains on success | 133 | 18 |
224,602 | def get_subdomain_DID_info ( fqn , db_path = None , zonefiles_dir = None ) : opts = get_blockstack_opts ( ) if not is_subdomains_enabled ( opts ) : log . warn ( "Subdomain support is disabled" ) return None if db_path is None : db_path = opts [ 'subdomaindb_path' ] if zonefiles_dir is None : zonefiles_dir = opts [ 'zonefiles' ] db = SubdomainDB ( db_path , zonefiles_dir ) try : subrec = db . get_subdomain_entry ( fqn ) except SubdomainNotFound : log . warn ( "No such subdomain: {}" . format ( fqn ) ) return None try : return db . get_subdomain_DID_info ( fqn ) except SubdomainNotFound : return None | Get a subdomain s DID info . Return None if not found | 200 | 13 |
224,603 | def get_DID_subdomain ( did , db_path = None , zonefiles_dir = None , atlasdb_path = None , check_pending = False ) : opts = get_blockstack_opts ( ) if not is_subdomains_enabled ( opts ) : log . warn ( "Subdomain support is disabled" ) return None if db_path is None : db_path = opts [ 'subdomaindb_path' ] if zonefiles_dir is None : zonefiles_dir = opts [ 'zonefiles' ] if atlasdb_path is None : atlasdb_path = opts [ 'atlasdb_path' ] db = SubdomainDB ( db_path , zonefiles_dir ) try : subrec = db . get_DID_subdomain ( did ) except Exception as e : if BLOCKSTACK_DEBUG : log . exception ( e ) log . warn ( "Failed to load subdomain for {}" . format ( did ) ) return None if check_pending : # make sure that all of the zone files between this subdomain's # domain's creation and this subdomain's zone file index are present, # minus the ones that are allowed to be missing. subrec . pending = db . subdomain_check_pending ( subrec , atlasdb_path ) return subrec | Static method for resolving a DID to a subdomain Return the subdomain record on success Return None on error | 295 | 21 |
224,604 | def is_subdomain_zonefile_hash ( fqn , zonefile_hash , db_path = None , zonefiles_dir = None ) : opts = get_blockstack_opts ( ) if not is_subdomains_enabled ( opts ) : return [ ] if db_path is None : db_path = opts [ 'subdomaindb_path' ] if zonefiles_dir is None : zonefiles_dir = opts [ 'zonefiles' ] db = SubdomainDB ( db_path , zonefiles_dir ) zonefile_hashes = db . is_subdomain_zonefile_hash ( fqn , zonefile_hash ) return zonefile_hashes | Static method for getting all historic zone file hashes for a subdomain | 154 | 13 |
224,605 | def get_subdomain_history ( fqn , offset = None , count = None , reverse = False , db_path = None , zonefiles_dir = None , json = False ) : opts = get_blockstack_opts ( ) if not is_subdomains_enabled ( opts ) : return [ ] if db_path is None : db_path = opts [ 'subdomaindb_path' ] if zonefiles_dir is None : zonefiles_dir = opts [ 'zonefiles' ] db = SubdomainDB ( db_path , zonefiles_dir ) recs = db . get_subdomain_history ( fqn , offset = offset , count = count ) if json : recs = [ rec . to_json ( ) for rec in recs ] ret = { } for rec in recs : if rec [ 'block_number' ] not in ret : ret [ rec [ 'block_number' ] ] = [ ] ret [ rec [ 'block_number' ] ] . append ( rec ) if reverse : for block_height in ret : ret [ block_height ] . sort ( lambda r1 , r2 : - 1 if r1 [ 'parent_zonefile_index' ] > r2 [ 'parent_zonefile_index' ] or ( r1 [ 'parent_zonefile_index' ] == r2 [ 'parent_zonefile_index' ] and r1 [ 'zonefile_offset' ] > r2 [ 'zonefile_offset' ] ) else 1 if r1 [ 'parent_zonefile_index' ] < r2 [ 'parent_zonefile_index' ] or ( r1 [ 'parent_zonefile_index' ] == r2 [ 'parent_zonefile_index' ] and r1 [ 'zonefile_offset' ] < r2 [ 'zonefile_offset' ] ) else 0 ) return ret else : return recs | Static method for getting all historic operations on a subdomain | 418 | 11 |
224,606 | def get_all_subdomains ( offset = None , count = None , min_sequence = None , db_path = None , zonefiles_dir = None ) : opts = get_blockstack_opts ( ) if not is_subdomains_enabled ( opts ) : return [ ] if db_path is None : db_path = opts [ 'subdomaindb_path' ] if zonefiles_dir is None : zonefiles_dir = opts [ 'zonefiles' ] db = SubdomainDB ( db_path , zonefiles_dir ) return db . get_all_subdomains ( offset = offset , count = count , min_sequence = None ) | Static method for getting the list of all subdomains | 149 | 11 |
224,607 | def get_subdomain_ops_at_txid ( txid , db_path = None , zonefiles_dir = None ) : opts = get_blockstack_opts ( ) if not is_subdomains_enabled ( opts ) : return [ ] if db_path is None : db_path = opts [ 'subdomaindb_path' ] if zonefiles_dir is None : zonefiles_dir = opts [ 'zonefiles' ] db = SubdomainDB ( db_path , zonefiles_dir ) return db . get_subdomain_ops_at_txid ( txid ) | Static method for getting the list of subdomain operations accepted at a given txid . Includes unaccepted subdomain operations | 135 | 24 |
224,608 | def get_subdomains_owned_by_address ( address , db_path = None , zonefiles_dir = None ) : opts = get_blockstack_opts ( ) if not is_subdomains_enabled ( opts ) : return [ ] if db_path is None : db_path = opts [ 'subdomaindb_path' ] if zonefiles_dir is None : zonefiles_dir = opts [ 'zonefiles' ] db = SubdomainDB ( db_path , zonefiles_dir ) return db . get_subdomains_owned_by_address ( address ) | Static method for getting the list of subdomains for a given address | 133 | 14 |
224,609 | def get_subdomain_last_sequence ( db_path = None , zonefiles_dir = None ) : opts = get_blockstack_opts ( ) if not is_subdomains_enabled ( opts ) : return [ ] if db_path is None : db_path = opts [ 'subdomaindb_path' ] if zonefiles_dir is None : zonefiles_dir = opts [ 'zonefiles' ] db = SubdomainDB ( db_path , zonefiles_dir ) return db . get_last_sequence ( ) | Static method for getting the last sequence number in the database | 121 | 11 |
224,610 | def sign ( privkey_bundle , plaintext ) : if virtualchain . is_singlesig ( privkey_bundle ) : return sign_singlesig ( privkey_bundle , plaintext ) elif virtualchain . is_multisig ( privkey_bundle ) : return sign_multisig ( privkey_bundle , plaintext ) else : raise ValueError ( "private key bundle is neither a singlesig nor multisig bundle" ) | Sign a subdomain plaintext with a private key bundle Returns the base64 - encoded scriptsig | 102 | 19 |
224,611 | def subdomains_init ( blockstack_opts , working_dir , atlas_state ) : if not is_subdomains_enabled ( blockstack_opts ) : return None subdomain_state = SubdomainIndex ( blockstack_opts [ 'subdomaindb_path' ] , blockstack_opts = blockstack_opts ) atlas_node_add_callback ( atlas_state , 'store_zonefile' , subdomain_state . enqueue_zonefile ) return subdomain_state | Set up subdomain state Returns a SubdomainIndex object that has been successfully connected to Atlas | 115 | 18 |
224,612 | def verify_signature ( self , addr ) : return verify ( virtualchain . address_reencode ( addr ) , self . get_plaintext_to_sign ( ) , self . sig ) | Given an address verify whether or not it was signed by it | 42 | 12 |
224,613 | def serialize_to_txt ( self ) : txtrec = { 'name' : self . fqn if self . independent else self . subdomain , 'txt' : self . pack_subdomain ( ) [ 1 : ] } return blockstack_zones . record_processors . process_txt ( [ txtrec ] , '{txt}' ) . strip ( ) | Serialize this subdomain record to a TXT record . The trailing newline will be omitted | 84 | 19 |
224,614 | def parse_subdomain_missing_zonefiles_record ( cls , rec ) : txt_entry = rec [ 'txt' ] if isinstance ( txt_entry , list ) : raise ParseError ( "TXT entry too long for a missing zone file list" ) try : return [ int ( i ) for i in txt_entry . split ( ',' ) ] if txt_entry is not None and len ( txt_entry ) > 0 else [ ] except ValueError : raise ParseError ( 'Invalid integers' ) | Parse a missing - zonefiles vector given by the domain . Returns the list of zone file indexes on success Raises ParseError on unparseable records | 118 | 32 |
224,615 | def get_public_key ( self ) : res = self . get_public_key_info ( ) if 'error' in res : raise ValueError ( res [ 'error' ] ) if res [ 'type' ] != 'singlesig' : raise ValueError ( res [ 'error' ] ) return res [ 'public_keys' ] [ 0 ] | Parse the scriptSig and extract the public key . Raises ValueError if this is a multisig - controlled subdomain . | 78 | 28 |
224,616 | def close ( self ) : with self . subdomain_db_lock : self . subdomain_db . close ( ) self . subdomain_db = None self . subdomain_db_path = None | Close the index | 44 | 3 |
224,617 | def make_new_subdomain_history ( self , cursor , subdomain_rec ) : # what's the subdomain's history up until this subdomain record? hist = self . subdomain_db . get_subdomain_history ( subdomain_rec . get_fqn ( ) , include_unaccepted = True , end_sequence = subdomain_rec . n + 1 , end_zonefile_index = subdomain_rec . parent_zonefile_index + 1 , cur = cursor ) assert len ( hist ) > 0 , 'BUG: not yet stored: {}' . format ( subdomain_rec ) for i in range ( 0 , len ( hist ) ) : hist [ i ] . accepted = False hist . sort ( lambda h1 , h2 : - 1 if h1 . n < h2 . n or ( h1 . n == h2 . n and h1 . parent_zonefile_index < h2 . parent_zonefile_index ) else 0 if h1 . n == h2 . n and h1 . parent_zonefile_index == h2 . parent_zonefile_index else 1 ) if not self . check_initial_subdomain ( hist [ 0 ] ) : log . debug ( "Reject initial {}" . format ( hist [ 0 ] ) ) return hist else : log . debug ( "Accept initial {}" . format ( hist [ 0 ] ) ) pass hist [ 0 ] . accepted = True last_accepted = 0 for i in xrange ( 1 , len ( hist ) ) : if self . check_subdomain_transition ( hist [ last_accepted ] , hist [ i ] ) : log . debug ( "Accept historic update {}" . format ( hist [ i ] ) ) hist [ i ] . accepted = True last_accepted = i else : log . debug ( "Reject historic update {}" . format ( hist [ i ] ) ) hist [ i ] . accepted = False return hist | Recalculate the history for this subdomain from genesis up until this record . Returns the list of subdomain records we need to save . | 423 | 29 |
224,618 | def make_new_subdomain_future ( self , cursor , subdomain_rec ) : assert subdomain_rec . accepted , 'BUG: given subdomain record must already be accepted' # what's the subdomain's future after this record? fut = self . subdomain_db . get_subdomain_history ( subdomain_rec . get_fqn ( ) , include_unaccepted = True , start_sequence = subdomain_rec . n , start_zonefile_index = subdomain_rec . parent_zonefile_index , cur = cursor ) for i in range ( 0 , len ( fut ) ) : if fut [ i ] . n == subdomain_rec . n and fut [ i ] . parent_zonefile_index == subdomain_rec . parent_zonefile_index : fut . pop ( i ) break if len ( fut ) == 0 : log . debug ( "At tip: {}" . format ( subdomain_rec ) ) return [ ] for i in range ( 0 , len ( fut ) ) : fut [ i ] . accepted = False fut = [ subdomain_rec ] + fut fut . sort ( lambda h1 , h2 : - 1 if h1 . n < h2 . n or ( h1 . n == h2 . n and h1 . parent_zonefile_index < h2 . parent_zonefile_index ) else 0 if h1 . n == h2 . n and h1 . parent_zonefile_index == h2 . parent_zonefile_index else 1 ) assert fut [ 0 ] . accepted , 'BUG: initial subdomain record is not accepted: {}' . format ( fut [ 0 ] ) last_accepted = 0 for i in range ( 1 , len ( fut ) ) : if self . check_subdomain_transition ( fut [ last_accepted ] , fut [ i ] ) : log . debug ( "Accept future update {}" . format ( fut [ i ] ) ) fut [ i ] . accepted = True last_accepted = i else : log . debug ( "Reject future update {}" . format ( fut [ i ] ) ) fut [ i ] . accepted = False return fut | Recalculate the future for this subdomain from the current record until the latest known record . Returns the list of subdomain records we need to save . | 471 | 32 |
224,619 | def subdomain_try_insert ( self , cursor , subdomain_rec , history_neighbors ) : blockchain_order = history_neighbors [ 'prev' ] + history_neighbors [ 'cur' ] + history_neighbors [ 'fut' ] last_accepted = - 1 for i in range ( 0 , len ( blockchain_order ) ) : if blockchain_order [ i ] . accepted : last_accepted = i break if blockchain_order [ i ] . n > subdomain_rec . n or ( blockchain_order [ i ] . n == subdomain_rec . n and blockchain_order [ i ] . parent_zonefile_index > subdomain_rec . parent_zonefile_index ) : # can't cheaply insert this subdomain record, # since none of its immediate ancestors are accepted. log . debug ( "No immediate ancestors are accepted on {}" . format ( subdomain_rec ) ) return False if last_accepted < 0 : log . debug ( "No immediate ancestors or successors are accepted on {}" . format ( subdomain_rec ) ) return False # one ancestor was accepted. # work from there. chain_tip_status = blockchain_order [ - 1 ] . accepted dirty = [ ] # to be written for i in range ( last_accepted + 1 , len ( blockchain_order ) ) : cur_accepted = blockchain_order [ i ] . accepted new_accepted = self . check_subdomain_transition ( blockchain_order [ last_accepted ] , blockchain_order [ i ] ) if new_accepted != cur_accepted : blockchain_order [ i ] . accepted = new_accepted log . debug ( "Changed from {} to {}: {}" . format ( cur_accepted , new_accepted , blockchain_order [ i ] ) ) dirty . append ( blockchain_order [ i ] ) if new_accepted : last_accepted = i if chain_tip_status != blockchain_order [ - 1 ] . accepted and len ( history_neighbors [ 'fut' ] ) > 0 : # deeper reorg log . debug ( "Immediate history chain tip altered from {} to {}: {}" . format ( chain_tip_status , blockchain_order [ - 1 ] . accepted , blockchain_order [ - 1 ] ) ) return False # localized change. Just commit the dirty entries for subrec in dirty : log . debug ( "Update to accepted={}: {}" . format ( subrec . accepted , subrec ) ) self . subdomain_db . update_subdomain_entry ( subrec , cur = cursor ) return True | Try to insert a subdomain record into its history neighbors . This is an optimization that handles the usual case . | 567 | 22 |
224,620 | def enqueue_zonefile ( self , zonefile_hash , block_height ) : with self . serialized_enqueue_zonefile : log . debug ( "Append {} from {}" . format ( zonefile_hash , block_height ) ) queuedb_append ( self . subdomain_queue_path , "zonefiles" , zonefile_hash , json . dumps ( { 'zonefile_hash' : zonefile_hash , 'block_height' : block_height } ) ) | Called when we discover a zone file . Queues up a request to reprocess this name s zone files subdomains . zonefile_hash is the hash of the zonefile . block_height is the minimium block height at which this zone file occurs . | 109 | 54 |
224,621 | def index_blockchain ( self , block_start , block_end ) : log . debug ( "Processing subdomain updates for zonefiles in blocks {}-{}" . format ( block_start , block_end ) ) res = self . find_zonefile_subdomains ( block_start , block_end ) zonefile_subdomain_info = res [ 'zonefile_info' ] self . process_subdomains ( zonefile_subdomain_info ) | Go through the sequence of zone files discovered in a block range and reindex the names subdomains . | 102 | 21 |
224,622 | def subdomain_row_factory ( cls , cursor , row ) : d = { } for idx , col in enumerate ( cursor . description ) : d [ col [ 0 ] ] = row [ idx ] return d | Dict row factory for subdomains | 50 | 8 |
224,623 | def _extract_subdomain ( self , rowdata ) : name = str ( rowdata [ 'fully_qualified_subdomain' ] ) domain = str ( rowdata [ 'domain' ] ) n = str ( rowdata [ 'sequence' ] ) encoded_pubkey = str ( rowdata [ 'owner' ] ) zonefile_hash = str ( rowdata [ 'zonefile_hash' ] ) sig = rowdata [ 'signature' ] block_height = int ( rowdata [ 'block_height' ] ) parent_zonefile_hash = str ( rowdata [ 'parent_zonefile_hash' ] ) parent_zonefile_index = int ( rowdata [ 'parent_zonefile_index' ] ) zonefile_offset = int ( rowdata [ 'zonefile_offset' ] ) txid = str ( rowdata [ 'txid' ] ) missing = [ int ( i ) for i in rowdata [ 'missing' ] . split ( ',' ) ] if rowdata [ 'missing' ] is not None and len ( rowdata [ 'missing' ] ) > 0 else [ ] accepted = int ( rowdata [ 'accepted' ] ) resolver = str ( rowdata [ 'resolver' ] ) if rowdata [ 'resolver' ] is not None else None if accepted == 0 : accepted = False else : accepted = True if sig == '' or sig is None : sig = None else : sig = str ( sig ) name = str ( name ) is_subdomain , _ , _ = is_address_subdomain ( name ) if not is_subdomain : raise Exception ( "Subdomain DB lookup returned bad subdomain result {}" . format ( name ) ) zonefile_str = get_atlas_zonefile_data ( zonefile_hash , self . zonefiles_dir ) if zonefile_str is None : log . error ( "No zone file for {}" . format ( name ) ) raise SubdomainNotFound ( '{}: missing zone file {}' . format ( name , zonefile_hash ) ) return Subdomain ( str ( name ) , str ( domain ) , str ( encoded_pubkey ) , int ( n ) , str ( zonefile_str ) , sig , block_height , parent_zonefile_hash , parent_zonefile_index , zonefile_offset , txid , domain_zonefiles_missing = missing , accepted = accepted , resolver = resolver ) | Extract a single subdomain from a DB cursor Raise SubdomainNotFound if there are no valid rows | 526 | 21 |
224,624 | def get_subdomains_count ( self , accepted = True , cur = None ) : if accepted : accepted_filter = 'WHERE accepted=1' else : accepted_filter = '' get_cmd = "SELECT COUNT(DISTINCT fully_qualified_subdomain) as count FROM {} {};" . format ( self . subdomain_table , accepted_filter ) cursor = cur if cursor is None : cursor = self . conn . cursor ( ) db_query_execute ( cursor , get_cmd , ( ) ) try : rowdata = cursor . fetchone ( ) return rowdata [ 'count' ] except Exception as e : if BLOCKSTACK_DEBUG : log . exception ( e ) return 0 | Fetch subdomain names | 153 | 5 |
224,625 | def get_all_subdomains ( self , offset = None , count = None , min_sequence = None , cur = None ) : get_cmd = 'SELECT DISTINCT fully_qualified_subdomain FROM {}' . format ( self . subdomain_table ) args = ( ) if min_sequence is not None : get_cmd += ' WHERE sequence >= ?' args += ( min_sequence , ) if count is not None : get_cmd += ' LIMIT ?' args += ( count , ) if offset is not None : get_cmd += ' OFFSET ?' args += ( offset , ) get_cmd += ';' cursor = None if cur is None : cursor = self . conn . cursor ( ) else : cursor = cur rows = db_query_execute ( cursor , get_cmd , args ) subdomains = [ ] for row in rows : subdomains . append ( row [ 'fully_qualified_subdomain' ] ) return subdomains | Get and all subdomain names optionally over a range | 210 | 10 |
224,626 | def get_subdomain_ops_at_txid ( self , txid , cur = None ) : get_cmd = 'SELECT * FROM {} WHERE txid = ? ORDER BY zonefile_offset' . format ( self . subdomain_table ) cursor = None if cur is None : cursor = self . conn . cursor ( ) else : cursor = cur db_query_execute ( cursor , get_cmd , ( txid , ) ) try : return [ x for x in cursor . fetchall ( ) ] except Exception as e : if BLOCKSTACK_DEBUG : log . exception ( e ) return [ ] | Given a txid get all subdomain operations at that txid . Include unaccepted operations . Order by zone file index | 131 | 25 |
224,627 | def get_subdomains_owned_by_address ( self , owner , cur = None ) : get_cmd = "SELECT fully_qualified_subdomain, MAX(sequence) FROM {} WHERE owner = ? AND accepted=1 GROUP BY fully_qualified_subdomain" . format ( self . subdomain_table ) cursor = None if cur is None : cursor = self . conn . cursor ( ) else : cursor = cur db_query_execute ( cursor , get_cmd , ( owner , ) ) try : return [ x [ 'fully_qualified_subdomain' ] for x in cursor . fetchall ( ) ] except Exception as e : if BLOCKSTACK_DEBUG : log . exception ( e ) return [ ] | Get the list of subdomain names that are owned by a given address . | 154 | 15 |
224,628 | def get_domain_resolver ( self , domain_name , cur = None ) : get_cmd = "SELECT resolver FROM {} WHERE domain=? AND resolver != '' AND accepted=1 ORDER BY sequence DESC, parent_zonefile_index DESC LIMIT 1;" . format ( self . subdomain_table ) cursor = None if cur is None : cursor = self . conn . cursor ( ) else : cursor = cur db_query_execute ( cursor , get_cmd , ( domain_name , ) ) rowdata = cursor . fetchone ( ) if not rowdata : return None return rowdata [ 'resolver' ] | Get the last - knwon resolver entry for a domain name Returns None if not found . | 136 | 19 |
224,629 | def get_subdomain_DID_info ( self , fqn , cur = None ) : subrec = self . get_subdomain_entry_at_sequence ( fqn , 0 , cur = cur ) cmd = 'SELECT zonefile_offset FROM {} WHERE fully_qualified_subdomain = ? AND owner = ? AND sequence=0 AND parent_zonefile_index <= ? AND accepted=1 ORDER BY parent_zonefile_index, zonefile_offset LIMIT 1;' . format ( self . subdomain_table ) args = ( fqn , subrec . address , subrec . parent_zonefile_index ) cursor = None if cur is None : cursor = self . conn . cursor ( ) else : cursor = cur rows = db_query_execute ( cursor , cmd , args ) zonefile_offset = None for r in rows : zonefile_offset = r [ 'zonefile_offset' ] break if zonefile_offset is None : raise SubdomainNotFound ( 'No rows for {}' . format ( fqn ) ) cmd = 'SELECT COUNT(*) FROM {} WHERE owner = ? AND sequence=0 AND (parent_zonefile_index < ? OR parent_zonefile_index = ? AND zonefile_offset < ?) AND accepted=1 ORDER BY parent_zonefile_index, zonefile_offset LIMIT 1;' . format ( self . subdomain_table ) args = ( subrec . address , subrec . parent_zonefile_index , subrec . parent_zonefile_index , zonefile_offset ) rows = db_query_execute ( cursor , cmd , args ) count = None for r in rows : count = r [ 'COUNT(*)' ] break if count is None : raise SubdomainNotFound ( 'No rows for {}' . format ( fqn ) ) return { 'name_type' : 'subdomain' , 'address' : subrec . address , 'index' : count } | Get the DID information for a subdomain . Raise SubdomainNotFound if there is no such subdomain | 424 | 21 |
224,630 | def get_DID_subdomain ( self , did , cur = None ) : did = str ( did ) try : did_info = parse_DID ( did ) assert did_info [ 'name_type' ] == 'subdomain' , 'Not a subdomain DID' except : raise ValueError ( "Invalid DID: {}" . format ( did ) ) original_address = did_info [ 'address' ] name_index = did_info [ 'index' ] # find the initial subdomain (the nth subdomain created by this address) cmd = 'SELECT fully_qualified_subdomain FROM {} WHERE owner = ? AND sequence = ? ORDER BY parent_zonefile_index, zonefile_offset LIMIT 1 OFFSET ?;' . format ( self . subdomain_table ) args = ( original_address , 0 , name_index ) cursor = None if cur is None : cursor = self . conn . cursor ( ) else : cursor = cur subdomain_name = None rows = db_query_execute ( cursor , cmd , args ) for r in rows : subdomain_name = r [ 'fully_qualified_subdomain' ] break if not subdomain_name : raise SubdomainNotFound ( 'Does not correspond to a subdomain: {}' . format ( did ) ) # get the current form subrec = self . get_subdomain_entry ( subdomain_name , cur = cur ) subrec . did_info = did_info return subrec | Get a subdomain given its DID Raise ValueError if the DID is invalid Raise SubdomainNotFound if the DID does not correspond to a subdomain | 318 | 30 |
224,631 | def is_subdomain_zonefile_hash ( self , fqn , zonefile_hash , cur = None ) : sql = 'SELECT COUNT(zonefile_hash) FROM {} WHERE fully_qualified_subdomain = ? and zonefile_hash = ?;' . format ( self . subdomain_table ) args = ( fqn , zonefile_hash ) cursor = None if cur is None : cursor = self . conn . cursor ( ) else : cursor = cur rows = db_query_execute ( cursor , sql , args ) count = None for row in rows : count = row [ 'COUNT(zonefile_hash)' ] break return ( count > 0 ) | Does this zone file hash belong to this subdomain? | 146 | 11 |
224,632 | def update_subdomain_entry ( self , subdomain_obj , cur = None ) : # sanity checks assert isinstance ( subdomain_obj , Subdomain ) # NOTE: there is no need to call fsync() on the zone file fd here---we already have the data from the on-chain name's zone file fsync'ed, # so this information is already durable (albeit somewhere else) and can ostensibly be restored later. # We get such high subdomain traffic that we cannot call fsync() here each time; otherwise we could stall the node. zonefile_hash = get_zonefile_data_hash ( subdomain_obj . zonefile_str ) rc = store_atlas_zonefile_data ( subdomain_obj . zonefile_str , self . zonefiles_dir , fsync = False ) if not rc : raise Exception ( "Failed to store zone file {} from {}" . format ( zonefile_hash , subdomain_obj . get_fqn ( ) ) ) write_cmd = 'INSERT OR REPLACE INTO {} VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)' . format ( self . subdomain_table ) args = ( subdomain_obj . get_fqn ( ) , subdomain_obj . domain , subdomain_obj . n , subdomain_obj . address , zonefile_hash , subdomain_obj . sig , subdomain_obj . block_height , subdomain_obj . parent_zonefile_hash , subdomain_obj . parent_zonefile_index , subdomain_obj . zonefile_offset , subdomain_obj . txid , ',' . join ( str ( i ) for i in subdomain_obj . domain_zonefiles_missing ) , 1 if subdomain_obj . accepted else 0 , subdomain_obj . resolver ) cursor = None if cur is None : cursor = self . conn . cursor ( ) else : cursor = cur db_query_execute ( cursor , write_cmd , args ) num_rows_written = cursor . rowcount if cur is None : # not part of a transaction self . conn . commit ( ) if num_rows_written != 1 : raise ValueError ( "No row written: fqn={} seq={}" . format ( subdomain_obj . get_fqn ( ) , subdomain_obj . n ) ) return True | Update the subdomain history table for this subdomain entry . Creates it if it doesn t exist . | 516 | 21 |
224,633 | def get_last_block ( self , cur = None ) : sql = 'SELECT MAX(block_height) FROM {};' . format ( self . subdomain_table ) cursor = None if cur is None : cursor = self . conn . cursor ( ) else : cursor = cur rows = db_query_execute ( cursor , sql , ( ) ) height = 0 try : rowdata = rows . fetchone ( ) height = rowdata [ 'MAX(block_height)' ] except : height = 0 return height | Get the highest block last processed | 109 | 6 |
224,634 | def get_last_sequence ( self , cur = None ) : sql = 'SELECT sequence FROM {} ORDER BY sequence DESC LIMIT 1;' . format ( self . subdomain_table ) cursor = None if cur is None : cursor = self . conn . cursor ( ) else : cursor = cur db_query_execute ( cursor , sql , ( ) ) last_seq = None try : last_seq = cursor . fetchone ( ) [ 0 ] except : last_seq = 0 return int ( last_seq ) | Get the highest sequence number in this db | 110 | 8 |
224,635 | def _drop_tables ( self ) : drop_cmd = "DROP TABLE IF EXISTS {};" for table in [ self . subdomain_table , self . blocked_table ] : cursor = self . conn . cursor ( ) db_query_execute ( cursor , drop_cmd . format ( table ) , ( ) ) | Clear the subdomain db s tables | 72 | 7 |
224,636 | def hash_name ( name , script_pubkey , register_addr = None ) : bin_name = b40_to_bin ( name ) name_and_pubkey = bin_name + unhexlify ( script_pubkey ) if register_addr is not None : name_and_pubkey += str ( register_addr ) return hex_hash160 ( name_and_pubkey ) | Generate the hash over a name and hex - string script pubkey | 87 | 14 |
224,637 | def fetch_profile_data_from_file ( ) : with open ( SEARCH_PROFILE_DATA_FILE , 'r' ) as fin : profiles = json . load ( fin ) counter = 0 log . debug ( "-" * 5 ) log . debug ( "Fetching profile data from file" ) for entry in profiles : new_entry = { } new_entry [ 'key' ] = entry [ 'fqu' ] new_entry [ 'value' ] = entry [ 'profile' ] try : clean_profile_entries ( entry [ 'profile' ] ) profile_data . save ( new_entry ) except Exception as e : log . exception ( e ) log . error ( "Exception on entry {}" . format ( new_entry ) ) counter += 1 if counter % 1000 == 0 : log . debug ( "Processed entries: %s" % counter ) profile_data . ensure_index ( 'key' ) return | takes profile data from file and saves in the profile_data DB | 202 | 14 |
224,638 | def create_search_index ( ) : # create people name cache counter = 0 people_names = [ ] twitter_handles = [ ] usernames = [ ] log . debug ( "-" * 5 ) log . debug ( "Creating search index" ) for user in namespace . find ( ) : # the profile/info to be inserted search_profile = { } counter += 1 if ( counter % 1000 == 0 ) : log . debug ( "Processed entries: %s" % counter ) if validUsername ( user [ 'username' ] ) : pass else : continue profile = get_json ( user [ 'profile' ] ) hasBazaarId = False # search for openbazaar id in the profile if 'account' in profile : for accounts in profile [ 'account' ] : if accounts [ 'service' ] == 'openbazaar' : hasBazaarId = True search_profile [ 'openbazaar' ] = accounts [ 'identifier' ] if ( hasBazaarId == False ) : search_profile [ 'openbazaar' ] = None if 'name' in profile : try : name = profile [ 'name' ] except : continue try : name = name [ 'formatted' ] . lower ( ) except : name = name . lower ( ) people_names . append ( name ) search_profile [ 'name' ] = name else : search_profile [ 'name' ] = None if 'twitter' in profile : twitter_handle = profile [ 'twitter' ] try : twitter_handle = twitter_handle [ 'username' ] . lower ( ) except : try : twitter_handle = profile [ 'twitter' ] . lower ( ) except : continue twitter_handles . append ( twitter_handle ) search_profile [ 'twitter_handle' ] = twitter_handle else : search_profile [ 'twitter_handle' ] = None search_profile [ 'fullyQualifiedName' ] = user [ 'fqu' ] search_profile [ 'username' ] = user [ 'username' ] usernames . append ( user [ 'fqu' ] ) search_profile [ 'profile' ] = profile search_profiles . save ( search_profile ) # dedup names people_names = list ( set ( people_names ) ) people_names = { 'name' : people_names } twitter_handles = list ( set ( twitter_handles ) ) twitter_handles = { 'twitter_handle' : twitter_handles } usernames = list ( set ( usernames ) ) usernames = { 'username' : usernames } # save final dedup results to mongodb (using it as a cache) people_cache . save ( people_names ) twitter_cache . save ( twitter_handles ) username_cache . save ( usernames ) optimize_db ( ) log . debug ( 'Created name/twitter/username search index' ) | takes people names from blockchain and writes deduped names in a cache | 623 | 15 |
224,639 | def op_extract ( op_name , data , senders , inputs , outputs , block_id , vtxindex , txid ) : global EXTRACT_METHODS if op_name not in EXTRACT_METHODS . keys ( ) : raise Exception ( "No such operation '%s'" % op_name ) method = EXTRACT_METHODS [ op_name ] op_data = method ( data , senders , inputs , outputs , block_id , vtxindex , txid ) return op_data | Extract an operation from transaction data . Return the extracted fields as a dict . | 114 | 16 |
224,640 | def op_canonicalize ( op_name , parsed_op ) : global CANONICALIZE_METHODS if op_name not in CANONICALIZE_METHODS : # no canonicalization needed return parsed_op else : return CANONICALIZE_METHODS [ op_name ] ( parsed_op ) | Get the canonical representation of a parsed operation s data . Meant for backwards - compatibility | 67 | 17 |
224,641 | def op_decanonicalize ( op_name , canonical_op ) : global DECANONICALIZE_METHODS if op_name not in DECANONICALIZE_METHODS : # no decanonicalization needed return canonical_op else : return DECANONICALIZE_METHODS [ op_name ] ( canonical_op ) | Get the current representation of a parsed operation s data given the canonical representation Meant for backwards - compatibility | 73 | 20 |
224,642 | def op_check ( state_engine , nameop , block_id , checked_ops ) : global CHECK_METHODS , MUTATE_FIELDS nameop_clone = copy . deepcopy ( nameop ) opcode = None if 'opcode' not in nameop_clone . keys ( ) : op = nameop_clone . get ( 'op' , None ) try : assert op is not None , "BUG: no op defined" opcode = op_get_opcode_name ( op ) assert opcode is not None , "BUG: op '%s' undefined" % op except Exception , e : log . exception ( e ) log . error ( "FATAL: BUG: no 'op' defined" ) sys . exit ( 1 ) else : opcode = nameop_clone [ 'opcode' ] check_method = CHECK_METHODS . get ( opcode , None ) try : assert check_method is not None , "BUG: no check-method for '%s'" % opcode except Exception , e : log . exception ( e ) log . error ( "FATAL: BUG: no check-method for '%s'" % opcode ) sys . exit ( 1 ) rc = check_method ( state_engine , nameop_clone , block_id , checked_ops ) if not rc : # rejected return False # accepted! clean up and canonicalize nameop . clear ( ) nameop . update ( nameop_clone ) # nameop = op_canonicalize(nameop['opcode'], nameop) op_canonicalize ( nameop [ 'opcode' ] , nameop ) # make sure we don't send unstored fields to the db that are otherwise canonical unstored_canonical_fields = UNSTORED_CANONICAL_FIELDS . get ( nameop [ 'opcode' ] ) assert unstored_canonical_fields is not None , "BUG: no UNSTORED_CANONICAL_FIELDS entry for {}" . format ( nameop [ 'opcode' ] ) for f in unstored_canonical_fields : if f in nameop : del nameop [ f ] return rc | Given the state engine the current block the list of pending operations processed so far and the current operation determine whether or not it should be accepted . | 475 | 28 |
224,643 | def op_get_mutate_fields ( op_name ) : global MUTATE_FIELDS if op_name not in MUTATE_FIELDS . keys ( ) : raise Exception ( "No such operation '%s'" % op_name ) fields = MUTATE_FIELDS [ op_name ] [ : ] return fields | Get the names of the fields that will change when this operation gets applied to a record . | 76 | 18 |
224,644 | def op_get_consensus_fields ( op_name ) : global SERIALIZE_FIELDS if op_name not in SERIALIZE_FIELDS . keys ( ) : raise Exception ( "No such operation '%s'" % op_name ) fields = SERIALIZE_FIELDS [ op_name ] [ : ] return fields | Get the set of consensus - generating fields for an operation . | 76 | 12 |
224,645 | def check ( state_engine , nameop , block_id , checked_ops ) : name_consensus_hash = nameop [ 'name_consensus_hash' ] sender = nameop [ 'sender' ] # deny updates if we exceed quota--the only legal operations are to revoke or transfer. sender_names = state_engine . get_names_owned_by_sender ( sender ) if len ( sender_names ) > MAX_NAMES_PER_SENDER : log . warning ( "Sender '%s' has exceeded quota: only transfers or revokes are allowed" % ( sender ) ) return False name , consensus_hash = state_engine . get_name_from_name_consensus_hash ( name_consensus_hash , sender , block_id ) # name must exist if name is None or consensus_hash is None : log . warning ( "Unable to resolve name consensus hash '%s' to a name owned by '%s'" % ( name_consensus_hash , sender ) ) # nothing to do--write is stale or on a fork return False namespace_id = get_namespace_from_name ( name ) name_rec = state_engine . get_name ( name ) if name_rec is None : log . warning ( "Name '%s' does not exist" % name ) return False # namespace must be ready if not state_engine . is_namespace_ready ( namespace_id ) : # non-existent namespace log . warning ( "Namespace '%s' is not ready" % ( namespace_id ) ) return False # name must not be revoked if state_engine . is_name_revoked ( name ) : log . warning ( "Name '%s' is revoked" % name ) return False # name must not be expired as of the *last block processed* if state_engine . is_name_expired ( name , state_engine . lastblock ) : log . warning ( "Name '%s' is expired" % name ) return False # name must not be in grace period in *this* block if state_engine . is_name_in_grace_period ( name , block_id ) : log . warning ( "Name '{}' is in the renewal grace period. It can only be renewed at this time." . format ( name ) ) return False # the name must be registered if not state_engine . is_name_registered ( name ) : # doesn't exist log . warning ( "Name '%s' is not registered" % name ) return False # the name must be owned by the same person who sent this nameop if not state_engine . is_name_owner ( name , sender ) : # wrong owner log . warning ( "Name '%s' is not owned by '%s'" % ( name , sender ) ) return False # remember the name and consensus hash, so we don't have to re-calculate it... nameop [ 'name' ] = name nameop [ 'consensus_hash' ] = consensus_hash nameop [ 'sender_pubkey' ] = name_rec [ 'sender_pubkey' ] # not stored, but re-calculateable del nameop [ 'name_consensus_hash' ] return True | Verify the validity of an update to a name s associated data . Use the nameop s 128 - bit name hash to find the name itself . | 708 | 30 |
224,646 | def genesis_block_audit ( genesis_block_stages , key_bundle = GENESIS_BLOCK_SIGNING_KEYS ) : gpg2_path = find_gpg2 ( ) if gpg2_path is None : raise Exception ( 'You must install gpg2 to audit the genesis block, and it must be in your PATH' ) log . debug ( 'Loading {} signing key(s)...' . format ( len ( key_bundle ) ) ) res = load_signing_keys ( gpg2_path , [ key_bundle [ kid ] for kid in key_bundle ] ) if not res : raise Exception ( 'Failed to install signing keys' ) log . debug ( 'Verifying {} signing key(s)...' . format ( len ( key_bundle ) ) ) res = check_gpg2_keys ( gpg2_path , key_bundle . keys ( ) ) if not res : raise Exception ( 'Failed to verify installation of signing keys' ) d = tempfile . mkdtemp ( prefix = '.genesis-block-audit-' ) # each entry in genesis_block_stages is a genesis block with its own history for stage_id , stage in enumerate ( genesis_block_stages ) : log . debug ( 'Verify stage {}' . format ( stage_id ) ) try : jsonschema . validate ( GENESIS_BLOCK_SCHEMA , stage ) except jsonschema . ValidationError : shutil . rmtree ( d ) log . error ( 'Invalid genesis block -- does not match schema' ) raise ValueError ( 'Invalid genesis block' ) # all history rows must be signed with a trusted key for history_id , history_row in enumerate ( stage [ 'history' ] ) : with open ( os . path . join ( d , 'sig' ) , 'w' ) as f : f . write ( history_row [ 'signature' ] ) with open ( os . path . join ( d , 'hash' ) , 'w' ) as f : f . write ( history_row [ 'hash' ] ) p = subprocess . Popen ( [ gpg2_path , '--verify' , os . path . join ( d , 'sig' ) , os . path . join ( d , 'hash' ) ] , stdout = subprocess . PIPE , stderr = subprocess . PIPE ) out , err = p . communicate ( ) if p . returncode != 0 : log . error ( 'Failed to verify stage {} history {}' . format ( stage_id , history_id ) ) shutil . rmtree ( d ) return False gb_rows_str = json . dumps ( stage [ 'rows' ] , sort_keys = True , separators = ( ',' , ':' ) ) + '\n' gb_rows_hash = hashlib . sha256 ( gb_rows_str ) . hexdigest ( ) # must match final history row if gb_rows_hash != stage [ 'history' ] [ - 1 ] [ 'hash' ] : log . error ( 'Genesis block stage {} hash mismatch: {} != {}' . format ( stage_id , gb_rows_hash , stage [ 'history' ] [ - 1 ] [ 'hash' ] ) ) shutil . rmtree ( d ) return False shutil . rmtree ( d ) log . info ( 'Genesis block is legitimate' ) return True | Verify the authenticity of the stages of the genesis block optionally with a given set of keys . Return True if valid Return False if not | 773 | 27 |
224,647 | def is_profile_in_legacy_format ( profile ) : if isinstance ( profile , dict ) : pass elif isinstance ( profile , ( str , unicode ) ) : try : profile = json . loads ( profile ) except ValueError : return False else : return False if "@type" in profile : return False if "@context" in profile : return False is_in_legacy_format = False if "avatar" in profile : is_in_legacy_format = True elif "cover" in profile : is_in_legacy_format = True elif "bio" in profile : is_in_legacy_format = True elif "twitter" in profile : is_in_legacy_format = True elif "facebook" in profile : is_in_legacy_format = True return is_in_legacy_format | Is a given profile JSON object in legacy format? | 188 | 10 |
224,648 | def format_profile ( profile , fqa , zone_file , address , public_key ) : # if the zone file is a string, then parse it if isinstance ( zone_file , ( str , unicode ) ) : try : zone_file = blockstack_zones . parse_zone_file ( zone_file ) except : # leave as text pass data = { 'profile' : profile , 'zone_file' : zone_file , 'public_key' : public_key , 'owner_address' : address } if not fqa . endswith ( '.id' ) : data [ 'verifications' ] = [ "No verifications for non-id namespaces." ] return data profile_in_legacy_format = is_profile_in_legacy_format ( profile ) if not profile_in_legacy_format : data [ 'verifications' ] = fetch_proofs ( data [ 'profile' ] , fqa , address , profile_ver = 3 , zonefile = zone_file ) else : if type ( profile ) is not dict : data [ 'profile' ] = json . loads ( profile ) data [ 'verifications' ] = fetch_proofs ( data [ 'profile' ] , fqa , address ) return data | Process profile data and 1 ) Insert verifications 2 ) Check if profile data is valid JSON | 274 | 18 |
224,649 | def get_users ( username ) : reply = { } log . debug ( 'Begin /v[x]/users/' + username ) if username is None : reply [ 'error' ] = "No username given" return jsonify ( reply ) , 404 if ',' in username : reply [ 'error' ] = 'Multiple username queries are no longer supported.' return jsonify ( reply ) , 401 if "." not in username : fqa = "{}.{}" . format ( username , 'id' ) else : fqa = username profile = get_profile ( fqa ) reply [ username ] = profile if 'error' in profile : status_code = 200 if 'status_code' in profile : status_code = profile [ 'status_code' ] del profile [ 'status_code' ] return jsonify ( reply ) , status_code else : return jsonify ( reply ) , 200 | Fetch data from username in . id namespace | 191 | 9 |
224,650 | def is_earlier_than ( nameop1 , block_id , vtxindex ) : return nameop1 [ 'block_number' ] < block_id or ( nameop1 [ 'block_number' ] == block_id and nameop1 [ 'vtxindex' ] < vtxindex ) | Does nameop1 come before bock_id and vtxindex? | 68 | 15 |
224,651 | def namespacereveal_sanity_check ( namespace_id , version , lifetime , coeff , base , bucket_exponents , nonalpha_discount , no_vowel_discount ) : # sanity check if not is_b40 ( namespace_id ) or "+" in namespace_id or namespace_id . count ( "." ) > 0 : raise Exception ( "Namespace ID '%s' has non-base-38 characters" % namespace_id ) if len ( namespace_id ) > LENGTHS [ 'blockchain_id_namespace_id' ] : raise Exception ( "Invalid namespace ID length for '%s' (expected length between 1 and %s)" % ( namespace_id , LENGTHS [ 'blockchain_id_namespace_id' ] ) ) if version not in [ NAMESPACE_VERSION_PAY_TO_BURN , NAMESPACE_VERSION_PAY_TO_CREATOR , NAMESPACE_VERSION_PAY_WITH_STACKS ] : raise Exception ( "Invalid namespace version bits {:x}" . format ( version ) ) if lifetime < 0 or lifetime > ( 2 ** 32 - 1 ) : lifetime = NAMESPACE_LIFE_INFINITE if coeff < 0 or coeff > 255 : raise Exception ( "Invalid cost multiplier %s: must be in range [0, 256)" % coeff ) if base < 0 or base > 255 : raise Exception ( "Invalid base price %s: must be in range [0, 256)" % base ) if type ( bucket_exponents ) != list : raise Exception ( "Bucket exponents must be a list" ) if len ( bucket_exponents ) != 16 : raise Exception ( "Exactly 16 buckets required" ) for i in xrange ( 0 , len ( bucket_exponents ) ) : if bucket_exponents [ i ] < 0 or bucket_exponents [ i ] > 15 : raise Exception ( "Invalid bucket exponent %s (must be in range [0, 16)" % bucket_exponents [ i ] ) if nonalpha_discount <= 0 or nonalpha_discount > 15 : raise Exception ( "Invalid non-alpha discount %s: must be in range [0, 16)" % nonalpha_discount ) if no_vowel_discount <= 0 or no_vowel_discount > 15 : raise Exception ( "Invalid no-vowel discount %s: must be in range [0, 16)" % no_vowel_discount ) return True | Verify the validity of a namespace reveal . Return True if valid Raise an Exception if not valid . | 551 | 20 |
224,652 | def namedb_create ( path , genesis_block ) : global BLOCKSTACK_DB_SCRIPT if os . path . exists ( path ) : raise Exception ( "Database '%s' already exists" % path ) lines = [ l + ";" for l in BLOCKSTACK_DB_SCRIPT . split ( ";" ) ] con = sqlite3 . connect ( path , isolation_level = None , timeout = 2 ** 30 ) for line in lines : db_query_execute ( con , line , ( ) ) con . row_factory = namedb_row_factory # create genesis block namedb_create_token_genesis ( con , genesis_block [ 'rows' ] , genesis_block [ 'history' ] ) return con | Create a sqlite3 db at the given path . Create all the tables and indexes we need . | 164 | 20 |
224,653 | def namedb_open ( path ) : con = sqlite3 . connect ( path , isolation_level = None , timeout = 2 ** 30 ) db_query_execute ( con , 'pragma mmap_size=536870912' , ( ) ) con . row_factory = namedb_row_factory version = namedb_get_version ( con ) if not semver_equal ( version , VERSION ) : # wrong version raise Exception ( 'Database has version {}, but this node is version {}. Please update your node database (such as with fast_sync).' . format ( version , VERSION ) ) return con | Open a connection to our database | 139 | 6 |
224,654 | def namedb_insert_prepare ( cur , record , table_name ) : namedb_assert_fields_match ( cur , record , table_name ) columns = record . keys ( ) columns . sort ( ) values = [ ] for c in columns : if record [ c ] == False : values . append ( 0 ) elif record [ c ] == True : values . append ( 1 ) else : values . append ( record [ c ] ) values = tuple ( values ) field_placeholders = "," . join ( [ "?" ] * len ( columns ) ) query = "INSERT INTO %s (%s) VALUES (%s);" % ( table_name , "," . join ( columns ) , field_placeholders ) log . debug ( namedb_format_query ( query , values ) ) return ( query , values ) | Prepare to insert a record but make sure that all of the column names have values first! | 180 | 19 |
224,655 | def namedb_update_must_equal ( rec , change_fields ) : must_equal = [ ] if len ( change_fields ) != 0 : given = rec . keys ( ) for k in given : if k not in change_fields : must_equal . append ( k ) return must_equal | Generate the set of fields that must stay the same across an update . | 65 | 15 |
224,656 | def namedb_delete_prepare ( cur , primary_key , primary_key_value , table_name ) : # primary key corresponds to a real column namedb_assert_fields_match ( cur , { primary_key : primary_key_value } , table_name , columns_match_record = False ) query = "DELETE FROM %s WHERE %s = ?;" % ( table_name , primary_key ) values = ( primary_key_value , ) return ( query , values ) | Prepare to delete a record but make sure the fields in record correspond to actual columns . Return a DELETE FROM ... WHERE statement on success . Raise an Exception if not . | 110 | 36 |
224,657 | def namedb_query_execute ( cur , query , values , abort = True ) : return db_query_execute ( cur , query , values , abort = abort ) | Execute a query . If it fails abort . Retry with timeouts on lock | 36 | 17 |
224,658 | def namedb_preorder_insert ( cur , preorder_rec ) : preorder_row = copy . deepcopy ( preorder_rec ) assert 'preorder_hash' in preorder_row , "BUG: missing preorder_hash" try : preorder_query , preorder_values = namedb_insert_prepare ( cur , preorder_row , "preorders" ) except Exception , e : log . exception ( e ) log . error ( "FATAL: Failed to insert name preorder '%s'" % preorder_row [ 'preorder_hash' ] ) os . abort ( ) namedb_query_execute ( cur , preorder_query , preorder_values ) return True | Add a name or namespace preorder record if it doesn t exist already . | 156 | 15 |
224,659 | def namedb_preorder_remove ( cur , preorder_hash ) : try : query , values = namedb_delete_prepare ( cur , 'preorder_hash' , preorder_hash , 'preorders' ) except Exception , e : log . exception ( e ) log . error ( "FATAL: Failed to delete preorder with hash '%s'" % preorder_hash ) os . abort ( ) log . debug ( namedb_format_query ( query , values ) ) namedb_query_execute ( cur , query , values ) return True | Remove a preorder hash . | 123 | 6 |
224,660 | def namedb_name_insert ( cur , input_name_rec ) : name_rec = copy . deepcopy ( input_name_rec ) namedb_name_fields_check ( name_rec ) try : query , values = namedb_insert_prepare ( cur , name_rec , "name_records" ) except Exception , e : log . exception ( e ) log . error ( "FATAL: Failed to insert name '%s'" % name_rec [ 'name' ] ) os . abort ( ) namedb_query_execute ( cur , query , values ) return True | Add the given name record to the database if it doesn t exist already . | 130 | 15 |
224,661 | def namedb_name_update ( cur , opcode , input_opdata , only_if = { } , constraints_ignored = [ ] ) : opdata = copy . deepcopy ( input_opdata ) namedb_name_fields_check ( opdata ) mutate_fields = op_get_mutate_fields ( opcode ) if opcode not in OPCODE_CREATION_OPS : assert 'name' not in mutate_fields , "BUG: 'name' listed as a mutate field for '%s'" % ( opcode ) # reduce opdata down to the given fields.... must_equal = namedb_update_must_equal ( opdata , mutate_fields ) must_equal += [ 'name' , 'block_number' ] for ignored in constraints_ignored : if ignored in must_equal : # ignore this constraint must_equal . remove ( ignored ) try : query , values = namedb_update_prepare ( cur , [ 'name' , 'block_number' ] , opdata , "name_records" , must_equal = must_equal , only_if = only_if ) except Exception , e : log . exception ( e ) log . error ( "FATAL: failed to update name '%s'" % opdata [ 'name' ] ) os . abort ( ) namedb_query_execute ( cur , query , values ) try : assert cur . rowcount == 1 , "Updated %s row(s)" % cur . rowcount except Exception , e : log . exception ( e ) log . error ( "FATAL: failed to update name '%s'" % opdata [ 'name' ] ) log . error ( "Query: %s" , "" . join ( [ "%s %s" % ( frag , "'%s'" % val if type ( val ) in [ str , unicode ] else val ) for ( frag , val ) in zip ( query . split ( "?" ) , values + ( "" , ) ) ] ) ) os . abort ( ) return True | Update an existing name in the database . If non - empty only update the given fields . | 445 | 18 |
224,662 | def namedb_state_mutation_sanity_check ( opcode , op_data ) : # sanity check: each mutate field in the operation must be defined in op_data, even if it's null. missing = [ ] mutate_fields = op_get_mutate_fields ( opcode ) for field in mutate_fields : if field not in op_data . keys ( ) : missing . append ( field ) assert len ( missing ) == 0 , ( "BUG: operation '%s' is missing the following fields: %s" % ( opcode , "," . join ( missing ) ) ) return True | Make sure all mutate fields for this operation are present . Return True if so Raise exception if not | 136 | 20 |
224,663 | def namedb_get_last_name_import ( cur , name , block_id , vtxindex ) : query = 'SELECT history_data FROM history WHERE history_id = ? AND (block_id < ? OR (block_id = ? AND vtxindex < ?)) ' + 'ORDER BY block_id DESC,vtxindex DESC LIMIT 1;' args = ( name , block_id , block_id , vtxindex ) history_rows = namedb_query_execute ( cur , query , args ) for row in history_rows : history_data = json . loads ( row [ 'history_data' ] ) return history_data return None | Find the last name import for this name | 147 | 8 |
224,664 | def namedb_account_transaction_save ( cur , address , token_type , new_credit_value , new_debit_value , block_id , vtxindex , txid , existing_account ) : if existing_account is None : existing_account = { } accounts_insert = { 'address' : address , 'type' : token_type , 'credit_value' : '{}' . format ( new_credit_value ) , 'debit_value' : '{}' . format ( new_debit_value ) , 'lock_transfer_block_id' : existing_account . get ( 'lock_transfer_block_id' , 0 ) , # unlocks immediately if the account doesn't exist 'receive_whitelisted' : existing_account . get ( 'receive_whitelisted' , True ) , # new accounts are whitelisted by default (for now) 'metadata' : existing_account . get ( 'metadata' , None ) , 'block_id' : block_id , 'txid' : txid , 'vtxindex' : vtxindex } try : query , values = namedb_insert_prepare ( cur , accounts_insert , 'accounts' ) except Exception as e : log . exception ( e ) log . fatal ( 'FATAL: failed to append account history record for {} at ({},{})' . format ( address , block_id , vtxindex ) ) os . abort ( ) namedb_query_execute ( cur , query , values ) return True | Insert the new state of an account at a particular point in time . | 340 | 14 |
224,665 | def namedb_account_debit ( cur , account_addr , token_type , amount , block_id , vtxindex , txid ) : account = namedb_get_account ( cur , account_addr , token_type ) if account is None : traceback . print_stack ( ) log . fatal ( 'Account {} does not exist' . format ( account_addr ) ) os . abort ( ) new_credit_value = account [ 'credit_value' ] new_debit_value = account [ 'debit_value' ] + amount # sanity check if new_debit_value > new_credit_value : traceback . print_stack ( ) log . fatal ( 'Account {} for "{}" tokens overdrew (debits = {}, credits = {})' . format ( account_addr , token_type , new_debit_value , new_credit_value ) ) os . abort ( ) new_balance = new_credit_value - new_debit_value log . debug ( "Account balance of units of '{}' for {} is now {}" . format ( token_type , account_addr , new_balance ) ) res = namedb_account_transaction_save ( cur , account_addr , token_type , new_credit_value , new_debit_value , block_id , vtxindex , txid , account ) if not res : traceback . print_stack ( ) log . fatal ( 'Failed to save new account state for {}' . format ( account_addr ) ) os . abort ( ) return True | Debit an account at a particular point in time by the given amount . Insert a new history entry for the account into the accounts table . | 341 | 28 |
224,666 | def namedb_accounts_vest ( cur , block_height ) : sql = 'SELECT * FROM account_vesting WHERE block_id = ?' args = ( block_height , ) vesting_rows = namedb_query_execute ( cur , sql , args ) rows = [ ] for row in vesting_rows : tmp = { } tmp . update ( row ) rows . append ( tmp ) for row in rows : addr = row [ 'address' ] token_type = row [ 'type' ] token_amount = row [ 'vesting_value' ] log . debug ( "Vest {} with {} {}" . format ( addr , token_amount , token_type ) ) fake_txid = namedb_vesting_txid ( addr , token_type , token_amount , block_height ) res = namedb_account_credit ( cur , addr , token_type , token_amount , block_height , 0 , fake_txid ) if not res : traceback . print_stack ( ) log . fatal ( 'Failed to vest {} {} to {}' . format ( token_amount , token_type , addr ) ) os . abort ( ) return True | Vest tokens at this block to all recipients . Goes through the vesting table and debits each account that should vest on this block . | 256 | 28 |
224,667 | def namedb_is_history_snapshot ( history_snapshot ) : # sanity check: each mutate field in the operation must be defined in op_data, even if it's null. missing = [ ] assert 'op' in history_snapshot . keys ( ) , "BUG: no op given" opcode = op_get_opcode_name ( history_snapshot [ 'op' ] ) assert opcode is not None , "BUG: unrecognized op '%s'" % history_snapshot [ 'op' ] consensus_fields = op_get_consensus_fields ( opcode ) for field in consensus_fields : if field not in history_snapshot . keys ( ) : missing . append ( field ) assert len ( missing ) == 0 , ( "BUG: operation '%s' is missing the following fields: %s" % ( opcode , "," . join ( missing ) ) ) return True | Given a dict verify that it is a history snapshot . It must have all consensus fields . Return True if so . Raise an exception of it doesn t . | 200 | 31 |
224,668 | def namedb_get_account_tokens ( cur , address ) : sql = 'SELECT DISTINCT type FROM accounts WHERE address = ?;' args = ( address , ) rows = namedb_query_execute ( cur , sql , args ) ret = [ ] for row in rows : ret . append ( row [ 'type' ] ) return ret | Get an account s tokens Returns the list of tokens on success Returns None if not found | 77 | 17 |
224,669 | def namedb_get_account ( cur , address , token_type ) : sql = 'SELECT * FROM accounts WHERE address = ? AND type = ? ORDER BY block_id DESC, vtxindex DESC LIMIT 1;' args = ( address , token_type ) rows = namedb_query_execute ( cur , sql , args ) row = rows . fetchone ( ) if row is None : return None ret = { } ret . update ( row ) return ret | Get an account given the address . Returns the account row on success Returns None if not found | 101 | 18 |
224,670 | def namedb_get_account_diff ( current , prior ) : if current [ 'address' ] != prior [ 'address' ] or current [ 'type' ] != prior [ 'type' ] : raise ValueError ( "Accounts for two different addresses and/or token types" ) # NOTE: only possible since Python doesn't overflow :P return namedb_get_account_balance ( current ) - namedb_get_account_balance ( prior ) | Figure out what the expenditure difference is between two accounts . They must be for the same token type and address . Calculates current - prior | 98 | 27 |
224,671 | def namedb_get_account_history ( cur , address , offset = None , count = None ) : sql = 'SELECT * FROM accounts WHERE address = ? ORDER BY block_id DESC, vtxindex DESC' args = ( address , ) if count is not None : sql += ' LIMIT ?' args += ( count , ) if offset is not None : sql += ' OFFSET ?' args += ( offset , ) sql += ';' rows = namedb_query_execute ( cur , sql , args ) ret = [ ] for rowdata in rows : tmp = { } tmp . update ( rowdata ) ret . append ( tmp ) return ret | Get the history of an account s tokens | 142 | 8 |
224,672 | def namedb_get_all_account_addresses ( cur ) : assert BLOCKSTACK_TEST , 'BUG: this method is only available in test mode' sql = 'SELECT DISTINCT address FROM accounts;' args = ( ) rows = namedb_query_execute ( cur , sql , args ) ret = [ ] for rowdata in rows : ret . append ( rowdata [ 'address' ] ) return ret | TESTING ONLY get all account addresses | 93 | 8 |
224,673 | def namedb_get_name_at ( cur , name , block_number , include_expired = False ) : if not include_expired : # don't return anything if this name is expired. # however, we don't care if the name hasn't been created as of this block_number either, since we might return its preorder (hence only_registered=False) name_rec = namedb_get_name ( cur , name , block_number , include_expired = False , include_history = False , only_registered = False ) if name_rec is None : # expired at this block. return None history_rows = namedb_get_record_states_at ( cur , name , block_number ) if len ( history_rows ) == 0 : # doesn't exist return None else : return history_rows | Get the sequence of states that a name record was in at a particular block height . There can be more than one if the name changed during the block . | 180 | 31 |
224,674 | def namedb_get_namespace_at ( cur , namespace_id , block_number , include_expired = False ) : if not include_expired : # don't return anything if the namespace was expired at this block. # (but do return something here even if the namespace was created after this block, so we can potentially pick up its preorder (hence only_revealed=False)) namespace_rec = namedb_get_namespace ( cur , namespace_id , block_number , include_expired = False , include_history = False , only_revealed = False ) if namespace_rec is None : # expired at this block return None history_rows = namedb_get_record_states_at ( cur , namespace_id , block_number ) if len ( history_rows ) == 0 : # doesn't exist yet return None else : return history_rows | Get the sequence of states that a namespace record was in at a particular block height . There can be more than one if the namespace changed durnig the block . Returns only unexpired namespaces by default . Can return expired namespaces with include_expired = True | 190 | 54 |
224,675 | def namedb_get_account_balance ( account ) : # NOTE: this is only possible because Python does not overflow :P balance = account [ 'credit_value' ] - account [ 'debit_value' ] if balance < 0 : log . fatal ( "Balance of {} is {} (credits = {}, debits = {})" . format ( account [ 'address' ] , balance , account [ 'credit_value' ] , account [ 'debit_value' ] ) ) traceback . print_stack ( ) os . abort ( ) return balance | Get the balance of an account for a particular type of token . This is its credits minus its debits . Returns the current balance on success . Aborts on error or if the balance is somehow negative . | 120 | 41 |
224,676 | def namedb_get_preorder ( cur , preorder_hash , current_block_number , include_expired = False , expiry_time = None ) : select_query = None args = None if include_expired : select_query = "SELECT * FROM preorders WHERE preorder_hash = ?;" args = ( preorder_hash , ) else : assert expiry_time is not None , "expiry_time is required with include_expired" select_query = "SELECT * FROM preorders WHERE preorder_hash = ? AND block_number < ?;" args = ( preorder_hash , expiry_time + current_block_number ) preorder_rows = namedb_query_execute ( cur , select_query , ( preorder_hash , ) ) preorder_row = preorder_rows . fetchone ( ) if preorder_row is None : # no such preorder return None preorder_rec = { } preorder_rec . update ( preorder_row ) return preorder_rec | Get a preorder record by hash . If include_expired is set then so must expiry_time Return None if not found . | 225 | 28 |
224,677 | def namedb_get_num_historic_names_by_address ( cur , address ) : select_query = "SELECT COUNT(*) FROM name_records JOIN history ON name_records.name = history.history_id " + "WHERE history.creator_address = ?;" args = ( address , ) count = namedb_select_count_rows ( cur , select_query , args ) return count | Get the number of names owned by an address throughout history | 91 | 11 |
224,678 | def namedb_get_num_names ( cur , current_block , include_expired = False ) : unexpired_query = "" unexpired_args = ( ) if not include_expired : # count all names, including expired ones unexpired_query , unexpired_args = namedb_select_where_unexpired_names ( current_block ) unexpired_query = 'WHERE {}' . format ( unexpired_query ) query = "SELECT COUNT(name_records.name) FROM name_records JOIN namespaces ON name_records.namespace_id = namespaces.namespace_id " + unexpired_query + ";" args = unexpired_args num_rows = namedb_select_count_rows ( cur , query , args , count_column = 'COUNT(name_records.name)' ) return num_rows | Get the number of names that exist at the current block | 191 | 11 |
224,679 | def namedb_get_all_names ( cur , current_block , offset = None , count = None , include_expired = False ) : unexpired_query = "" unexpired_args = ( ) if not include_expired : # all names, including expired ones unexpired_query , unexpired_args = namedb_select_where_unexpired_names ( current_block ) unexpired_query = 'WHERE {}' . format ( unexpired_query ) query = "SELECT name FROM name_records JOIN namespaces ON name_records.namespace_id = namespaces.namespace_id " + unexpired_query + " ORDER BY name " args = unexpired_args offset_count_query , offset_count_args = namedb_offset_count_predicate ( offset = offset , count = count ) query += offset_count_query + ";" args += offset_count_args name_rows = namedb_query_execute ( cur , query , tuple ( args ) ) ret = [ ] for name_row in name_rows : rec = { } rec . update ( name_row ) ret . append ( rec [ 'name' ] ) return ret | Get a list of all names in the database optionally paginated with offset and count . Exclude expired names . Include revoked names . | 258 | 26 |
224,680 | def namedb_get_num_names_in_namespace ( cur , namespace_id , current_block ) : unexpired_query , unexpired_args = namedb_select_where_unexpired_names ( current_block ) query = "SELECT COUNT(name_records.name) FROM name_records JOIN namespaces ON name_records.namespace_id = namespaces.namespace_id WHERE name_records.namespace_id = ? AND " + unexpired_query + " ORDER BY name;" args = ( namespace_id , ) + unexpired_args num_rows = namedb_select_count_rows ( cur , query , args , count_column = 'COUNT(name_records.name)' ) return num_rows | Get the number of names in a given namespace | 171 | 9 |
224,681 | def namedb_get_names_in_namespace ( cur , namespace_id , current_block , offset = None , count = None ) : unexpired_query , unexpired_args = namedb_select_where_unexpired_names ( current_block ) query = "SELECT name FROM name_records JOIN namespaces ON name_records.namespace_id = namespaces.namespace_id WHERE name_records.namespace_id = ? AND " + unexpired_query + " ORDER BY name " args = ( namespace_id , ) + unexpired_args offset_count_query , offset_count_args = namedb_offset_count_predicate ( offset = offset , count = count ) query += offset_count_query + ";" args += offset_count_args name_rows = namedb_query_execute ( cur , query , tuple ( args ) ) ret = [ ] for name_row in name_rows : rec = { } rec . update ( name_row ) ret . append ( rec [ 'name' ] ) return ret | Get a list of all names in a namespace optionally paginated with offset and count . Exclude expired names | 234 | 21 |
224,682 | def namedb_get_all_namespace_ids ( cur ) : query = "SELECT namespace_id FROM namespaces WHERE op = ?;" args = ( NAMESPACE_READY , ) namespace_rows = namedb_query_execute ( cur , query , args ) ret = [ ] for namespace_row in namespace_rows : ret . append ( namespace_row [ 'namespace_id' ] ) return ret | Get a list of all READY namespace IDs . | 91 | 10 |
224,683 | def namedb_get_all_preordered_namespace_hashes ( cur , current_block ) : query = "SELECT preorder_hash FROM preorders WHERE op = ? AND block_number >= ? AND block_number < ?;" args = ( NAMESPACE_PREORDER , current_block , current_block + NAMESPACE_PREORDER_EXPIRE ) namespace_rows = namedb_query_execute ( cur , query , args ) ret = [ ] for namespace_row in namespace_rows : ret . append ( namespace_row [ 'preorder_hash' ] ) return ret | Get a list of all preordered namespace hashes that haven t expired yet . Used for testing | 133 | 18 |
224,684 | def namedb_get_all_revealed_namespace_ids ( self , current_block ) : query = "SELECT namespace_id FROM namespaces WHERE op = ? AND reveal_block < ?;" args = ( NAMESPACE_REVEAL , current_block + NAMESPACE_REVEAL_EXPIRE ) namespace_rows = namedb_query_execute ( cur , query , args ) ret = [ ] for namespace_row in namespace_rows : ret . append ( namespace_row [ 'namespace_id' ] ) return ret | Get all non - expired revealed namespaces . | 121 | 9 |
224,685 | def namedb_get_all_importing_namespace_hashes ( self , current_block ) : query = "SELECT preorder_hash FROM namespaces WHERE (op = ? AND reveal_block < ?) OR (op = ? AND block_number < ?);" args = ( NAMESPACE_REVEAL , current_block + NAMESPACE_REVEAL_EXPIRE , NAMESPACE_PREORDER , current_block + NAMESPACE_PREORDER_EXPIRE ) namespace_rows = namedb_query_execute ( cur , query , args ) ret = [ ] for namespace_row in namespace_rows : ret . append ( namespace_row [ 'preorder_hash' ] ) return ret | Get the list of all non - expired preordered and revealed namespace hashes . | 162 | 15 |
224,686 | def namedb_get_names_by_sender ( cur , sender , current_block ) : unexpired_query , unexpired_args = namedb_select_where_unexpired_names ( current_block ) query = "SELECT name_records.name FROM name_records JOIN namespaces ON name_records.namespace_id = namespaces.namespace_id " + "WHERE name_records.sender = ? AND name_records.revoked = 0 AND " + unexpired_query + ";" args = ( sender , ) + unexpired_args name_rows = namedb_query_execute ( cur , query , args ) names = [ ] for name_row in name_rows : names . append ( name_row [ 'name' ] ) return names | Given a sender pubkey script find all the non - expired non - revoked names owned by it . Return None if the sender owns no names . | 175 | 29 |
224,687 | def namedb_get_namespace_preorder ( db , namespace_preorder_hash , current_block ) : cur = db . cursor ( ) select_query = "SELECT * FROM preorders WHERE preorder_hash = ? AND op = ? AND block_number < ?;" args = ( namespace_preorder_hash , NAMESPACE_PREORDER , current_block + NAMESPACE_PREORDER_EXPIRE ) preorder_rows = namedb_query_execute ( cur , select_query , args ) preorder_row = preorder_rows . fetchone ( ) if preorder_row is None : # no such preorder return None preorder_rec = { } preorder_rec . update ( preorder_row ) # make sure that the namespace doesn't already exist cur = db . cursor ( ) select_query = "SELECT preorder_hash FROM namespaces WHERE preorder_hash = ? AND ((op = ?) OR (op = ? AND reveal_block < ?));" args = ( namespace_preorder_hash , NAMESPACE_READY , NAMESPACE_REVEAL , current_block + NAMESPACE_REVEAL_EXPIRE ) ns_rows = namedb_query_execute ( cur , select_query , args ) ns_row = ns_rows . fetchone ( ) if ns_row is not None : # exists return None return preorder_rec | Get a namespace preorder given its hash . | 312 | 9 |
224,688 | def namedb_get_namespace_ready ( cur , namespace_id , include_history = True ) : select_query = "SELECT * FROM namespaces WHERE namespace_id = ? AND op = ?;" namespace_rows = namedb_query_execute ( cur , select_query , ( namespace_id , NAMESPACE_READY ) ) namespace_row = namespace_rows . fetchone ( ) if namespace_row is None : # no such namespace return None namespace = { } namespace . update ( namespace_row ) if include_history : hist = namedb_get_history ( cur , namespace_id ) namespace [ 'history' ] = hist namespace = op_decanonicalize ( 'NAMESPACE_READY' , namespace ) return namespace | Get a ready namespace and optionally its history . Only return a namespace if it is ready . | 164 | 18 |
224,689 | def namedb_get_name_from_name_hash128 ( cur , name_hash128 , block_number ) : unexpired_query , unexpired_args = namedb_select_where_unexpired_names ( block_number ) select_query = "SELECT name FROM name_records JOIN namespaces ON name_records.namespace_id = namespaces.namespace_id " + "WHERE name_hash128 = ? AND revoked = 0 AND " + unexpired_query + ";" args = ( name_hash128 , ) + unexpired_args name_rows = namedb_query_execute ( cur , select_query , args ) name_row = name_rows . fetchone ( ) if name_row is None : # no such namespace return None return name_row [ 'name' ] | Given the hexlified 128 - bit hash of a name get the name . | 179 | 16 |
224,690 | def namedb_get_names_with_value_hash ( cur , value_hash , block_number ) : unexpired_query , unexpired_args = namedb_select_where_unexpired_names ( block_number ) select_query = "SELECT name FROM name_records JOIN namespaces ON name_records.namespace_id = namespaces.namespace_id " + "WHERE value_hash = ? AND revoked = 0 AND " + unexpired_query + ";" args = ( value_hash , ) + unexpired_args name_rows = namedb_query_execute ( cur , select_query , args ) names = [ ] for name_row in name_rows : names . append ( name_row [ 'name' ] ) if len ( names ) == 0 : return None else : return names | Get the names with the given value hash . Only includes current non - revoked names . Return None if there are no names . | 181 | 25 |
224,691 | def namedb_get_value_hash_txids ( cur , value_hash ) : query = 'SELECT txid FROM history WHERE value_hash = ? ORDER BY block_id,vtxindex;' args = ( value_hash , ) rows = namedb_query_execute ( cur , query , args ) txids = [ ] for r in rows : # present txid = str ( r [ 'txid' ] ) txids . append ( txid ) return txids | Get the list of txs that sent this value hash ordered by block and vtxindex | 104 | 18 |
224,692 | def namedb_get_num_block_vtxs ( cur , block_number ) : select_query = "SELECT vtxindex FROM history WHERE history_id = ?;" args = ( block_number , ) rows = namedb_query_execute ( cur , select_query , args ) count = 0 for r in rows : count += 1 return count | How many virtual transactions were processed for this block? | 77 | 10 |
224,693 | def namedb_is_name_zonefile_hash ( cur , name , zonefile_hash ) : select_query = 'SELECT COUNT(value_hash) FROM history WHERE history_id = ? AND value_hash = ?' select_args = ( name , zonefile_hash ) rows = namedb_query_execute ( cur , select_query , select_args ) count = None for r in rows : count = r [ 'COUNT(value_hash)' ] break return count > 0 | Determine if a zone file hash was sent by a name . Return True if so false if not | 108 | 21 |
224,694 | def process_announcement ( sender_namerec , op , working_dir ) : node_config = get_blockstack_opts ( ) # valid announcement announce_hash = op [ 'message_hash' ] announcer_id = op [ 'announcer_id' ] # verify that it came from this individual name_history = sender_namerec [ 'history' ] allowed_value_hashes = [ ] for block_height in name_history . keys ( ) : for historic_namerec in name_history [ block_height ] : if historic_namerec . get ( 'value_hash' ) : allowed_value_hashes . append ( historic_namerec [ 'value_hash' ] ) if announce_hash not in allowed_value_hashes : # this individual did not send this announcement log . warning ( "Announce hash {} not found in name history for {}" . format ( announce_hash , announcer_id ) ) return # go get it from Atlas zonefiles_dir = node_config . get ( 'zonefiles' , None ) if not zonefiles_dir : log . warning ( "This node does not store zone files, so no announcement can be found" ) return announce_text = get_atlas_zonefile_data ( announce_hash , zonefiles_dir ) if announce_text is None : log . warning ( "No zone file {} found" . format ( announce_hash ) ) return # go append it log . critical ( "ANNOUNCEMENT (from %s): %s\n------BEGIN MESSAGE------\n%s\n------END MESSAGE------\n" % ( announcer_id , announce_hash , announce_text ) ) store_announcement ( working_dir , announce_hash , announce_text ) | If the announcement is valid then immediately record it . | 388 | 10 |
224,695 | def check ( state_engine , nameop , block_id , checked_ops ) : sender = nameop [ 'sender' ] sending_blockchain_id = None found = False blockchain_namerec = None for blockchain_id in state_engine . get_announce_ids ( ) : blockchain_namerec = state_engine . get_name ( blockchain_id ) if blockchain_namerec is None : # this name doesn't exist yet, or is expired or revoked continue if str ( sender ) == str ( blockchain_namerec [ 'sender' ] ) : # yup! found = True sending_blockchain_id = blockchain_id break if not found : log . warning ( "Announcement not sent from our whitelist of blockchain IDs" ) return False nameop [ 'announcer_id' ] = sending_blockchain_id process_announcement ( blockchain_namerec , nameop , state_engine . working_dir ) return True | Log an announcement from the blockstack developers but first verify that it is correct . Return True if the announcement came from the announce IDs whitelist Return False otherwise | 208 | 31 |
224,696 | def get_bitcoind_client ( ) : bitcoind_opts = get_bitcoin_opts ( ) bitcoind_host = bitcoind_opts [ 'bitcoind_server' ] bitcoind_port = bitcoind_opts [ 'bitcoind_port' ] bitcoind_user = bitcoind_opts [ 'bitcoind_user' ] bitcoind_passwd = bitcoind_opts [ 'bitcoind_passwd' ] return create_bitcoind_service_proxy ( bitcoind_user , bitcoind_passwd , server = bitcoind_host , port = bitcoind_port ) | Connect to the bitcoind node | 152 | 7 |
224,697 | def txid_to_block_data ( txid , bitcoind_proxy , proxy = None ) : proxy = get_default_proxy ( ) if proxy is None else proxy timeout = 1.0 while True : try : untrusted_tx_data = bitcoind_proxy . getrawtransaction ( txid , 1 ) untrusted_block_hash = untrusted_tx_data [ 'blockhash' ] untrusted_block_data = bitcoind_proxy . getblock ( untrusted_block_hash ) break except ( OSError , IOError ) as ie : log . exception ( ie ) log . error ( 'Network error; retrying...' ) timeout = timeout * 2 + random . randint ( 0 , timeout ) continue except Exception as e : log . exception ( e ) return None , None , None bitcoind_opts = get_bitcoin_opts ( ) spv_headers_path = bitcoind_opts [ 'bitcoind_spv_path' ] # first, can we trust this block? is it in the SPV headers? untrusted_block_header_hex = virtualchain . block_header_to_hex ( untrusted_block_data , untrusted_block_data [ 'previousblockhash' ] ) block_id = SPVClient . block_header_index ( spv_headers_path , ( '{}00' . format ( untrusted_block_header_hex ) ) . decode ( 'hex' ) ) if block_id < 0 : # bad header log . error ( 'Block header "{}" is not in the SPV headers ({})' . format ( untrusted_block_header_hex , spv_headers_path ) ) return None , None , None # block header is trusted. Is the transaction data consistent with it? verified_block_header = virtualchain . block_verify ( untrusted_block_data ) if not verified_block_header : msg = ( 'Block transaction IDs are not consistent ' 'with the Merkle root of the trusted header' ) log . error ( msg ) return None , None , None # verify block hash verified_block_hash = virtualchain . block_header_verify ( untrusted_block_data , untrusted_block_data [ 'previousblockhash' ] , untrusted_block_hash ) if not verified_block_hash : log . error ( 'Block hash is not consistent with block header' ) return None , None , None # we trust the block hash, block data, and txids block_hash = untrusted_block_hash block_data = untrusted_block_data tx_data = untrusted_tx_data return block_hash , block_data , tx_data | Given a txid get its block s data . | 611 | 10 |
224,698 | def get_consensus_hash_from_tx ( tx ) : opcode , payload = parse_tx_op_return ( tx ) if opcode is None or payload is None : return None # only present in NAME_PREORDER, NAMESPACE_PREORDER, NAME_TRANSFER if opcode in [ NAME_PREORDER , NAMESPACE_PREORDER , NAME_TRANSFER ] : consensus_hash = payload [ - 16 : ] . encode ( 'hex' ) return consensus_hash msg = ( 'Blockchain ID transaction is not a ' 'NAME_PREORDER, NAMESPACE_PROERDER or NAME_TRANSFER' ) log . error ( msg ) return None | Given an SPV - verified transaction extract its consensus hash . Only works of the tx encodes a NAME_PREORDER NAMESPACE_PREORDER or NAME_TRANSFER . | 157 | 40 |
224,699 | def json_is_exception ( resp ) : if not json_is_error ( resp ) : return False if 'traceback' not in resp . keys ( ) or 'error' not in resp . keys ( ) : return False return True | Is the given response object an exception traceback? | 52 | 10 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.