def init(self): if self.getIndexBlockByHash(self.CHAIN_HEAD_INDEX) == None: genesisBlockGasLimit = Config.getIntValue("GENESIS_BLOCK_GAS_LIMIT") genesisBlockGasUsed = Config.getIntValue("GENESIS_BLOCK_GAS_USED") genesisBlockGasPrice = Config.getIntValue("GENESIS_BLOCK_GAS_PRICE") genesisBlock = Block() genesisBlock.previousHash = Config.getBytesValue("GENESIS_BLOCK_PREVIOUS_HASH", False) genesisBlock.gasLimit = genesisBlockGasLimit genesisBlock.gasUsed = genesisBlockGasUsed genesisBlock.nonce = Config.getIntValue("GENESIS_BLOCK_NONCE") genesisBlock.bits = Config.getIntValue("GENESIS_BLOCK_DIFFICULTY_BITS", 16) genesisBlock.timestamp = Config.getIntValue("GENESIS_BLOCK_TIMESTAMP") transaction = Transaction(genesisBlockGasLimit, genesisBlockGasPrice) coinbaseData = [] coinbaseData.append(Config.getValue("GENESIS_BLOCK_COINBASE_DATA")) transaction.addCoinbaseInput(coinbaseData) genesisBlockRewards = Config.getDecimalValue("GENESIS_BLOCK_REWARDS") genesisBlockRewards = Units.toUnits(genesisBlockRewards) genesisBlockPublicAddress = Config.getValue("GENESIS_BLOCK_PUBLIC_ADDRESS") genesisBlockPublicAddress = Address.toAddressBytes(genesisBlockPublicAddress) genesisBlockScript = Script.verifySignature() transaction.addOutput(genesisBlockPublicAddress, genesisBlockScript, genesisBlockRewards) transaction.hash() genesisBlock.transactions.append(transaction) genesisBlock.merkleRoot = MerkleTree.getMerkleRoot(genesisBlock.transactions, False) genesisBlock.witnessRoot = MerkleTree.getMerkleRoot(genesisBlock.transactions, True) self.addBlock(genesisBlock)
def getBasicAuth(): username = Config.getValue("HTTP_RPC_USERNAME") password = Config.getValue("HTTP_RPC_PASSWORD") userpass = "******" % (username, password) userpassBytes = DataType.serialize(userpass) userpassB64 = b64encode(userpassBytes) return 'Basic %s' % userpassB64.decode("ascii")
class UXTO: db = Config.getFilePath("CHAIN_DIRECTORY", "STATE_DB") subDb = Config.getValue("UXTO_SUB_DB") uxto = Storage(db, subDb) indexDb = Config.getFilePath("CHAIN_DIRECTORY", "STATE_INDEX_DB") subIndexDb = Config.getValue("UXTO_INDEX_SUB_DB") index = Storage(indexDb, subIndexDb)
class Accounts: accounts = [] with open(Config.getValue('WALLET_DIR')) as wallet: accountsJson = json.load(wallet) for accountJson in accountsJson: account = Account("") account.deserialize(accountJson) accounts.append(account) indexDb = Config.getFilePath("CHAIN_DIRECTORY", "ACCOUNTS_INDEX_DB") balancesSubDb = Config.getValue("BALANCES_SUB_DB") localUxtoSubDb = Config.getValue("LOCAL_UXTO_SUB_DB") index = Storage(indexDb)
def handleLocalScript(self, fromAccount, output, deploy): gasLimit = Config.getIntValue('TRANSACTION_LOCAL_GAS_LIMIT') gasPrice = Config.getIntValue('TRANSACTION_LOCAL_GAS_PRICE') localTx = Transaction(gasLimit, gasPrice) localTx.gasRemaining = Config.getIntValue( 'TRANSACTION_LOCAL_GAS_REMAINING') _input = None if deploy: pass else: scriptData = [] scriptData.append(DataType.zeroFillArray(0, 32)) scriptData.append(DataType.zeroFillArray(0, 32)) scriptData.append(fromAccount.address) scriptData.extend(self.parameters) _input = Input(Config.getValue('SCRIPT_TRANSACTION_ID'), Config.getIntValue('SCRIPT_OUTPUT_INDEX')) _input.witness = scriptData if RVM.run(localTx, _input, output, True, deploy, True): if len(localTx.internalOutputs) > 0: internalOutput = localTx.internalOutputs[-1] if deploy: PersistentStorage.add(internalOutput.address, internalOutput, True) result = 'Script Deployed Locally' else: result = internalOutput.script try: result = DataType.toHex(result) result = DataType.asInt(result, 16) except ValueError: pass return result return None
def __init__(self): super().__init__() self.type = MessageType.VERSION self.version = Config.getValue("NODE_VERSION") self.timestamp = DataType.asTime() self.nonce = randint(0, sys.maxsize) self.chainHeadBlockHash = None
class Sidechains: sidechains = [] with open(Config.getValue('SIDECHAINS_DIR')) as _sidechains: sidechainsJson = json.load(_sidechains) for sidechainJson in sidechainsJson: _sidechain = Sidechain() _sidechain.deserialize(sidechainJson) sidechains.append(_sidechain)
def __init__(self, port): self.port = port def handler(*args): HttpNodeRequestHandler(*args) self.node = HttpNodeServer((Config.getValue("NODE_HOSTNAME"), port), handler)
def server_bind(self): self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) if Config.getBoolValue("HTTP_SSL_ENABLE"): self.socket = ssl.wrap_socket( self.socket, certfile=Config.getValue("HTTP_SSL_CERTIFICATE"), server_side=True) self.socket.bind(self.server_address)
class Contracts: contracts = [] with open(Config.getValue('CONTRACTS_DIR')) as _contracts: contractsJson = json.load(_contracts) for contractJson in contractsJson: _contract = Contract() _contract.deserialize(contractJson) contracts.append(_contract)
def sha3(self): offset = self.popAsInt() length = self.popAsInt() data = self.memory[offset:offset + length] print('memory', 'sha3', 'data', data, len(self.memory)) _hash = Crypto.generateHash(data, Config.getValue('SHA3_HASHING_ALGORITHM')) print('memory', 'sha3', 'hash', _hash) self.stack.append(_hash)
def intToBytes(value, bytesLen=None): if isinstance(value, bytes): return value if bytesLen == None: bytesLen = math.ceil(value.bit_length() / Config.getIntValue("BITS_PER_BYTE")) if bytesLen <= 0: bytesLen = 1 return value.to_bytes(bytesLen, byteorder=Config.getValue("BYTE_ORDER"))
def extcodehash(self): address = self.pop() unspentTransactionScript = UXTO.getUnspentTransactionScript(address) txOut = unspentTransactionScript.output script = txOut.script _hash = 0 if script == None else Crypto.generateHash(script, Config.getValue('SHA3_HASHING_ALGORITHM')) self.stack.append(_hash)
class Peers: db = Config.getValue("PEERS_DB") subDb = Config.getValue("PEERS_SUB_DB") peers = Storage(db, subDb) hostname = Network.getHostname() ipAddress = Network.getIpAddress() if Config.getBoolValue('PEERS_ENABLE_SEEDS'): with open(Config.getValue('SEEDS_DIR')) as seeds: hosts = json.load(seeds) for host in hosts: if host != hostname and host != ipAddress: hostBytes = DataType.serialize(host) if peers.get(hostBytes) == None: peer = Peer() peer.host = host peer.lastUpdate = DataType.asTime() peers.set(hostBytes, peer.serialize())
def validate(self): if self.type != MessageType.VERSION: return False if self.version != Config.getValue("NODE_VERSION"): return False if self.timestamp == None or self.timestamp < 0: return False if self.nonce == None or self.nonce < 0: return False if not Validator.hash(self.chainHeadBlockHash): return False return True
def __init__(self): self.db = Config.getFilePath("CHAIN_DIRECTORY", "BLOCKCHAIN_DB") self.subDb = Config.getValue("BLOCKS_SUB_DB") self.storage = Storage(self.db, self.subDb) self.indexDb = Config.getFilePath("CHAIN_DIRECTORY", "INDEX_DB") self.subIndexDb = Config.getValue("INDEX_SUB_DB") self.index = Storage(self.indexDb, self.subIndexDb) self.CHAIN_HEAD_INDEX = DataType.serialize("CHAIN_HEAD_INDEX") self.BLOCK_HEIGHT_KEY = "BLOCK_HEIGHT_KEY" self.blkValidator = ValidatorFactory.getInstance(ValidatorType.BLOCK) self.txValidator = ValidatorFactory.getInstance(ValidatorType.TX) self.blkLock = RLock() self.orphanLock = RLock() self.miningPool = {}
def validate(self): if self.host == None or len(self.host) == 0: return False if self.version != Config.getValue("NODE_VERSION"): return False if self.lastVersionNonce == None or self.lastVersionNonce < 0: return False if not Validator.hash(self.chainHeadBlockHash): return False if self.lastUpdate == None or self.lastUpdate < 0: return False return True
def createNewUnconfirmedTransaction(fromAccount, value, gasLimit, gasPrice, script=Script.verifySignature(), extraData=None): spending = 0 outpoints = set() fee = gasLimit * gasPrice try: Accounts.index.open(Accounts.localUxtoSubDb) with Accounts.index.db.begin() as local: for outpointBytes, coinBytes in local.cursor( db=Accounts.index.subDb): outpoint = Outpoint() coin = Coin() outpoint.deserialize(outpointBytes) coin.deserialize(coinBytes) txOut = coin.output if txOut.address != fromAccount.address: continue if outpoint in MemoryPool.spentOutpoints: continue if coin.isCoinbase(): if not Validator.coinbaseMaturity(coin.height): continue outpoints.add(outpoint) spending += txOut.value if spending > value + fee: break except IOError: Log.error('Unable to open accounts local uxto database: %s' % Config.getValue("ACCOUNTS_INDEX_DB")) finally: Accounts.index.close() if spending < value + fee: return None, None transaction = Transaction(gasLimit, gasPrice) for outpoint in outpoints: transaction.addInput(outpoint.txId, outpoint.outputIndex) change = spending - value - fee if change > 0: transaction.addOutput(fromAccount.address, script, change, extraData) return transaction, outpoints
def addPortMapping(port): with open("recip/network/messages/upnp/AddPortMapping.xml", "r") as upnp: payload = upnp.read() payload = payload % (port, port, Network.getIpAddress(False), Config.getValue('NODE_VERSION')) headers = { 'SOAPAction': '"urn:schemas-upnp-org:service:WANIPConnection:1#AddPortMapping"', 'Content-Type': 'text/xml' } for igd in INTERNET_GATEWAY_DEVICES: xml = Http.send(igd, payload, False, headers) return xmlFindText(xml, 'AddPortMappingResponse')
def serialize(data): if data is None: return b'' elif isinstance(data, int): return intToBytes(data) elif isinstance(data, bool): return pack('?', data) elif isinstance(data, Decimal): return pack('>d', data) elif isinstance(data, str): return bytes(data, encoding=Config.getValue("ENCODING")) elif isinstance(data, bytearray): return bytes(data) elif isinstance(data, Serializable): return data.serialize() return data
def getPeers(): peers = [] try: Peers.peers.open() with Peers.peers.db.begin() as tx: cursor = tx.cursor(db=Peers.peers.subDb) while cursor.next(): peerBytes = cursor.value() peer = getPeerFromBytes(peerBytes) if peer != None: peers.append(peer) except IOError: Log.error('Unable to open peers database: %s' % Config.getValue("PEERS_DB")) finally: Peers.peers.close() return peers
def deserialize(dataBytes, dataType=STRING, defaultValue=None): if dataBytes != None and len(dataBytes) > 0: if dataType == INT: return bytesToInt(dataBytes) elif dataType == BOOL: return unpack('?', dataBytes)[0] elif dataType == DECIMAL: value = unpack('>d', dataBytes)[0] return asDecimal(value) elif dataType == STRING: return dataBytes.decode(Config.getValue("ENCODING")) elif dataType == LIST: data = [] for dataByte in dataBytes: data.append(deserialize(dataByte)) return data if dataType == DECIMAL: return asDecimal(defaultValue) else: return defaultValue
def writeSidechains(): sidechains = [] for sidechain in Sidechains.sidechains: sidechains.append(sidechain.serialize()) with open(Config.getValue('SIDECHAINS_DIR'), 'w') as sidechain: json.dump(sidechains, sidechain, indent=2, sort_keys=False)
def sha256(self): data = self.pop() _hash = Crypto.generateHash(data, Config.getValue('SHA2_HASHING_ALGORITHM')) self.stack.append(_hash)
class PersistentStorage: db = Config.getFilePath("CHAIN_DIRECTORY", "PERSISTENT_DB") subDb = Config.getValue("STORAGE_SUB_DB") persistent = Storage(db, subDb) storage = {}
def writeContracts(): _contracts = [] for contract in Contracts.contracts: _contracts.append(contract.serialize()) with open(Config.getValue('CONTRACTS_DIR'), 'w') as contract: json.dump(_contracts, contract, indent=2, sort_keys=False)
def bytesToInt(numberBytes): if isinstance(numberBytes, int): return numberBytes return int.from_bytes(numberBytes, byteorder=Config.getValue("BYTE_ORDER"))
import shutil import os if os.path.exists(Config.getFilePath('CHAIN_DIRECTORY', 'ACCOUNTS_INDEX_DB')): shutil.rmtree(Config.getFilePath('CHAIN_DIRECTORY', 'ACCOUNTS_INDEX_DB')) if os.path.exists(Config.getFilePath('CHAIN_DIRECTORY', 'BLOCKCHAIN_DB')): shutil.rmtree(Config.getFilePath('CHAIN_DIRECTORY', 'BLOCKCHAIN_DB')) if os.path.exists(Config.getFilePath('CHAIN_DIRECTORY', 'INDEX_DB')): shutil.rmtree(Config.getFilePath('CHAIN_DIRECTORY', 'INDEX_DB')) if os.path.exists(Config.getFilePath('CHAIN_DIRECTORY', 'STATE_DB')): shutil.rmtree(Config.getFilePath('CHAIN_DIRECTORY', 'STATE_DB')) if os.path.exists(Config.getFilePath('CHAIN_DIRECTORY', 'STATE_INDEX_DB')): shutil.rmtree(Config.getFilePath('CHAIN_DIRECTORY', 'STATE_INDEX_DB')) if os.path.exists(Config.getValue('PEERS_DB')): shutil.rmtree(Config.getValue('PEERS_DB')) if os.path.exists(Config.getFilePath('CHAIN_DIRECTORY', 'PERSISTENT_DB')): shutil.rmtree(Config.getFilePath('CHAIN_DIRECTORY', 'PERSISTENT_DB')) if os.path.exists(Config.getValue('CONTRACTS_DIR')): with open(Config.getValue('CONTRACTS_DIR'), 'w') as contracts: contracts.write('[]') if os.path.exists(Config.getValue('SIDECHAINS_DIR')): with open(Config.getValue('SIDECHAINS_DIR'), 'w') as sidechains: sidechains.write('[]')
def writeAccounts(): accountList = [] for account in Accounts.accounts: accountList.append(account.serialize()) with open(Config.getValue('WALLET_DIR'), 'w') as wallet: json.dump(accountList, wallet, indent=2, sort_keys=False)
def getLogHandler(logPath): logHandler = logging.FileHandler(logPath) logFormat = logging.Formatter(Config.getValue('LOG_FORMAT')) logHandler.setFormatter(logFormat) return logHandler