tx.c File Reference

#include <stdint.h>
#include <stddef.h>
#include <string.h>
#include "btc/base58.h"
#include "btc/tx.h"
#include "serialize.h"
#include "sha2.h"
#include "utils.h"

Go to the source code of this file.

Functions
void	btc_tx_in_free (btc_tx_in *tx_in)
void	btc_tx_in_free_cb (void *data)
btc_tx_in *	btc_tx_in_new ()
	create a new tx input More...
void	btc_tx_out_free (btc_tx_out *tx_out)
void	btc_tx_out_free_cb (void *data)
btc_tx_out *	btc_tx_out_new ()
	create a new tx output More...
void	btc_tx_free (btc_tx *tx)
btc_tx *	btc_tx_new ()
	create a new tx input More...
btc_bool	btc_tx_in_deserialize (btc_tx_in *tx_in, struct const_buffer *buf)
btc_bool	btc_tx_out_deserialize (btc_tx_out *tx_out, struct const_buffer *buf)
int	btc_tx_deserialize (const unsigned char *tx_serialized, size_t inlen, btc_tx *tx)
	deserialize/parse a p2p serialized bitcoin transaction More...
void	btc_tx_in_serialize (cstring *s, const btc_tx_in *tx_in)
void	btc_tx_out_serialize (cstring *s, const btc_tx_out *tx_out)
void	btc_tx_serialize (cstring *s, const btc_tx *tx)
	serialize a lbc bitcoin data structure into a p2p serialized buffer More...
void	btc_tx_hash (const btc_tx *tx, uint8_t *hashout)
void	btc_tx_in_copy (btc_tx_in *dest, const btc_tx_in *src)
void	btc_tx_out_copy (btc_tx_out *dest, const btc_tx_out *src)
void	btc_tx_copy (btc_tx *dest, const btc_tx *src)
btc_bool	btc_tx_sighash (const btc_tx *tx_to, const cstring *fromPubKey, unsigned int in_num, int hashtype, uint8_t *hash)
btc_bool	btc_tx_add_address_out (btc_tx *tx, const btc_chain *chain, int64_t amount, const char *address)
btc_bool	btc_tx_add_p2pkh_hash160_out (btc_tx *tx, int64_t amount, uint8_t *hash160)
btc_bool	btc_tx_add_p2sh_hash160_out (btc_tx *tx, int64_t amount, uint8_t *hash160)
btc_bool	btc_tx_add_p2pkh_out (btc_tx *tx, int64_t amount, const btc_pubkey *pubkey)

Function Documentation

btc_bool btc_tx_add_address_out	(	btc_tx *	tx,
		const btc_chain *	chain,
		int64_t	amount,
		const char *	address
	)

Definition at line 426 of file tx.c.

References btc_chain::b58prefix_pubkey_address, btc_chain::b58prefix_script_address, btc_base58_decode_check(), btc_tx_add_p2pkh_hash160_out(), and btc_tx_add_p2sh_hash160_out().

{

    uint8_t buf[strlen(address)*2];
    int r = btc_base58_decode_check(address, buf, sizeof(buf));
    if (r <= 0)
        return false;

    if (buf[0] == chain->b58prefix_pubkey_address)
    {
        btc_tx_add_p2pkh_hash160_out(tx, amount, &buf[1]);
    }
    else if (buf[0] == chain->b58prefix_script_address)
    {
        btc_tx_add_p2sh_hash160_out(tx, amount, &buf[1]);
    }

    return true;
}

btc_bool btc_tx_add_p2pkh_hash160_out	(	btc_tx *	tx,
		int64_t	amount,
		uint8_t *	hash160
	)

Definition at line 447 of file tx.c.

References btc_script_build_p2pkh(), btc_tx_out_new(), cstr_new_sz(), btc_tx_out_::script_pubkey, btc_tx_out_::value, vector_add(), and btc_tx_::vout.

Referenced by btc_tx_add_address_out(), and btc_tx_add_p2pkh_out().

{
    btc_tx_out* tx_out = btc_tx_out_new();

    tx_out->script_pubkey = cstr_new_sz(1024);
    btc_script_build_p2pkh(tx_out->script_pubkey, hash160);

    tx_out->value = amount;

    vector_add(tx->vout, tx_out);

    return true;
}

btc_bool btc_tx_add_p2pkh_out	(	btc_tx *	tx,
		int64_t	amount,
		const btc_pubkey *	pubkey
	)

Definition at line 475 of file tx.c.

References btc_pubkey_get_hash160(), and btc_tx_add_p2pkh_hash160_out().

{

    uint8_t hash160[20];
    btc_pubkey_get_hash160(pubkey, hash160);
    return btc_tx_add_p2pkh_hash160_out(tx, amount, hash160);
}

btc_bool btc_tx_add_p2sh_hash160_out	(	btc_tx *	tx,
		int64_t	amount,
		uint8_t *	hash160
	)

Definition at line 461 of file tx.c.

References btc_script_build_p2sh(), btc_tx_out_new(), cstr_new_sz(), btc_tx_out_::script_pubkey, btc_tx_out_::value, vector_add(), and btc_tx_::vout.

Referenced by btc_tx_add_address_out().

{
    btc_tx_out* tx_out = btc_tx_out_new();

    tx_out->script_pubkey = cstr_new_sz(1024);
    btc_script_build_p2sh(tx_out->script_pubkey, hash160);

    tx_out->value = amount;

    vector_add(tx->vout, tx_out);

    return true;
}

void btc_tx_copy	(	btc_tx *	dest,
		const btc_tx *	src
	)

Definition at line 283 of file tx.c.

References btc_tx_in_copy(), btc_tx_in_free_cb(), btc_tx_out_copy(), btc_tx_out_free_cb(), vector::len, btc_tx_::locktime, vector_add(), vector_free(), vector_idx, vector_new(), btc_tx_::version, btc_tx_::vin, and btc_tx_::vout.

Referenced by btc_tx_sighash().

{
    dest->version = src->version;
    dest->locktime = src->locktime;

    if (!src->vin)
        dest->vin = NULL;
    else {
        unsigned int i;

        if (dest->vin)
            vector_free(dest->vin, true);

        dest->vin = vector_new(src->vin->len, btc_tx_in_free_cb);

        for (i = 0; i < src->vin->len; i++) {
            btc_tx_in* tx_in_old, *tx_in_new;

            tx_in_old = vector_idx(src->vin, i);
            tx_in_new = malloc(sizeof(*tx_in_new));
            btc_tx_in_copy(tx_in_new, tx_in_old);
            vector_add(dest->vin, tx_in_new);
        }
    }

    if (!src->vout)
        dest->vout = NULL;
    else {
        unsigned int i;

        if (dest->vout)
            vector_free(dest->vout, true);

        dest->vout = vector_new(src->vout->len,
                                btc_tx_out_free_cb);

        for (i = 0; i < src->vout->len; i++) {
            btc_tx_out* tx_out_old, *tx_out_new;

            tx_out_old = vector_idx(src->vout, i);
            tx_out_new = malloc(sizeof(*tx_out_new));
            btc_tx_out_copy(tx_out_new, tx_out_old);
            vector_add(dest->vout, tx_out_new);
        }
    }
}

int btc_tx_deserialize	(	const unsigned char *	tx_serialized,
		size_t	inlen,
		btc_tx *	tx
	)

deserialize/parse a p2p serialized bitcoin transaction

Definition at line 157 of file tx.c.

References btc_tx_in_deserialize(), btc_tx_in_new(), btc_tx_out_deserialize(), btc_tx_out_new(), deser_u32(), deser_varlen(), btc_tx_::locktime, vector_add(), btc_tx_::version, btc_tx_::vin, and btc_tx_::vout.

{
    struct const_buffer buf = {tx_serialized, inlen};

    //tx needs to be initialized
    deser_u32(&tx->version, &buf);
    uint32_t vlen;
    if (!deser_varlen(&vlen, &buf))
        return false;

    unsigned int i;
    for (i = 0; i < vlen; i++) {
        btc_tx_in* tx_in = btc_tx_in_new();

        if (!btc_tx_in_deserialize(tx_in, &buf)) {
            free(tx_in);
        }

        vector_add(tx->vin, tx_in);
    }

    if (!deser_varlen(&vlen, &buf))
        return false;
    for (i = 0; i < vlen; i++) {
        btc_tx_out* tx_out = btc_tx_out_new();

        if (!btc_tx_out_deserialize(tx_out, &buf)) {
            free(tx_out);
        }

        vector_add(tx->vout, tx_out);
    }

    if (!deser_u32(&tx->locktime, &buf))
        return false;

    return true;
}

void btc_tx_free

(

btc_tx *

tx

)

Definition at line 112 of file tx.c.

References vector_free(), btc_tx_::vin, and btc_tx_::vout.

Referenced by btc_tx_sighash().

{
    if (tx->vin)
        vector_free(tx->vin, true);

    if (tx->vout)
        vector_free(tx->vout, true);

    free(tx);
}

void btc_tx_hash	(	const btc_tx *	tx,
		uint8_t *	hashout
	)

Definition at line 240 of file tx.c.

References btc_tx_serialize(), cstr_free(), cstr_new_sz(), cstring::len, sha256_Raw(), and cstring::str.

{
    cstring *txser = cstr_new_sz(1024);
    btc_tx_serialize(txser, tx);


    sha256_Raw((const uint8_t*)txser->str, txser->len, hashout);
    sha256_Raw(hashout, 32, hashout);
    cstr_free(txser, true);
}

void btc_tx_in_copy	(	btc_tx_in *	dest,
		const btc_tx_in *	src
	)

Definition at line 252 of file tx.c.

References cstr_append_buf(), cstr_new_sz(), cstring::len, btc_tx_in_::prevout, btc_tx_in_::script_sig, btc_tx_in_::sequence, and cstring::str.

Referenced by btc_tx_copy().

{
    memcpy(&dest->prevout, &src->prevout, sizeof(dest->prevout));
    dest->sequence = src->sequence;

    if (!src->script_sig)
        dest->script_sig = NULL;
    else {
        dest->script_sig = cstr_new_sz(src->script_sig->len);
        cstr_append_buf(dest->script_sig,
                        src->script_sig->str,
                        src->script_sig->len);
    }
}

btc_bool btc_tx_in_deserialize	(	btc_tx_in *	tx_in,
		struct const_buffer *	buf
	)

Definition at line 136 of file tx.c.

References deser_u256(), deser_u32(), deser_varstr(), btc_tx_outpoint_::hash, btc_tx_outpoint_::n, btc_tx_in_::prevout, btc_tx_in_::script_sig, and btc_tx_in_::sequence.

Referenced by btc_tx_deserialize().

{
    deser_u256(tx_in->prevout.hash, buf);
    if (!deser_u32(&tx_in->prevout.n, buf))
        return false;
    if (!deser_varstr(&tx_in->script_sig, buf))
        return false;
    if (!deser_u32(&tx_in->sequence, buf))
        return false;
    return true;
}

void btc_tx_in_free

(

btc_tx_in *

tx_in

)

Definition at line 39 of file tx.c.

References cstr_free(), btc_tx_outpoint_::hash, btc_tx_outpoint_::n, btc_tx_in_::prevout, and btc_tx_in_::script_sig.

Referenced by btc_tx_in_free_cb().

{
    if (!tx_in)
        return;

    memset(&tx_in->prevout.hash, 0, 32);
    tx_in->prevout.n = 0;

    if (tx_in->script_sig) {
        cstr_free(tx_in->script_sig, true);
        tx_in->script_sig = NULL;
    }
}

void btc_tx_in_free_cb

(

void *

data

)

Definition at line 54 of file tx.c.

References btc_tx_in_free().

Referenced by btc_tx_copy(), and btc_tx_new().

{
    if (!data)
        return;

    btc_tx_in* tx_in = data;
    btc_tx_in_free(tx_in);

    memset(tx_in, 0, sizeof(*tx_in));
    free(tx_in);
}

btc_tx_in* btc_tx_in_new

(

)

create a new tx input

Definition at line 67 of file tx.c.

References btc_tx_in_::prevout, and btc_tx_in_::sequence.

Referenced by btc_tx_deserialize().

{
    btc_tx_in* tx_in;
    tx_in = calloc(1, sizeof(*tx_in));
    memset(&tx_in->prevout, 0, sizeof(tx_in->prevout));
    tx_in->sequence = UINT32_MAX;
    return tx_in;
}

void btc_tx_in_serialize	(	cstring *	s,
		const btc_tx_in *	tx_in
	)

Definition at line 196 of file tx.c.

References btc_tx_outpoint_::hash, btc_tx_outpoint_::n, btc_tx_in_::prevout, btc_tx_in_::script_sig, btc_tx_in_::sequence, ser_u256(), ser_u32(), and ser_varstr().

Referenced by btc_tx_serialize().

{
    ser_u256(s, tx_in->prevout.hash);
    ser_u32(s, tx_in->prevout.n);
    ser_varstr(s, tx_in->script_sig);
    ser_u32(s, tx_in->sequence);
}

btc_tx* btc_tx_new

(

)

create a new tx input

Definition at line 124 of file tx.c.

References btc_tx_in_free_cb(), btc_tx_out_free_cb(), btc_tx_::locktime, vector_new(), btc_tx_::version, btc_tx_::vin, and btc_tx_::vout.

Referenced by btc_tx_sighash().

{
    btc_tx* tx;
    tx = calloc(1, sizeof(*tx));
    tx->vin = vector_new(8, btc_tx_in_free_cb);
    tx->vout = vector_new(8, btc_tx_out_free_cb);
    tx->version = 1;
    tx->locktime = 0;
    return tx;
}

void btc_tx_out_copy	(	btc_tx_out *	dest,
		const btc_tx_out *	src
	)

Definition at line 268 of file tx.c.

References cstr_append_buf(), cstr_new_sz(), cstring::len, btc_tx_out_::script_pubkey, cstring::str, and btc_tx_out_::value.

Referenced by btc_tx_copy().

{
    dest->value = src->value;

    if (!src->script_pubkey)
        dest->script_pubkey = NULL;
    else {
        dest->script_pubkey = cstr_new_sz(src->script_pubkey->len);
        cstr_append_buf(dest->script_pubkey,
                        src->script_pubkey->str,
                        src->script_pubkey->len);
    }
}

btc_bool btc_tx_out_deserialize	(	btc_tx_out *	tx_out,
		struct const_buffer *	buf
	)

Definition at line 148 of file tx.c.

References deser_s64(), deser_varstr(), btc_tx_out_::script_pubkey, and btc_tx_out_::value.

Referenced by btc_tx_deserialize().

{
    if (!deser_s64(&tx_out->value, buf))
        return false;
    if (!deser_varstr(&tx_out->script_pubkey, buf))
        return false;
    return true;
}

void btc_tx_out_free

(

btc_tx_out *

tx_out

)

Definition at line 77 of file tx.c.

References cstr_free(), btc_tx_out_::script_pubkey, and btc_tx_out_::value.

Referenced by btc_tx_out_free_cb().

{
    if (!tx_out)
        return;
    tx_out->value = 0;

    if (tx_out->script_pubkey) {
        cstr_free(tx_out->script_pubkey, true);
        tx_out->script_pubkey = NULL;
    }
}

void btc_tx_out_free_cb

(

void *

data

)

Definition at line 90 of file tx.c.

References btc_tx_out_free().

Referenced by btc_tx_copy(), btc_tx_new(), and btc_tx_sighash().

{
    if (!data)
        return;

    btc_tx_out* tx_out = data;
    btc_tx_out_free(tx_out);

    memset(tx_out, 0, sizeof(*tx_out));
    free(tx_out);
}

btc_tx_out* btc_tx_out_new

(

)

create a new tx output

Definition at line 103 of file tx.c.

Referenced by btc_tx_add_p2pkh_hash160_out(), btc_tx_add_p2sh_hash160_out(), and btc_tx_deserialize().

{
    btc_tx_out* tx_out;
    tx_out = calloc(1, sizeof(*tx_out));

    return tx_out;
}

void btc_tx_out_serialize	(	cstring *	s,
		const btc_tx_out *	tx_out
	)

Definition at line 204 of file tx.c.

References btc_tx_out_::script_pubkey, ser_s64(), ser_varstr(), and btc_tx_out_::value.

Referenced by btc_tx_serialize().

{
    ser_s64(s, tx_out->value);
    ser_varstr(s, tx_out->script_pubkey);
}

void btc_tx_serialize	(	cstring *	s,
		const btc_tx *	tx
	)

serialize a lbc bitcoin data structure into a p2p serialized buffer

Definition at line 210 of file tx.c.

References btc_tx_in_serialize(), btc_tx_out_serialize(), vector::len, btc_tx_::locktime, ser_u32(), ser_varlen(), vector_idx, btc_tx_::version, btc_tx_::vin, and btc_tx_::vout.

Referenced by btc_tx_hash(), and btc_tx_sighash().

{
    ser_u32(s, tx->version);

    ser_varlen(s, tx->vin ? tx->vin->len : 0);

    unsigned int i;
    if (tx->vin) {
        for (i = 0; i < tx->vin->len; i++) {
            btc_tx_in* tx_in;

            tx_in = vector_idx(tx->vin, i);
            btc_tx_in_serialize(s, tx_in);
        }
    }

    ser_varlen(s, tx->vout ? tx->vout->len : 0);

    if (tx->vout) {
        for (i = 0; i < tx->vout->len; i++) {
            btc_tx_out* tx_out;

            tx_out = vector_idx(tx->vout, i);
            btc_tx_out_serialize(s, tx_out);
        }
    }

    ser_u32(s, tx->locktime);
}

btc_bool btc_tx_sighash	(	const btc_tx *	tx_to,
		const cstring *	fromPubKey,
		unsigned int	in_num,
		int	hashtype,
		uint8_t *	hash
	)

Definition at line 330 of file tx.c.

References btc_script_copy_without_op_codeseperator(), btc_tx_copy(), btc_tx_free(), btc_tx_new(), btc_tx_out_free_cb(), btc_tx_serialize(), cstr_append_buf(), cstr_free(), cstr_new_sz(), cstr_resize(), vector::len, cstring::len, btc_tx_out_::script_pubkey, btc_tx_in_::script_sig, btc_tx_in_::sequence, ser_s32(), sha256_Raw(), SIGHASH_ANYONECANPAY, SIGHASH_NONE, SIGHASH_SINGLE, cstring::str, btc_tx_out_::value, vector_free(), vector_idx, vector_new(), vector_remove_range(), vector_resize(), btc_tx_::vin, and btc_tx_::vout.

{
    if (in_num >= tx_to->vin->len)
        return false;

    btc_bool ret = true;

    btc_tx* tx_tmp = btc_tx_new();
    btc_tx_copy(tx_tmp, tx_to);

    cstring* new_script = cstr_new_sz(fromPubKey->len);
    btc_script_copy_without_op_codeseperator(fromPubKey, new_script);

    unsigned int i;
    btc_tx_in* tx_in;
    for (i = 0; i < tx_tmp->vin->len; i++) {
        tx_in = vector_idx(tx_tmp->vin, i);
        cstr_resize(tx_in->script_sig, 0);

        if (i == in_num)
            cstr_append_buf(tx_in->script_sig,
                            new_script->str,
                            new_script->len);
    }
    cstr_free(new_script, true);
    /* Blank out some of the outputs */
    if ((hashtype & 0x1f) == SIGHASH_NONE) {
        /* Wildcard payee */
        if (tx_tmp->vout)
            vector_free(tx_tmp->vout, true);

        tx_tmp->vout = vector_new(1, btc_tx_out_free_cb);

        /* Let the others update at will */
        for (i = 0; i < tx_tmp->vin->len; i++) {
            tx_in = vector_idx(tx_tmp->vin, i);
            if (i != in_num)
                tx_in->sequence = 0;
        }
    }

    else if ((hashtype & 0x1f) == SIGHASH_SINGLE) {
        /* Only lock-in the txout payee at same index as txin */
        unsigned int n_out = in_num;
        if (n_out >= tx_tmp->vout->len) {
            //TODO: set error code
            ret = false;
            goto out;
        }

        vector_resize(tx_tmp->vout, n_out + 1);

        for (i = 0; i < n_out; i++) {
            btc_tx_out* tx_out;

            tx_out = vector_idx(tx_tmp->vout, i);
            tx_out->value = -1;
            if (tx_out->script_pubkey) {
                cstr_free(tx_out->script_pubkey, true);
                tx_out->script_pubkey = NULL;
            }
        }

        /* Let the others update at will */
        for (i = 0; i < tx_tmp->vin->len; i++) {
            tx_in = vector_idx(tx_tmp->vin, i);
            if (i != in_num)
                tx_in->sequence = 0;
        }
    }

    /* Blank out other inputs completely;
     not recommended for open transactions */
    if (hashtype & SIGHASH_ANYONECANPAY) {
        if (in_num > 0)
            vector_remove_range(tx_tmp->vin, 0, in_num);
        vector_resize(tx_tmp->vin, 1);
    }

    cstring* s = cstr_new_sz(512);
    btc_tx_serialize(s, tx_tmp);
    char hextest[4096];
    ser_s32(s, hashtype);

    sha256_Raw((const uint8_t*)s->str, s->len, hash);
    sha256_Raw(hash, 32, hash);

    cstr_free(s, true);

out:
    btc_tx_free(tx_tmp);

    return ret;
}