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