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 getNewBlockBits(chainHeadBlock, chainHeadBlockHeight): newBlockBits = chainHeadBlock.bits if chainHeadBlockHeight > 0: blockRetargeting = getBlockRetargeting() if chainHeadBlockHeight % blockRetargeting == 0: retargetingStartBlock = chainHeadBlock retargeting = None index = 0 while index < blockRetargeting: retargetingBlockTarget = getTargetFromBits( retargetingStartBlock.bits) if retargeting == None: retargeting = retargetingBlockTarget if Config.getBoolValue('DGW3_ENABLED'): if index > 0: retargeting = (retargeting * index + retargetingBlockTarget) // (index + 1) retargetingStartBlock = Chain.getChain().getBlockByHash( retargetingStartBlock.previousHash) index += 1 blockIntervalTime = chainHeadBlock.timestamp - retargetingStartBlock.timestamp blockIntervalTime = math.ceil(blockIntervalTime) adjustedTarget = adjustTarget(retargeting, blockIntervalTime) if adjustedTarget > getTargetFromBits( Config.getIntValue('GENESIS_BLOCK_DIFFICULTY_BITS', 16)): adjustedTarget = getTargetFromBits( Config.getIntValue('GENESIS_BLOCK_DIFFICULTY_BITS', 16)) newBlockBits = getBitsFromTarget(adjustedTarget) return newBlockBits
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")
def view(key): if Config.getBoolValue('TIME_IT_ENABLED'): message = "{0} => {1}s".format(key, TimeIt.timings[key]) if Config.getBoolValue('TIME_IT_CONSOLE'): print(message) if Config.getBoolValue('TIME_IT_FILE'): Log.debug(message)
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 isCoinbase(self): if self.outpoint.txId != Config.getBytesValue( 'COINBASE_TRANSACTION_ID', False): return False if self.outpoint.outputIndex != Config.getIntValue( 'COINBASE_OUTPUT_INDEX'): return False return True
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)
def isAtomicLock(self): if len(self.script) != Config.getIntValue('SCRIPT_ATOMIC_SWAP_LEN'): return False if self.script[0] != Config.getIntValue('SCRIPT_VERSION', False): return False if self.script[1] != Opcodes.alias('CHECKATOMICSWAPLOCKVERIFY', True): return False return True
class Log: debugLogger = getLogger( 'DEBUG', logging.DEBUG, Config.getFilePath('LOG_DIRECTORY', 'DEBUG_LOG_FILE')) errorLogger = getLogger( 'ERROR', logging.ERROR, Config.getFilePath('LOG_DIRECTORY', 'ERROR_LOG_FILE'))
def isMultiSig(self): if len(self.script) != Config.getIntValue('SCRIPT_MULTISIG_LEN'): return False if self.script[0] != Config.getIntValue('SCRIPT_VERSION', False): return False if self.script[1] != Opcodes.alias('CHECKMULTISIGVERIFY', True): return False return True
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)
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 sendDataByUDP(host, port, data): try: with socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP) as sock: sock.settimeout(Config.getIntValue("CONNECTION_TIMEOUT")) data = DataType.serialize(data) sock.sendto(data, (host, port)) return sock.recvfrom( Config.getIntValue("SOCKET_RECEIVE_BUFFER_SIZE")) except IOError: Log.error('Unable to send data by UDP to host: %s port: %s data: %s' % (host, port, data)) return None, None
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 writeResponse(self, response): response = DataType.serialize(response) responseLen = len(response) responseLen = DataType.intToBytes( responseLen, Config.getIntValue("SOCKET_HEADER_BUFFER_SIZE")) self.request.sendall(responseLen) self.request.sendall(response)
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
def onSuccess(self, callback = None): isMiningSupported = Config.getBoolValue("MINING_SUPPORTED") if isMiningSupported: account = Accounts.getAccountByAddress(self.address) if account != None: if not self.chain.exitsMiningWorker(account): self.chain.addMiningWorker(account, self.enabled) callback( JSONRPC.createResultObject('added mining worker', self.id) ) else: if self.enabled: callback( JSONRPC.createResultObject('worker is mining', self.id) ) else: self.chain.stopMiningWorker(account) callback( JSONRPC.createResultObject('worker is stopped mining', self.id) ) else: callback( JSONRPC.createErrorObject(-32005, 'not found', 'account not found', self.id) ) else: callback( JSONRPC.createErrorObject(-32006, 'not supported', 'node does not support mining', self.id) )
def __init__(self): super().__init__() self.type = MessageType.GETBLOCKS self.version = Config.getIntValue("BLOCK_VERSION") self.blockHashes = [] self.chain = Chain.getChain()
def deploy(self, isLocal, callback): result = None fromAccount = Accounts.getAccountByAddress(self.fromAddress) if fromAccount != None: if isLocal: toAddress = Crypto.generateAddress(fromAccount.address) _script = bytearray() _script.append(Config.getIntValue("EXTENSION_SCRIPT_VERSION")) _script.extend(self.script) _script = DataType.serialize(_script) extraData = None if len(self.parameters) > 0: extraData = self.parameters extraData.append(fromAccount.address) output = Output(toAddress, _script, self.value, extraData) result = self.handleLocalScript(fromAccount, output, True) if result != None: Contracts.addContract(Contract(toAddress), False) else: result = MemoryPool.addUnconfirmedTransaction( fromAccount, None, self.value, self.gasLimit, self.gasPrice, self.script, self.parameters) try: result = DataType.toHex(result) except: pass if result != None: callback(JSONRPC.createResultObject(result, self.id)) else: self.onFailure(callback)
def merge(): script = bytearray() script.append(Config.getIntValue("SCRIPT_VERSION")) script.append(Opcodes.alias('MERGE', True)) return DataType.serialize(script)
def verifyAtomicSwapLock(): script = bytearray() script.append(Config.getIntValue("SCRIPT_VERSION")) script.append(Opcodes.alias('CHECKATOMICSWAPLOCKVERIFY', True)) return DataType.serialize(script)
def verifyMultiSignature(): script = bytearray() script.append(Config.getIntValue("SCRIPT_VERSION")) script.append(Opcodes.alias('CHECKMULTISIGVERIFY', True)) return DataType.serialize(script)
def open(self, subDatabase=None): self.lock.acquire() self.db = lmdb.open(self.database, max_dbs=Config.getIntValue('MAX_DATABASES')) subDatabaseBytes = DataType.serialize( self.subDatabase if subDatabase == None else subDatabase) self.subDb = self.db.open_db(subDatabaseBytes)
def getNewBlock(self, address, previousHash, bits, extraNonce): previousIndexBlock = self.getIndexBlockByHash(previousHash) block = Block() gasLimit = Config.getIntValue("BLOCK_REWARDS_GAS_LIMIT") gasPrice = Config.getIntValue("BLOCK_REWARDS_GAS_PRICE") transaction = Transaction(gasLimit, gasPrice) height = previousIndexBlock.height + 1 coinbaseData = [ DataType.asString(height), DataType.asString(bits), DataType.asString(extraNonce) ] transaction.addCoinbaseInput(coinbaseData) block.transactions.append(transaction) txFees = 0 totalTxGasUsed = 0 unconfirmedTransactions = MemoryPool.getMemoryPool() for txId in unconfirmedTransactions: unconfirmedTransaction = unconfirmedTransactions[txId] block.transactions.append(unconfirmedTransaction) txFees += unconfirmedTransaction.calculateTxFee() totalTxGasUsed += unconfirmedTransaction.calculateTxGasUsed() blockRewards = Config.getDecimalValue("BLOCK_REWARDS") blockRewards = Units.toUnits(blockRewards) coinbaseValue = blockRewards + txFees script = Script.verifySignature() transaction.addOutput(address, script, coinbaseValue) transaction.hash() #Include coinbase tx gas used totalTxGasUsed += transaction.calculateTxGasUsed() block.merkleRoot = MerkleTree.getMerkleRoot(block.transactions, False) block.witnessRoot = MerkleTree.getMerkleRoot(block.transactions, True) blockGasLimit = previousIndexBlock.gasLimit + (previousIndexBlock.gasLimit * (1 / 1024)) blockGasLimit = math.ceil(blockGasLimit) block.gasLimit = blockGasLimit block.gasUsed = totalTxGasUsed block.nonce = 0 block.bits = bits block.previousHash = previousHash return block
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)
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 hasAuthorization(self): if Config.getBoolValue("HTTP_RPC_AUTHENTICATION_ENABLE"): authorizationHeader = self.headers.get('Authorization') if authorizationHeader == None: return False elif authorizationHeader != Http.getBasicAuth(): return False return True
def __init__(self, port): self.port = port def handler(*args): HttpNodeRequestHandler(*args) self.node = HttpNodeServer((Config.getValue("NODE_HOSTNAME"), port), handler)
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 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)