uint8_t CBNetworkAddressDeserialise(CBNetworkAddress * self, bool timestamp){
CBByteArray * bytes = CBGetMessage(self)->bytes;
if (! bytes) {
CBLogError("Attempting to deserialise a CBNetworkAddress with no bytes.");
return 0;
}
if (bytes->length < 26 + timestamp * 4) {
CBLogError("Attempting to deserialise a CBNetworkAddress with less bytes than required.");
return 0;
}
uint8_t start;
uint64_t twoHoursAgo = time(NULL) - 3600;
if (timestamp) {
// Make sure we do not set self->lastSeen later than one hour ago.
self->lastSeen = CBByteArrayReadInt32(bytes, 0);
if (self->lastSeen > twoHoursAgo)
self->lastSeen = twoHoursAgo;
start = 4;
}else{
self->lastSeen = twoHoursAgo;
start = 0;
}
self->services = (CBVersionServices) CBByteArrayReadInt64(bytes, start);
self->ip = CBNewByteArraySubReference(bytes, start + 8, 16);
// Determine IP type
self->type = CBGetIPType(CBByteArrayGetData(self->ip));
self->port = CBByteArrayReadPort(bytes, start + 24);
return start + 26;
}
bool CBBlockChainStorageLoadOrphan(void * validator, uint8_t orphanNum){
CBFullValidator * validatorObj = validator;
CBDatabase * database = (CBDatabase *)validatorObj->storage;
CB_ORPHAN_KEY[2] = orphanNum;
uint32_t len = CBDatabaseGetLength(database, CB_ORPHAN_KEY);
CBByteArray * orphanData = CBNewByteArrayOfSize(len);
if (NOT orphanData) {
CBLogError("There was an error when initialising a byte array for an orphan.");
return false;
}
if (NOT CBDatabaseReadValue(database, CB_ORPHAN_KEY, CBByteArrayGetData(orphanData), len, 0)) {
CBLogError("There was an error when reading the data for an orphan.");
CBReleaseObject(orphanData);
return false;
}
validatorObj->orphans[orphanNum] = CBNewBlockFromData(orphanData);
CBBlockDeserialise(validatorObj->orphans[orphanNum], true);
if (NOT validatorObj->orphans[orphanNum]) {
CBLogError("There was an error when creating a block object for an orphan.");
CBReleaseObject(orphanData);
return false;
}
CBReleaseObject(orphanData);
return true;
}
void * CBBlockChainStorageLoadBlock(void * validator, uint32_t blockID, uint32_t branch){
CBFullValidator * validatorObj = validator;
CBDatabase * database = (CBDatabase *)validatorObj->storage;
CB_BLOCK_KEY[2] = branch;
CBInt32ToArray(CB_BLOCK_KEY, 3, blockID);
uint32_t blockDataLen = CBDatabaseGetLength(database, CB_BLOCK_KEY);
if (NOT blockDataLen)
return NULL;
blockDataLen -= CB_BLOCK_START;
// Get block data
CBByteArray * data = CBNewByteArrayOfSize(blockDataLen);
if (NOT data) {
CBLogError("Could not initialise a byte array for loading a block.");
return NULL;
}
if (NOT CBDatabaseReadValue(database, CB_BLOCK_KEY, CBByteArrayGetData(data), blockDataLen, CB_BLOCK_START)){
CBLogError("Could not read a block from the database.");
CBReleaseObject(data);
return NULL;
}
// Make and return the block
CBBlock * block = CBNewBlockFromData(data);
CBReleaseObject(data);
if (NOT block) {
CBLogError("Could not create a block object when loading a block.");
return NULL;
}
return block;
}
bool CBBlockChainStorageLoadOutputs(void * validator, uint8_t * txHash, uint8_t ** data, uint32_t * dataAllocSize, uint32_t * position){
CBFullValidator * validatorObj = validator;
CBDatabase * database = (CBDatabase *)validatorObj->storage;
memcpy(CB_TRANSACTION_INDEX_KEY + 2, txHash, 32);
if (NOT CBDatabaseReadValue(database, CB_TRANSACTION_INDEX_KEY, CB_DATA_ARRAY, 14, 0)) {
CBLogError("Could not read a transaction reference from the transaction index.");
return false;
}
// Set position of outputs
*position = CBArrayToInt32(CB_DATA_ARRAY, CB_TRANSACTION_REF_POSITION_OUPTUTS);
// Get transaction to find position for output in the block
// Reallocate transaction data memory if needed.
if (CBArrayToInt32(CB_DATA_ARRAY, CB_TRANSACTION_REF_LENGTH_OUTPUTS) > *dataAllocSize) {
*dataAllocSize = CBArrayToInt32(CB_DATA_ARRAY, CB_TRANSACTION_REF_LENGTH_OUTPUTS);
*data = realloc(*data, *dataAllocSize);
if (NOT *data) {
CBLogError("Could not allocate memory for reading a transaction.");
return false;
}
}
// Read transaction from the block
CB_BLOCK_KEY[2] = CB_DATA_ARRAY[CB_TRANSACTION_REF_BRANCH];
memcpy(CB_BLOCK_KEY + 3, CB_DATA_ARRAY + CB_TRANSACTION_REF_BLOCK_INDEX, 4);
if (NOT CBDatabaseReadValue(database, CB_BLOCK_KEY, *data, CBArrayToInt32(CB_DATA_ARRAY, CB_TRANSACTION_REF_LENGTH_OUTPUTS), CB_BLOCK_START + *position)) {
CBLogError("Could not read a transaction from the block-chain database.");
return false;
}
return true;
}
bool CBDecodeBase58Checked(CBBigInt * bi, char * str){
if(NOT CBDecodeBase58(bi, str)) {
CBLogError("Memory failure in CBDecodeBase58.");
return false;
}
if (bi->length < 4){
CBLogError("The string passed into CBDecodeBase58Checked decoded into data that was too short.");
return false;
}
// Reverse bytes for checksum generation
uint8_t * reversed = malloc(bi->length - 4);
if (NOT reversed) {
CBLogError("Cannot allocate %i bytes of memory in CBDecodeBase58Checked", bi->length - 4);
return false;
}
for (uint8_t x = 4; x < bi->length; x++)
reversed[bi->length - 1 - x] = bi->data[x];
// The checksum uses SHA-256, twice, for some reason unknown to man.
uint8_t checksum[32];
uint8_t checksum2[32];
CBSha256(reversed, bi->length - 4, checksum);
free(reversed);
CBSha256(checksum, 32, checksum2);
bool ok = true;
for (uint8_t x = 0; x < 4; x++)
if (checksum2[x] != bi->data[3-x])
ok = false;
if (NOT ok){
CBLogError("The data passed to CBDecodeBase58Checked is invalid. Checksum does not match.");
return false;
}
return true;
}
uint32_t CBTransactionOutputSerialise(CBTransactionOutput * self){
CBByteArray * bytes = CBGetMessage(self)->bytes;
if (NOT bytes) {
CBLogError("Attempting to serialise a CBTransactionInput with no bytes.");
return 0;
}
if (NOT self->scriptObject){
CBLogError("Attempting to serialise a CBTransactionOutput without scriptObject.");
return 0;
}
CBVarInt scriptLen = CBVarIntFromUInt64(CBGetByteArray(self->scriptObject)->length);
uint32_t reqLen = 8 + scriptLen.size + CBGetByteArray(self->scriptObject)->length;
if (bytes->length < reqLen) {
CBLogError("Attempting to serialise a CBTransactionOutput with less bytes than required. %i < %i", bytes->length, reqLen);
return 0;
}
// Serialise data into the CBByteArray and rereference objects to this CBByteArray to save memory.
CBByteArraySetInt64(bytes, 0, self->value);
CBVarIntEncode(bytes, 8, scriptLen);
CBByteArrayCopyByteArray(bytes, 8 + scriptLen.size, CBGetByteArray(self->scriptObject));
CBByteArrayChangeReference(CBGetByteArray(self->scriptObject), bytes, 8 + scriptLen.size);
// Ensure length is correct
bytes->length = reqLen;
// Is serialised.
CBGetMessage(self)->serialised = true;
return reqLen;
}
uint16_t CBChainDescriptorDeserialise(CBChainDescriptor * self){
CBByteArray * bytes = CBGetMessage(self)->bytes;
if (! bytes) {
CBLogError("Attempting to deserialise a CBChainDescriptor with no bytes.");
return 0;
}
if (bytes->length < 1) {
CBLogError("Attempting to deserialise a CBChainDescriptor with no bytes");
return 0;
}
CBVarInt hashNum = CBVarIntDecode(bytes, 0);
if (hashNum.val > 500) {
CBLogError("Attempting to deserialise a CBChainDescriptor with a var int over 500.");
return 0;
}
if (bytes->length < hashNum.size + hashNum.val * 32) {
CBLogError("Attempting to deserialise a CBChainDescriptor with less bytes than required for the hashes.");
return 0;
}
// Deserialise each hash
self->hashes = malloc(sizeof(*self->hashes) * (size_t)hashNum.val);
self->hashNum = hashNum.val;
uint16_t cursor = hashNum.size;
for (uint16_t x = 0; x < self->hashNum; x++) {
self->hashes[x] = CBNewByteArraySubReference(bytes, cursor, 32);
cursor += 32;
}
return cursor;
}
uint32_t CBTransactionInputDeserialise(CBTransactionInput * self){
CBByteArray * bytes = CBGetMessage(self)->bytes;
if (! bytes) {
CBLogError("Attempting to deserialise a CBTransactionInput with no bytes.");
return 0;
}
if (bytes->length < 41) {
CBLogError("Attempting to deserialise a CBTransactionInput with less than 41 bytes.");
return 0;
}
CBVarInt scriptLen = CBVarIntDecode(bytes, 36);
if (scriptLen.val > 10000) {
CBLogError("Attempting to deserialise a CBTransactionInput with too big a script.");
return 0;
}
uint32_t reqLen = (uint32_t)(40 + scriptLen.size + scriptLen.val);
if (bytes->length < reqLen) {
CBLogError("Attempting to deserialise a CBTransactionInput with less bytes than needed according to the length for the script. %i < %i", bytes->length, reqLen);
return 0;
}
// Deserialise by subreferencing byte arrays and reading integers.
self->prevOut.hash = CBByteArraySubReference(bytes, 0, 32);
self->prevOut.index = CBByteArrayReadInt32(bytes, 32);
self->scriptObject = CBNewScriptFromReference(bytes, 36 + scriptLen.size, (uint32_t) scriptLen.val);
self->sequence = CBByteArrayReadInt32(bytes, (uint32_t) (36 + scriptLen.size + scriptLen.val));
return reqLen;
}
int CBAlertSerialiseSignature(CBAlert * self, int offset) {
CBByteArray * bytes = CBGetMessage(self)->bytes;
if (! bytes) {
CBLogError("Attempting to serialise a CBAlert with no bytes.");
return 0;
}
CBVarInt sigLen = CBVarIntFromUInt64(self->signature->length);
if (bytes->length < offset + sigLen.size + sigLen.val) {
CBLogError("Attempting to serialise a CBAlert with less bytes than required for the signature.");
return 0;
}
CBByteArraySetVarInt(bytes, offset, sigLen);
offset += sigLen.size;
CBByteArrayCopyByteArray(bytes, offset, self->signature);
CBByteArrayChangeReference(self->signature, bytes, offset);
bytes->length = offset + (int)sigLen.val;
CBGetMessage(self)->serialised = true;
return bytes->length;
}
bool CBBlockChainStorageSaveTransactionRef(void * validator, uint8_t * txHash, uint8_t branch, uint32_t blockIndex, uint32_t outputPos, uint32_t outputsLen, bool coinbase, uint32_t numOutputs){
CBFullValidator * validatorObj = validator;
CBDatabase * database = (CBDatabase *)validatorObj->storage;
memcpy(CB_TRANSACTION_INDEX_KEY + 2, txHash, 32);
if (CBDatabaseGetLength(database, CB_TRANSACTION_INDEX_KEY)) {
// We have the transaction already. Thus obtain the data already in the index.
if (NOT CBDatabaseReadValue(database, CB_TRANSACTION_INDEX_KEY, CB_DATA_ARRAY, 22, 0)) {
CBLogError("Could not read a transaction reference from the transaction index.");
return false;
}
// Increase the instance count. We change nothing else as we will use the first instance for all other instances.
CBInt32ToArray(CB_DATA_ARRAY, CB_TRANSACTION_REF_INSTANCE_COUNT, CBArrayToInt32(CB_DATA_ARRAY, CB_TRANSACTION_REF_INSTANCE_COUNT) + 1);
}else{
// This transaction has not yet been seen in the block chain.
CBInt32ToArray(CB_DATA_ARRAY, CB_TRANSACTION_REF_BLOCK_INDEX, blockIndex);
CB_DATA_ARRAY[CB_TRANSACTION_REF_BRANCH] = branch;
CBInt32ToArray(CB_DATA_ARRAY, CB_TRANSACTION_REF_POSITION_OUPTUTS, outputPos);
CBInt32ToArray(CB_DATA_ARRAY, CB_TRANSACTION_REF_LENGTH_OUTPUTS, outputsLen);
CB_DATA_ARRAY[CB_TRANSACTION_REF_IS_COINBASE] = coinbase;
// We start with an instance count of one
CBInt32ToArray(CB_DATA_ARRAY, CB_TRANSACTION_REF_INSTANCE_COUNT, 1);
}
// Always set the number of unspent outputs back to the number of outputs in the transaction
CBInt32ToArray(CB_DATA_ARRAY, CB_TRANSACTION_REF_NUM_UNSPENT_OUTPUTS, numOutputs);
// Write to the transaction index.
if (NOT CBDatabaseWriteValue(database, CB_TRANSACTION_INDEX_KEY, CB_DATA_ARRAY, 22)) {
CBLogError("Could not write transaction reference to transaction index.");
return false;
}
return true;
}
uint8_t CBNetworkAddressSerialise(CBNetworkAddress * self, bool timestamp){
CBByteArray * bytes = CBGetMessage(self)->bytes;
if (! bytes) {
CBLogError("Attempting to serialise a CBNetworkAddress with no bytes.");
return 0;
}
if (bytes->length < 26 + timestamp * 4) {
CBLogError("Attempting to serialise a CBNetworkAddress with less bytes than required.");
return 0;
}
uint8_t cursor;
if (timestamp) {
CBByteArraySetInt32(bytes, 0, (uint32_t)(self->lastSeen - self->penalty));
cursor = 4;
}else cursor = 0;
CBByteArraySetInt64(bytes, cursor, self->services);
cursor += 8;
CBByteArrayCopyByteArray(bytes, cursor, self->ip);
CBByteArrayChangeReference(self->ip, bytes, cursor);
cursor += 16;
CBByteArraySetPort(bytes, cursor, self->port);
bytes->length = cursor + 2;
CBGetMessage(self)->serialised = true;
return cursor + 2;
}
bool CBAddressStorageSaveAddress(uint64_t iself, void * address){
CBAddressStore * self = (CBAddressStore *)iself;
CBNetworkAddress * addrObj = address;
// Create key
memcpy(CB_ADDRESS_KEY + 1, CBByteArrayGetData(addrObj->ip), 16);
CBInt16ToArray(CB_ADDRESS_KEY, 17, addrObj->port);
// Create data
CBInt64ToArray(CB_DATA_ARRAY, 0, addrObj->lastSeen);
CBInt64ToArray(CB_DATA_ARRAY, 8, (uint64_t) addrObj->services);
CBInt32ToArray(CB_DATA_ARRAY, 16, addrObj->penalty);
// Write data
if (NOT CBDatabaseWriteValue(CBGetDatabase(self), CB_ADDRESS_KEY, CB_DATA_ARRAY, 20)) {
CBLogError("Could not write an address to storage.");
return false;
}
// Increase the number of addresses
CBInt32ToArray(CB_DATA_ARRAY, 0, --self->numAddresses);
if (NOT CBDatabaseWriteValue(CBGetDatabase(self), CB_ADDR_NUM_KEY, CB_DATA_ARRAY, 4)) {
CBLogError("Could not write the new number of addresses to storage.");
return false;
}
// Commit changes
if (NOT CBDatabaseCommit(CBGetDatabase(self))) {
CBLogError("Could not commit adding a new network address to storage.");
return false;
}
return true;
}
bool CBBlockChainStorageDeleteTransactionRef(void * validator, uint8_t * txHash){
CBFullValidator * validatorObj = validator;
CBDatabase * database = (CBDatabase *)validatorObj->storage;
// Place transaction hash into the key
memcpy(CB_TRANSACTION_INDEX_KEY + 2, txHash, 32);
// Read the instance count
if (NOT CBDatabaseReadValue(database, CB_TRANSACTION_INDEX_KEY, CB_DATA_ARRAY, 22, 0)) {
CBLogError("Could not read a transaction reference from storage.");
return false;
}
uint32_t txInstanceNum = CB_DATA_ARRAY[CB_TRANSACTION_REF_INSTANCE_COUNT] - 1;
if (txInstanceNum) {
// There are still more instances of this transaction. Do not remove the transaction, only make the unspent output number equal to zero and decrement the instance count.
CB_DATA_ARRAY[CB_TRANSACTION_REF_NUM_UNSPENT_OUTPUTS] = 0;
CB_DATA_ARRAY[CB_TRANSACTION_REF_INSTANCE_COUNT] = txInstanceNum;
// Write to storage.
if (NOT CBDatabaseWriteValue(database, CB_TRANSACTION_INDEX_KEY, CB_DATA_ARRAY, 22)) {
CBLogError("Could not update a transaction reference for deleting an instance.");
return false;
}
}else{
// This was the last instance.
// Remove from storage
if (NOT CBDatabaseRemoveValue(database, CB_TRANSACTION_INDEX_KEY)) {
CBLogError("Could not remove a transaction reference from storage.");
return false;
}
}
return true;
}
bool CBInitNode(CBNode * self, CBDepObject database, CBNodeFlags flags, CBNodeCallbacks nodeCallbacks, CBNetworkCommunicatorCallbacks commCallbacks, CBOnMessageReceivedAction (*onMessageReceived)(CBNode *, CBPeer *, CBMessage *)){
self->flags = flags;
self->database = database;
self->callbacks = nodeCallbacks;
self->onMessageReceived = onMessageReceived;
// Initialise network communicator
CBNetworkCommunicator * comm = CBGetNetworkCommunicator(self);
commCallbacks.onMessageReceived = CBNodeOnMessageReceived;
CBInitNetworkCommunicator(comm, CB_SERVICE_FULL_BLOCKS, commCallbacks);
// Set network communicator fields.
comm->flags = CB_NETWORK_COMMUNICATOR_AUTO_DISCOVERY | CB_NETWORK_COMMUNICATOR_AUTO_HANDSHAKE | CB_NETWORK_COMMUNICATOR_AUTO_PING;
if (flags & CB_NODE_BOOTSTRAP)
comm->flags |= CB_NETWORK_COMMUNICATOR_BOOTSTRAP;
comm->version = CB_PONG_VERSION;
comm->networkID = CB_PRODUCTION_NETWORK_BYTES; // ??? Add testnet support
CBNetworkCommunicatorSetAlternativeMessages(comm, NULL, NULL);
// Create address manager
comm->addresses = CBNewNetworkAddressManager(CBNodeOnBadTime);
comm->addresses->maxAddressesInBucket = 1000;
comm->addresses->callbackHandler = self;
// Initialise thread data
self->shutDownThread = false;
self->messageQueue = NULL;
CBNewMutex(&self->blockAndTxMutex);
CBNewMutex(&self->messageProcessMutex);
CBNewCondition(&self->messageProcessWaitCond);
CBNewThread(&self->messageProcessThread, CBNodeProcessMessages, self);
// Initialise the storage objects
if (CBNewBlockChainStorage(&self->blockChainStorage, database)) {
if (CBNewAccounterStorage(&self->accounterStorage, database)){
if (CBNewNodeStorage(&self->nodeStorage, database)){
// Setup address storage
if (CBNewAddressStorage(&comm->addrStorage, database)) {
if (CBAddressStorageLoadAddresses(comm->addrStorage, comm->addresses)){
comm->useAddrStorage = true;
return true;
}
}else
CBLogError("Could not create the address storage object for a node");
CBFreeNodeStorage(self->nodeStorage);
}else
CBLogError("Could not create the node storage object for a node");
CBFreeAccounterStorage(self->accounterStorage);
}else
CBLogError("Could not create the accounter storage object for a node");
CBFreeBlockChainStorage(self->blockChainStorage);
}else
CBLogError("Could not create the block storage object for a node");
CBDestroyNetworkCommunicator(self);
return false;
}
int CBInventoryDeserialise(CBInventory * self) {
CBByteArray * bytes = CBGetMessage(self)->bytes;
if (! bytes) {
CBLogError("Attempting to deserialise a CBInventory with no bytes.");
return CB_DESERIALISE_ERROR;
}
if (bytes->length < 37) {
CBLogError("Attempting to deserialise a CBInventory with less bytes than required for one item.");
return CB_DESERIALISE_ERROR;
}
CBVarInt itemNum = CBByteArrayReadVarInt(bytes, 0);
if (itemNum.val > 50000) {
CBLogError("Attempting to deserialise a CBInventory with a var int over 50000.");
return CB_DESERIALISE_ERROR;
}
self->itemNum = 0;
self->itemFront = NULL;
// Run through the items and deserialise each one.
int cursor = itemNum.size;
for (int x = 0; x < itemNum.val; x++) {
// Make new CBInventoryItem from the rest of the data.
CBByteArray * data = CBByteArraySubReference(bytes, cursor, bytes->length-cursor);
CBInventoryItem * item = CBNewInventoryItemFromData(data);
// Deserialise
int len = CBInventoryItemDeserialise(item);
if (len == CB_DESERIALISE_ERROR){
CBLogError("CBInventory cannot be deserialised because of an error with the CBInventoryItem number %u.", x);
CBReleaseObject(data);
return CB_DESERIALISE_ERROR;
}
// Take item
CBInventoryTakeInventoryItem(self, item);
// Adjust length
data->length = len;
CBReleaseObject(data);
cursor += len;
}
return cursor;
}
uint32_t CBInventoryItemDeserialise(CBInventoryItem * self){
CBByteArray * bytes = CBGetMessage(self)->bytes;
if (NOT bytes) {
CBLogError("Attempting to deserialise a CBInventoryItem with no bytes.");
return 0;
}
if (bytes->length < 36) {
CBLogError("Attempting to deserialise a CBInventoryItem with less than 36 bytes.");
return 0;
}
self->type = CBByteArrayReadInt32(bytes, 0);
self->hash = CBByteArraySubReference(bytes, 4, 32);
if (NOT self->hash)
return 0;
return 36;
}
void CBNodeOnValidatorError(void * vself){
CBNode * self = vself;
CBMutexUnlock(CBGetNode(self)->blockAndTxMutex);
CBLogError("There was a validation error.");
self->callbacks.onFatalNodeError(self, CB_ERROR_VALIDATION);
CBReleaseObject(self);
}
bool CBInitHDKeyFromData(CBHDKey * key, uint8_t * data, CBHDKeyVersion versionBytes, CBHDKeyType type){
CBInitHDKey(key);
// Set version bytes
key->versionBytes = versionBytes;
// Chain code
memcpy(key->chainCode, data + 13, 32);
if (type == CB_HD_KEY_TYPE_PRIVATE){
// Private
memcpy(key->keyPair->privkey, data + 46, 32);
// Calculate public key
CBKeyGetPublicKey(CBHDKeyGetPrivateKey(key), CBHDKeyGetPublicKey(key));
}else
// Assume public
memcpy(CBHDKeyGetPublicKey(key), data + 45, 33);
// Depth
key->depth = data[4];
if (key->depth == 0) {
// Master
key->childID.priv = false;
key->childID.childNumber = 0;
for (uint8_t x = 5; x < 9; x++)
if (data[x] != 0) {
CBLogError("The fingerprint of the master key is not zero.");
return false;
}
}else{
// Not master
uint32_t childNum = CBArrayToInt32BigEndian(data, 9);
key->childID.priv = childNum >> 31;
key->childID.childNumber = childNum & 0x8fffffff;
}
return true;
}
void CBNodeOnBadTime(void * vself){
CBNode * self = vself;
CBMutexUnlock(CBGetNode(self)->blockAndTxMutex);
CBLogError("The system time is potentially incorrect. It does not match with the network time.");
self->callbacks.onFatalNodeError(self, CB_ERROR_BAD_TIME);
CBReleaseObject(self);
}
uint32_t CBBlockHeadersSerialise(CBBlockHeaders * self, bool force){
CBByteArray * bytes = CBGetMessage(self)->bytes;
if (! bytes) {
CBLogError("Attempting to serialise a CBBlockHeaders with no bytes.");
return 0;
}
if (bytes->length < 81 * self->headerNum) {
CBLogError("Attempting to deserialise a CBBlockHeaders with less bytes than minimally required.");
return 0;
}
CBVarInt num = CBVarIntFromUInt64(self->headerNum);
CBVarIntEncode(bytes, 0, num);
uint16_t cursor = num.size;
for (uint16_t x = 0; x < num.val; x++) {
if (! CBGetMessage(self->blockHeaders[x])->serialised // Serailise if not serialised yet.
// Serialise if force is true.
|| force
// If the data shares the same data as the block headers message, re-serialise the block header, in case it got overwritten.
|| CBGetMessage(self->blockHeaders[x])->bytes->sharedData == bytes->sharedData) {
if (CBGetMessage(self->blockHeaders[x])->serialised)
// Release old byte array
CBReleaseObject(CBGetMessage(self->blockHeaders[x])->bytes);
CBGetMessage(self->blockHeaders[x])->bytes = CBByteArraySubReference(bytes, cursor, bytes->length-cursor);
if (! CBGetMessage(self->blockHeaders[x])->bytes) {
CBLogError("Cannot create a new CBByteArray sub reference in CBBlockHeadersSerialise for the header number %u", x);
return 0;
}
if (! CBBlockSerialise(self->blockHeaders[x], false, force)) { // false for no transactions.
CBLogError("CBBlockHeaders cannot be serialised because of an error with the CBBlock number %u.", x);
// Release CBByteArray objects to avoid problems overwritting pointer without release, if serialisation is tried again.
for (uint8_t y = 0; y < x + 1; y++)
CBReleaseObject(CBGetMessage(self->blockHeaders[y])->bytes);
return 0;
}
}else{
// Move serialsed data to one location
CBByteArrayCopyByteArray(bytes, cursor, CBGetMessage(self->blockHeaders[x])->bytes);
CBByteArrayChangeReference(CBGetMessage(self->blockHeaders[x])->bytes, bytes, cursor);
}
cursor += CBGetMessage(self->blockHeaders[x])->bytes->length;
}
// Ensure length is correct
bytes->length = cursor;
// Is now serialised
CBGetMessage(self)->serialised = true;
return cursor;
}
int CBBlockHeadersDeserialise(CBBlockHeaders * self) {
CBByteArray * bytes = CBGetMessage(self)->bytes;
if (! bytes) {
CBLogError("Attempting to deserialise a CBBlockHeaders with no bytes.");
return CB_DESERIALISE_ERROR;
}
if (bytes->length < 82) {
CBLogError("Attempting to deserialise a CBBlockHeaders with less bytes than required for one header.");
return CB_DESERIALISE_ERROR;
}
CBVarInt headerNum = CBByteArrayReadVarInt(bytes, 0);
if (headerNum.val > 2000) {
CBLogError("Attempting to deserialise a CBBlockHeaders with a var int over 2000.");
return CB_DESERIALISE_ERROR;
}
// Deserialise each header
self->headerNum = headerNum.val;
int cursor = headerNum.size;
for (int x = 0; x < headerNum.val; x++) {
// Make new CBBlock from the rest of the data.
CBByteArray * data = CBByteArraySubReference(bytes, cursor, bytes->length-cursor);
self->blockHeaders[x] = CBNewBlockFromData(data);
// Deserialise
int len = CBBlockDeserialise(self->blockHeaders[x], false); // false for no transactions. Only the header.
if (len == CB_DESERIALISE_ERROR){
CBLogError("CBBlockHeaders cannot be deserialised because of an error with the CBBlock number %" PRIu16 ".", x);
CBReleaseObject(data);
return CB_DESERIALISE_ERROR;
}
// Adjust length
data->length = len;
CBReleaseObject(data);
cursor += len;
}
return cursor;
}
int CBPingPongDeserialise(CBPingPong * self) {
CBByteArray * bytes = CBGetMessage(self)->bytes;
if (! bytes) {
CBLogError("Attempting to deserialise a CBPingPong with no bytes.");
return CB_DESERIALISE_ERROR;
}
if (bytes->length < 8) {
CBLogError("Attempting to deserialise a CBPingPong with less than 8 bytes.");
return CB_DESERIALISE_ERROR;
}
self->ID = CBByteArrayReadInt64(bytes, 0);
return 8;
}
uint32_t CBInventoryItemSerialise(CBInventoryItem * self){
CBByteArray * bytes = CBGetMessage(self)->bytes;
if (NOT bytes) {
CBLogError("Attempting to serialise a CBInventoryItem with no bytes.");
return 0;
}
if (bytes->length < 36) {
CBLogError("Attempting to serialise a CBInventoryItem with less than 36 bytes.");
return 0;
}
CBByteArraySetInt32(bytes, 0, self->type);
CBByteArrayCopyByteArray(bytes, 4, self->hash);
CBByteArrayChangeReference(self->hash, bytes, 4);
bytes->length = 36;
CBGetMessage(self)->serialised = true;
return 36;
}
bool CBBlockChainStorageLoadBranchWork(void * validator, uint8_t branchNum){
CBFullValidator * validatorObj = validator;
CBDatabase * database = (CBDatabase *)validatorObj->storage;
// Get work
CB_WORK_KEY[2] = branchNum;
uint8_t workLen = CBDatabaseGetLength(database, CB_WORK_KEY);
if (NOT CBBigIntAlloc(&validatorObj->branches[branchNum].work, workLen)){
CBLogError("There was an error when allocating memory for a branch's work.");
return false;
}
validatorObj->branches[branchNum].work.length = workLen;
if (NOT CBDatabaseReadValue(database, CB_WORK_KEY, validatorObj->branches[branchNum].work.data, workLen, 0)) {
CBLogError("There was an error when reading the work for a branch.");
free(validatorObj->branches[branchNum].work.data);
return false;
}
return true;
}
uint32_t CBNetworkAddressListSerialise(CBNetworkAddressList * self, bool force){
CBByteArray * bytes = CBGetMessage(self)->bytes;
if (! bytes) {
CBLogError("Attempting to serialise a CBNetworkAddress with no bytes.");
return 0;
}
CBVarInt num = CBVarIntFromUInt64(self->addrNum);
if (bytes->length < (26 + self->timeStamps * 4) * self->addrNum + num.size) {
CBLogError("Attempting to serialise a CBNetworkAddress without enough bytes.");
return 0;
}
CBVarIntEncode(bytes, 0, num);
uint16_t cursor = num.size;
for (uint8_t x = 0; x < num.val; x++) {
if (! CBGetMessage(self->addresses[x])->serialised // Serailise if not serialised yet.
// Serialise if force is true.
|| force
// If the data shares the same data as this address broadcast, re-serialise the address, in case it got overwritten.
|| CBGetMessage(self->addresses[x])->bytes->sharedData == bytes->sharedData
|| (CBGetMessage(self->addresses[x])->bytes->length != 26) ^ self->timeStamps) {
if (CBGetMessage(self->addresses[x])->serialised)
// Release old byte array
CBReleaseObject(CBGetMessage(self->addresses[x])->bytes);
CBGetMessage(self->addresses[x])->bytes = CBByteArraySubReference(bytes, cursor, bytes->length-cursor);
if (! CBNetworkAddressSerialise(self->addresses[x], self->timeStamps)) {
CBLogError("CBNetworkAddress cannot be serialised because of an error with the CBNetworkAddress number %u.", x);
// Release CBByteArray objects to avoid problems overwritting pointer without release, if serialisation is tried again.
for (uint8_t y = 0; y < x + 1; y++)
CBReleaseObject(CBGetMessage(self->addresses[y])->bytes);
return 0;
}
}else{
// Move serialsed data to one location
CBByteArrayCopyByteArray(bytes, cursor, CBGetMessage(self->addresses[x])->bytes);
CBByteArrayChangeReference(CBGetMessage(self->addresses[x])->bytes, bytes, cursor);
}
cursor += CBGetMessage(self->addresses[x])->bytes->length;
}
// Change bytes length
bytes->length = cursor;
// Is now serialised
CBGetMessage(self)->serialised = true;
return cursor;
}
bool CBAddressStorageLoadAddresses(uint64_t iself, void * addrMan){
CBDatabase * database = (CBDatabase *)iself;
CBAddressManager * addrManObj = addrMan;
CBPosition it;
// The first element shoudl be the number of addresses so get second element to begin with.
if (CBAssociativeArrayGetElement(&database->index, &it, 1)) for(;;) {
uint8_t * key = it.node->elements[it.index];
CBIndexValue * val = (CBIndexValue *)(key + *key + 1);
if (val->length) {
// Is not deleted.
// Read data
uint64_t file = CBDatabaseGetFile(database, val->fileID);
if (NOT file) {
CBLogError("Could not open a file for loading a network address.");
return false;
}
if (NOT CBFileSeek(file, val->pos)){
CBLogError("Could not read seek a file to a network address.");
return false;
}
if (NOT CBFileRead(file, CB_DATA_ARRAY, 20)) {
CBLogError("Could not read a network address from a file.");
return false;
}
// Create network address object and add to the address manager.
CBByteArray * ip = CBNewByteArrayWithDataCopy(key + 1, 16);
CBNetworkAddress * addr = CBNewNetworkAddress(CBArrayToInt64(CB_DATA_ARRAY, 0),
ip,
CBArrayToInt16(key, 17),
(CBVersionServices) CBArrayToInt64(CB_DATA_ARRAY, 8),
true);
addr->penalty = CBArrayToInt32(CB_DATA_ARRAY, 16);
if (NOT CBAddressManagerTakeAddress(addrManObj, addr)) {
CBLogError("Could not create and add a network address to the address manager.");
return false;
}
CBReleaseObject(ip);
}
if (CBAssociativeArrayIterate(&database->index, &it))
break;
}
return true;
}
bool CBBlockChainStorageSaveBranchWork(void * validator, uint8_t branch){
CBFullValidator * validatorObj = validator;
CBDatabase * database = (CBDatabase *)validatorObj->storage;
CB_WORK_KEY[2] = branch;
if (NOT CBDatabaseWriteValue(database, CB_WORK_KEY, validatorObj->branches[branch].work.data, validatorObj->branches[branch].work.length)) {
CBLogError("Could not write branch work.");
return false;
}
return true;
}
bool CBKeyPairGenerate(CBKeyPair * keyPair){
// Generate private key from a CSPRNG.
if (!CBGet32RandomBytes(keyPair->privkey)) {
CBLogError("Could not generate private key from 32 random bytes");
return false;
}
// Get public key
CBKeyGetPublicKey(keyPair->privkey, keyPair->pubkey.key);
return true;
}
bool CBBlockChainStorageDeleteUnspentOutput(void * validator, uint8_t * txHash, uint32_t outputIndex, bool decrement){
CBFullValidator * validatorObj = validator;
CBDatabase * database = (CBDatabase *)validatorObj->storage;
// Place transaction hash into the key
memcpy(CB_UNSPENT_OUTPUT_KEY + 2, txHash, 32);
// Place output index into the key
CBInt32ToArray(CB_UNSPENT_OUTPUT_KEY, 34, outputIndex);
// Remove from storage
if (NOT CBDatabaseRemoveValue(database, CB_UNSPENT_OUTPUT_KEY)) {
CBLogError("Could not remove an unspent output reference from storage.");
return false;
}
if (decrement
// For the transaction, decrement the number of unspent outputs
&& NOT CBBlockChainStorageChangeUnspentOutputsNum(database, txHash, -1)) {
CBLogError("Could not decrement the number of unspent outputs for a transaction.");
return false;
}
return true;
}
CBHDKey * CBNewHDKeyFromData(uint8_t * data){
CBHDKeyVersion versionBytes = CBArrayToInt32BigEndian(data, 0);
CBHDKeyType type = CBHDKeyGetType(versionBytes);
if (type == CB_HD_KEY_TYPE_UNKNOWN) {
CBLogError("Unknown key type.");
return NULL;
}
// Allocate memory for key
CBHDKey * key = CBNewHDKey(type == CB_HD_KEY_TYPE_PRIVATE);
return CBInitHDKeyFromData(key, data, versionBytes, type) ? key : NULL;
}