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)