add _t suffix to uint256, uint160 and vector types

doc/signing.md

@@ -22,7 +22,7 @@ This document describes the process of message signing within libdogecoin. It ai
 char* sign_message(char* privkey, char* msg) {
     if (!privkey || !msg) return false;
 
-    uint256 message_bytes;
+    uint256_t message_bytes;
     hash_message(msg, message_bytes);
 
     size_t compact_signature_length = 65;
@@ -66,7 +66,7 @@ char* sig = sign_message("QUtnMFjt3JFk1NfeMe6Dj5u4p25DHZA54FsvEFAiQxcNP4bZkPu2",
 int verify_message(char* sig, char* msg, char* address) {
     if (!(sig || msg || address)) return false;
 
-    uint256 message_bytes;
+    uint256_t message_bytes;
     hash_message(msg, message_bytes);
 
     size_t encoded_length = strlen((const char*)sig);

doc/transaction_extended.md

@@ -16,8 +16,8 @@ The `dogecoin_tx` structure describes a dogecoin transaction in reply to getdata
 ```
 typedef struct dogecoin_tx_ {
     int32_t version;
-    vector* vin;
-    vector* vout;
+    vector_t* vin;
+    vector_t* vout;
     uint32_t locktime;
 } dogecoin_tx;
 ```
@@ -51,7 +51,7 @@ The `dogecoin_tx_outpoint` structure represented above as `prevout` consists of
 `include/dogecoin/tx.h`:
 ```
 typedef struct dogecoin_tx_outpoint_ {
-    uint256 hash;
+    uint256_t hash;
     uint32_t n;
 } dogecoin_tx_outpoint;
 ```
@@ -88,7 +88,7 @@ OP_DUP OP_HASH160    Bytes to push
 ```
 ##### **Note: scriptSig is in the input of the spending transaction and scriptPubKey is in the output of the previously unspent i.e. "available" transaction.**
 
-Here is how each word is processed: 
+Here is how each word is processed:
 | Stack      | Script | Description |
 | ----------- | ----------- | - |
 | Empty | `<sig> <pubKey>` OP_DUP OP_HASH160 `<pubKeyHash>` OP_EQUALVERIFY OP_CHECKSIG | scriptSig and scriptPubKey are combined. |

include/dogecoin/arith_uint256.h

@@ -57,7 +57,7 @@ void arith_shift_left(arith_uint256* input, unsigned int shift);
 void arith_shift_right(arith_uint256* input, unsigned int shift);
 arith_uint256* set_compact(arith_uint256* hash, uint32_t compact, dogecoin_bool *pf_negative, dogecoin_bool *pf_overflow);
 uint8_t* arith_to_uint256(const arith_uint256* a);
-arith_uint256* uint_to_arith(const uint256* a);
+arith_uint256* uint_to_arith(const uint256_t* a);
 uint64_t get_low64(arith_uint256* a);
 arith_uint256* div_arith_uint256(arith_uint256* a, arith_uint256* b);
 arith_uint256* add_arith_uint256(arith_uint256* a, arith_uint256* b);

include/dogecoin/auxpow.h

@@ -44,7 +44,7 @@ LIBDOGECOIN_BEGIN_DECL
 static const unsigned char pch_merged_mining_header[] = { 0xfa, 0xbe, 'm', 'm' };
 
 int get_expected_index(uint32_t nNonce, int nChainId, unsigned h);
-uint256* check_merkle_branch(uint256* hash, const vector* merkle_branch, int index);
+uint256_t* check_merkle_branch(uint256_t* hash, const vector_t* merkle_branch, int index);
 
 LIBDOGECOIN_END_DECL
 

include/dogecoin/base58.h

@@ -3,7 +3,7 @@
  * Copyright (c) 2013-2014 Pavol Rusnak
  * Copyright (c) 2022 bluezr
  * Copyright (c) 2022 The Dogecoin Foundation
- * 
+ *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
@@ -39,8 +39,8 @@ LIBDOGECOIN_API size_t dogecoin_base58_decode_check(const char* str, uint8_t* da
 LIBDOGECOIN_API int dogecoin_base58_encode(char* b58, size_t* b58sz, const void* data, size_t binsz);
 LIBDOGECOIN_API int dogecoin_base58_decode(void* bin, size_t* binszp, const char* b58, size_t b58sz);
 
-LIBDOGECOIN_API dogecoin_bool dogecoin_p2pkh_addr_from_hash160(const uint160 hashin, const dogecoin_chainparams* chain, char* addrout, size_t len);
-LIBDOGECOIN_API dogecoin_bool dogecoin_p2sh_addr_from_hash160(const uint160 hashin, const dogecoin_chainparams* chain, char* addrout, size_t len);
+LIBDOGECOIN_API dogecoin_bool dogecoin_p2pkh_addr_from_hash160(const uint160_t hashin, const dogecoin_chainparams* chain, char* addrout, size_t len);
+LIBDOGECOIN_API dogecoin_bool dogecoin_p2sh_addr_from_hash160(const uint160_t hashin, const dogecoin_chainparams* chain, char* addrout, size_t len);
 
 LIBDOGECOIN_END_DECL
 

include/dogecoin/bip32.h

@@ -60,7 +60,7 @@ LIBDOGECOIN_API void dogecoin_hdnode_serialize_public(const dogecoin_hdnode* nod
 LIBDOGECOIN_API void dogecoin_hdnode_serialize_private(const dogecoin_hdnode* node, const dogecoin_chainparams* chain, char* str, size_t strsize);
 
 /* gives out the raw sha256/ripemd160 hash */
-LIBDOGECOIN_API void dogecoin_hdnode_get_hash160(const dogecoin_hdnode* node, uint160 hash160_out);
+LIBDOGECOIN_API void dogecoin_hdnode_get_hash160(const dogecoin_hdnode* node, uint160_t hash160_out);
 LIBDOGECOIN_API void dogecoin_hdnode_get_p2pkh_address(const dogecoin_hdnode* node, const dogecoin_chainparams* chain, char* str, size_t strsize);
 LIBDOGECOIN_API dogecoin_bool dogecoin_hdnode_get_pub_hex(const dogecoin_hdnode* node, char* str, size_t* strsize);
 LIBDOGECOIN_API dogecoin_bool dogecoin_hdnode_deserialize(const char* str, const dogecoin_chainparams* chain, dogecoin_hdnode* node);

include/dogecoin/block.h

@@ -43,14 +43,14 @@ LIBDOGECOIN_BEGIN_DECL
 
 typedef struct _auxpow {
     dogecoin_bool is;
-    dogecoin_bool (*check)(void* ctx, uint256* hash, uint32_t chainid, dogecoin_chainparams* params);
+    dogecoin_bool (*check)(void* ctx, uint256_t* hash, uint32_t chainid, dogecoin_chainparams* params);
     void *ctx;
 } auxpow;
 
 typedef struct dogecoin_block_header_ {
     int32_t version;
-    uint256 prev_block;
-    uint256 merkle_root;
+    uint256_t prev_block;
+    uint256_t merkle_root;
     uint32_t timestamp;
     uint32_t bits;
     uint32_t nonce;
@@ -60,12 +60,12 @@ typedef struct dogecoin_block_header_ {
 typedef struct dogecoin_auxpow_block_ {
     dogecoin_block_header* header;
     dogecoin_tx* parent_coinbase;
-    uint256 parent_hash;
+    uint256_t parent_hash;
     uint8_t parent_merkle_count;
-    uint256* parent_coinbase_merkle;
+    uint256_t* parent_coinbase_merkle;
     uint32_t parent_merkle_index;
     uint8_t aux_merkle_count;
-    uint256* aux_merkle_branch;
+    uint256_t* aux_merkle_branch;
     uint32_t aux_merkle_index;
     dogecoin_block_header* parent_header;
 } dogecoin_auxpow_block;
@@ -74,11 +74,11 @@ LIBDOGECOIN_API dogecoin_block_header* dogecoin_block_header_new();
 LIBDOGECOIN_API void dogecoin_block_header_free(dogecoin_block_header* header);
 LIBDOGECOIN_API dogecoin_auxpow_block* dogecoin_auxpow_block_new();
 LIBDOGECOIN_API void dogecoin_auxpow_block_free(dogecoin_auxpow_block* block);
-LIBDOGECOIN_API int dogecoin_block_header_deserialize(dogecoin_block_header* header, struct const_buffer* buf, const dogecoin_chainparams *params, uint256* chainwork);
-LIBDOGECOIN_API int deserialize_dogecoin_auxpow_block(dogecoin_auxpow_block* block, struct const_buffer* buffer, const dogecoin_chainparams *params, uint256* chainwork);
+LIBDOGECOIN_API int dogecoin_block_header_deserialize(dogecoin_block_header* header, struct const_buffer* buf, const dogecoin_chainparams *params, uint256_t* chainwork);
+LIBDOGECOIN_API int deserialize_dogecoin_auxpow_block(dogecoin_auxpow_block* block, struct const_buffer* buffer, const dogecoin_chainparams *params, uint256_t* chainwork);
 LIBDOGECOIN_API void dogecoin_block_header_serialize(cstring* s, const dogecoin_block_header* header);
 LIBDOGECOIN_API void dogecoin_block_header_copy(dogecoin_block_header* dest, const dogecoin_block_header* src);
-LIBDOGECOIN_API dogecoin_bool dogecoin_block_header_hash(dogecoin_block_header* header, uint256 hash);
+LIBDOGECOIN_API dogecoin_bool dogecoin_block_header_hash(dogecoin_block_header* header, uint256_t hash);
 
 LIBDOGECOIN_END_DECL
 

include/dogecoin/blockchain.h

@@ -39,8 +39,8 @@ LIBDOGECOIN_BEGIN_DECL
  */
 typedef struct dogecoin_blockindex {
     uint32_t height;
-    uint256 hash;
-    uint256 chainwork;
+    uint256_t hash;
+    uint256_t chainwork;
     dogecoin_block_header header;
     struct dogecoin_blockindex* prev;
 } dogecoin_blockindex;

include/dogecoin/chainparams.h

@@ -46,14 +46,14 @@ typedef struct dogecoin_chainparams_ {
     uint32_t b58prefix_bip32_privkey;
     uint32_t b58prefix_bip32_pubkey;
     const unsigned char netmagic[4];
-    uint256 genesisblockhash;
-    uint256 genesisblockchainwork;
+    uint256_t genesisblockhash;
+    uint256_t genesisblockchainwork;
     int default_port;
     dogecoin_dns_seed dnsseeds[8];
     dogecoin_bool strict_id;
     dogecoin_bool auxpow_id;
-    uint256 pow_limit;
-    uint256 minimumchainwork;
+    uint256_t pow_limit;
+    uint256_t minimumchainwork;
 } dogecoin_chainparams;
 
 typedef struct dogecoin_checkpoint_ {

include/dogecoin/dogecoin.h

@@ -34,7 +34,7 @@
 #include <stdlib.h>
 #include <string.h>
 
-#if defined(HAVE_CONFIG_H)
+#if defined(HAVE_CONFIG_H) && !defined(USE_LIB)
 #include <config/libdogecoin-config.h>
 #endif
 
@@ -146,8 +146,8 @@ typedef uint8_t dogecoin_bool; //!serialize, c/c++ save bool
 LIBDOGECOIN_BEGIN_DECL
 
 /* Data array types */
-typedef uint8_t uint256[32];
-typedef uint8_t uint160[20];
+typedef uint8_t uint256_t[32];
+typedef uint8_t uint160_t[20];
 typedef uint8_t SEED[MAX_SEED_SIZE];
 
 static const int WIDTH = 0x0000100/32;

include/dogecoin/ecc.h

@@ -57,22 +57,22 @@ LIBDOGECOIN_API dogecoin_bool dogecoin_ecc_verify_privatekey(const uint8_t* priv
 LIBDOGECOIN_API dogecoin_bool dogecoin_ecc_verify_pubkey(const uint8_t* public_key, dogecoin_bool compressed);
 
 //!create a DER signature (72-74 bytes) with private key
-LIBDOGECOIN_API dogecoin_bool dogecoin_ecc_sign(const uint8_t* private_key, const uint256 hash, unsigned char* sigder, size_t* outlen);
+LIBDOGECOIN_API dogecoin_bool dogecoin_ecc_sign(const uint8_t* private_key, const uint256_t hash, unsigned char* sigder, size_t* outlen);
 
 //!create a compact (64bytes) signature with private key
-LIBDOGECOIN_API dogecoin_bool dogecoin_ecc_sign_compact(const uint8_t* private_key, const uint256 hash, unsigned char* sigcomp, size_t* outlen);
+LIBDOGECOIN_API dogecoin_bool dogecoin_ecc_sign_compact(const uint8_t* private_key, const uint256_t hash, unsigned char* sigcomp, size_t* outlen);
 
 //!create a compact recoverable (65bytes) signature with private key
-LIBDOGECOIN_API dogecoin_bool dogecoin_ecc_sign_compact_recoverable(const uint8_t* private_key, const uint256 hash, unsigned char* sigcomprec, size_t* outlen, int* recid);
+LIBDOGECOIN_API dogecoin_bool dogecoin_ecc_sign_compact_recoverable(const uint8_t* private_key, const uint256_t hash, unsigned char* sigcomprec, size_t* outlen, int* recid);
 
 //!create a compact recoverable (65bytes) signature with private key with compressed or uncompressed bytes flag
-LIBDOGECOIN_API dogecoin_bool dogecoin_ecc_sign_compact_recoverable_fcomp(const uint8_t* private_key, const uint256 hash, unsigned char* sigrec, size_t* outlen, int* recid, bool fCompressed);
+LIBDOGECOIN_API dogecoin_bool dogecoin_ecc_sign_compact_recoverable_fcomp(const uint8_t* private_key, const uint256_t hash, unsigned char* sigrec, size_t* outlen, int* recid, bool fCompressed);
 
 //!recover a specific pubkey from a signature and recid
-LIBDOGECOIN_API dogecoin_bool dogecoin_recover_pubkey(const unsigned char* sigrec, const uint256 hash, const int recid, uint8_t* public_key, size_t* outlen);
+LIBDOGECOIN_API dogecoin_bool dogecoin_recover_pubkey(const unsigned char* sigrec, const uint256_t hash, const int recid, uint8_t* public_key, size_t* outlen);
 
 //!recover a pubkey from a signature and recid
-LIBDOGECOIN_API dogecoin_bool dogecoin_ecc_recover_pubkey(const unsigned char* sigrec, const uint256 hash, const int recid, uint8_t* public_key, size_t* outlen);
+LIBDOGECOIN_API dogecoin_bool dogecoin_ecc_recover_pubkey(const unsigned char* sigrec, const uint256_t hash, const int recid, uint8_t* public_key, size_t* outlen);
 
 //!converts (and normalized) a compact signature to DER
 LIBDOGECOIN_API dogecoin_bool dogecoin_ecc_compact_to_der_normalized(unsigned char* sigcomp_in, unsigned char* sigder_out, size_t* sigder_len_out);
@@ -81,10 +81,10 @@ LIBDOGECOIN_API dogecoin_bool dogecoin_ecc_compact_to_der_normalized(unsigned ch
 LIBDOGECOIN_API dogecoin_bool dogecoin_ecc_der_to_compact(unsigned char* sigder_in, size_t sigder_len, unsigned char* sigcomp_out);
 
 //!verify DER signature with public key
-LIBDOGECOIN_API dogecoin_bool dogecoin_ecc_verify_sig(const uint8_t* public_key, dogecoin_bool compressed, const uint256 hash, unsigned char* sigder, size_t siglen);
+LIBDOGECOIN_API dogecoin_bool dogecoin_ecc_verify_sig(const uint8_t* public_key, dogecoin_bool compressed, const uint256_t hash, unsigned char* sigder, size_t siglen);
 
 //!verify compact signature with public key
-LIBDOGECOIN_API dogecoin_bool dogecoin_ecc_verify_sigcmp(const uint8_t* public_key, dogecoin_bool compressed, const uint256 hash, unsigned char* sigcmp);
+LIBDOGECOIN_API dogecoin_bool dogecoin_ecc_verify_sigcmp(const uint8_t* public_key, dogecoin_bool compressed, const uint256_t hash, unsigned char* sigcmp);
 
 LIBDOGECOIN_END_DECL
 

include/dogecoin/hash.h

@@ -41,53 +41,53 @@
 
 LIBDOGECOIN_BEGIN_DECL
 
-LIBDOGECOIN_API static inline dogecoin_bool dogecoin_hash_is_empty(uint256 hash)
+LIBDOGECOIN_API static inline dogecoin_bool dogecoin_hash_is_empty(uint256_t hash)
 {
     return hash[0] == 0 && !memcmp(hash, hash + 1, 19);
 }
 
-LIBDOGECOIN_API static inline void dogecoin_hash_clear(uint256 hash)
+LIBDOGECOIN_API static inline void dogecoin_hash_clear(uint256_t hash)
 {
     dogecoin_mem_zero(hash, DOGECOIN_HASH_LENGTH);
 }
 
-LIBDOGECOIN_API static inline dogecoin_bool dogecoin_hash_equal(uint256 hash_a, uint256 hash_b)
+LIBDOGECOIN_API static inline dogecoin_bool dogecoin_hash_equal(uint256_t hash_a, uint256_t hash_b)
 {
     return (memcmp(hash_a, hash_b, DOGECOIN_HASH_LENGTH) == 0);
 }
 
-LIBDOGECOIN_API static inline void dogecoin_hash_set(uint256 hash_dest, const uint256 hash_src)
+LIBDOGECOIN_API static inline void dogecoin_hash_set(uint256_t hash_dest, const uint256_t hash_src)
 {
     memcpy_safe(hash_dest, hash_src, DOGECOIN_HASH_LENGTH);
 }
 
-LIBDOGECOIN_API static inline void dogecoin_hash(const unsigned char* datain, size_t length, uint256 hashout)
+LIBDOGECOIN_API static inline void dogecoin_hash(const unsigned char* datain, size_t length, uint256_t hashout)
 {
     sha256_raw(datain, length, hashout);
     sha256_raw(hashout, SHA256_DIGEST_LENGTH, hashout); // dogecoin double sha256 hash
 }
 
-LIBDOGECOIN_API static inline dogecoin_bool dogecoin_dblhash(const unsigned char* datain, size_t length, uint256 hashout)
+LIBDOGECOIN_API static inline dogecoin_bool dogecoin_dblhash(const unsigned char* datain, size_t length, uint256_t hashout)
 {
     sha256_raw(datain, length, hashout);
     sha256_raw(hashout, SHA256_DIGEST_LENGTH, hashout); // dogecoin double sha256 hash
     return true;
 }
 
-LIBDOGECOIN_API static inline void dogecoin_hash_sngl_sha256(const unsigned char* datain, size_t length, uint256 hashout)
+LIBDOGECOIN_API static inline void dogecoin_hash_sngl_sha256(const unsigned char* datain, size_t length, uint256_t hashout)
 {
     sha256_raw(datain, length, hashout); // single sha256 hash
 }
 
-LIBDOGECOIN_API static inline void dogecoin_get_auxpow_hash(const uint32_t version, uint256 hashout)
+LIBDOGECOIN_API static inline void dogecoin_get_auxpow_hash(const uint32_t version, uint256_t hashout)
 {
     scrypt_1024_1_1_256(BEGIN(version), BEGIN(hashout));
 }
 
 DISABLE_WARNING_PUSH
 DISABLE_WARNING(-Wunused-function)
 DISABLE_WARNING(-Wunused-variable)
-typedef uint256 chain_code;
+typedef uint256_t chain_code;
 
 typedef struct _chash256 {
     sha256_context* sha;
@@ -107,19 +107,19 @@ static inline chash256* dogecoin_chash256_init() {
     return chash;
 }
 
-// Hashes the data from two uint256 values and returns the double SHA-256 hash.
-static inline uint256* Hash(const uint256* p1, const uint256* p2) {
-    uint256* result = dogecoin_uint256_vla(1);
+// Hashes the data from two uint256_t values and returns the double SHA-256 hash.
+static inline uint256_t* Hash(const uint256_t* p1, const uint256_t* p2) {
+    uint256_t* result = dogecoin_uint256_vla(1);
     chash256* chash = dogecoin_chash256_init();
 
-    // Write the first uint256 to the hash context
+    // Write the first uint256_t to the hash context
     if (p1) {
-        chash->write(chash->sha, (const uint8_t*)p1, sizeof(uint256));
+        chash->write(chash->sha, (const uint8_t*)p1, sizeof(uint256_t));
     }
 
-    // Write the second uint256 to the hash context
+    // Write the second uint256_t to the hash context
     if (p2) {
-        chash->write(chash->sha, (const uint8_t*)p2, sizeof(uint256));
+        chash->write(chash->sha, (const uint8_t*)p2, sizeof(uint256_t));
     }
 
     // Finalize and reset for double hashing
@@ -148,11 +148,11 @@ typedef struct hashwriter {
     int n_type;
     int n_version;
     cstring* cstr;
-    uint256* hash;
+    uint256_t* hash;
     int (*get_type)(struct hashwriter* hw);
     int (*get_version)(struct hashwriter* hw);
     void (*write_hash)(struct hashwriter* hw, const char* pch, size_t size);
-    uint256* (*get_hash)(struct hashwriter* hw);
+    uint256_t* (*get_hash)(struct hashwriter* hw);
     void (*ser)(cstring* cstr, const void* obj);
 } hashwriter;
 
@@ -168,7 +168,7 @@ static void write_hash(struct hashwriter* hw, const char* pch, size_t size) {
     hw->ctx->write(hw->ctx->sha, (const unsigned char*)pch, size);
 }
 
-static uint256* get_hash(struct hashwriter* hw) {
+static uint256_t* get_hash(struct hashwriter* hw) {
     dogecoin_dblhash((const unsigned char*)hw->cstr->str, hw->cstr->len, *hw->hash);
     cstr_free(hw->cstr, true);
     return hw->hash;
@@ -289,10 +289,10 @@ static uint64_t siphasher_finalize(struct siphasher* sh) {
 }
 
 typedef union u256 {
-    uint256 data;
+    uint256_t data;
 } u256;
 
-static uint64_t get_uint64(uint256* data, int pos) {
+static uint64_t get_uint64(uint256_t* data, int pos) {
     const uint8_t* ptr = (const uint8_t*)data + pos * 8;
     return ((uint64_t)ptr[0]) | \
             ((uint64_t)ptr[1]) << 8 | \
@@ -304,14 +304,14 @@ static uint64_t get_uint64(uint256* data, int pos) {
             ((uint64_t)ptr[7]) << 56;
 }
 
-static inline union u256 init_u256(uint256* val) {
+static inline union u256 init_u256(uint256_t* val) {
     union u256* u256 = dogecoin_calloc(1, sizeof(*u256));
     memcpy_safe(u256->data, dogecoin_uint256_vla(1), 32);
     if (val != NULL) memcpy(u256->data, val, 32);
     return *u256;
 }
 
-static uint64_t siphash_u256(uint64_t k0, uint64_t k1, uint256* val) {
+static uint64_t siphash_u256(uint64_t k0, uint64_t k1, uint256_t* val) {
     /* Specialized implementation for efficiency */
     uint64_t d = get_uint64(val, 0);
     uint64_t v0 = 0x736f6d6570736575ULL ^ k0;

include/dogecoin/headersdb.h

@@ -47,12 +47,12 @@ typedef struct dogecoin_headers_db_interface_
     void* (*init)(const dogecoin_chainparams* chainparams, dogecoin_bool inmem_only);
     void (*free)(void *db);
     dogecoin_bool (*load)(void *db, const char *filename, dogecoin_bool prompt);
-    void (*fill_blocklocator_tip)(void* db, vector *blocklocators);
+    void (*fill_blocklocator_tip)(void* db, vector_t *blocklocators);
     dogecoin_blockindex *(*connect_hdr)(void* db, struct const_buffer *buf, dogecoin_bool load_process, dogecoin_bool *connected);
     dogecoin_blockindex* (*getchaintip)(void *db);
     dogecoin_bool (*disconnect_tip)(void *db);
     dogecoin_bool (*has_checkpoint_start)(void *db);
-    void (*set_checkpoint_start)(void *db, uint256 hash, uint32_t height, uint256 chainwork);
+    void (*set_checkpoint_start)(void *db, uint256_t hash, uint32_t height, uint256_t chainwork);
 } dogecoin_headers_db_interface;
 
 LIBDOGECOIN_END_DECL