Topic: Need help understanding a transaction (Read 1520 times)

struct BitcoinAddress
{
  uint32_t key[25]; // the 25 bitcoin public key address
};

uint32_t findOutputAddresses(const uint8_t *scriptData,	// The raw output script data
			uint32_t scriptLength,		// The length of the output script.
			BitcoinAddress *keys,		// The array of keys to return				
			uint32_t maxOutputKeys);	// The maximum number of output keys allowed 

4d 65 73 73 61 67 65 3a 20 68 74 74 70 3a 2f 2f 
69 2e 69 6d 67 75 72 2e 63 6f 6d 2f 73 5a 38 64 
30 2e 6a 70 67

4d 65 73 73 61 67 65 3a 20 42 69 74 63 6f 69 6e 
50 61 72 61 2e 64 65 20 44 69 76 69 64 65 6e 64 
65 6e 7a 61 68 6c 75 6e 67 20 31 20 76 6f 6d 20 
30 37 2e 30 39 2e 32 30 31 32

bool bitcoinPublicKeyToAddress(const uint8_t input[65], // The ECDSA public key; first byte will indicate if the public key is compressed or not
									     uint8_t output[25])		// A bitcoin address (in binary is always 25 bytes long).
{
	bool ret = false;
	uint8_t hash1[32]; // holds the intermediate SHA256 hash computations

	if ( input[0] == 0x04 ) // Uncompressed public key. First byte is 0x04 followed by two 32 byte components
	{
		SHA256::computeSHA256(input,65,hash1);	// Compute the SHA256 hash of the input public ECSDA signature
	}
	else if ( input[0] == 0x02 || input[0] == 0x03 ) //Compressed public key. First byte is 0x02 or 0x03 followed by the 32 byte component
	{
		SHA256::computeSHA256(input,33,hash1);	// Compute the SHA256 hash of the input public ECSDA signature
	}

	if ( input[0] == 0x02 || input[0] == 0x03 || input[0] == 0x04 )
	{
		output[0] = 0;	// Store a network byte of 0 (i.e. 'main' network)
		RIPEMD160::computeRIPEMD160(hash1,32,&output[1]);	// Compute the RIPEMD160 (20 byte) hash of the SHA256 hash
		SHA256::computeSHA256(output,21,hash1);	// Compute the SHA256 hash of the RIPEMD16 hash + the one byte header (for a checksum)
		SHA256::computeSHA256(hash1,32,hash1); // now compute the SHA256 hash of the previously computed SHA256 hash (for a checksum)
		output[21] = hash1[0];	// Store the checksum in the last 4 bytes of the public key hash
		output[22] = hash1[1];
		output[23] = hash1[2];
		output[24] = hash1[3];
		ret = true;
	}
	return ret;
}

bool bitcoinCompressedPublicKeyToAddress(const uint8_t input[32], // The 33 byte long compressed ECDSA public key; first byte will always be 0x2 or 0x3 followed by the 32 byte component
									     uint8_t output[25])		// A bitcoin address (in binary( is always 25 bytes long.
{
	bool ret = false;

	if ( input[0] == 0x02 || input[0] == 0x03 )
	{
		uint8_t hash1[32]; // holds the intermediate SHA256 hash computations
		SHA256::computeSHA256(input,33,hash1);	// Compute the SHA256 hash of the input public ECSDA signature
		output[0] = 0;	// Store a network byte of 0 (i.e. 'main' network)
		RIPEMD160::computeRIPEMD160(hash1,32,&output[1]);	// Compute the RIPEMD160 (20 byte) hash of the SHA256 hash
		SHA256::computeSHA256(output,21,hash1);	// Compute the SHA256 hash of the RIPEMD16 hash + the one byte header (for a checksum)
		SHA256::computeSHA256(hash1,32,hash1); // now compute the SHA256 hash of the previously computed SHA256 hash (for a checksum)
		output[21] = hash1[0];	// Store the checksum in the last 4 bytes of the public key hash
		output[22] = hash1[1];
		output[23] = hash1[2];
		output[24] = hash1[3];
		ret = true;
	}
	return ret;
}

bool bitcoinCompressedPublicKeyToAddress(const uint8_t input[33], // The 33 bytes long ECDSA public key; first byte will always be either 0x02 or 0x03 followed by a 32 byte components
							   uint8_t output[25])		// A bitcoin address (in binary is always 25 bytes long).
{
	bool ret = false;

	if ( ( input[0] == 0x02 ) || ( ( input[0] == 0x03 ) )
	{
		uint8_t hash1[32]; // holds the intermediate SHA256 hash computations
		SHA256::computeSHA256(input,33,hash1);	// Compute the SHA256 hash of the input public ECSDA signature
		output[0] = 0;	// Store a network byte of 0 (i.e. 'main' network)
		RIPEMD160::computeRIPEMD160(hash1,32,&output[1]);	// Compute the RIPEMD160 (20 byte) hash of the SHA256 hash
		SHA256::computeSHA256(output,21,hash1);	// Compute the SHA256 hash of the RIPEMD16 hash + the one byte header (for a checksum)
		SHA256::computeSHA256(hash1,32,hash1); // now compute the SHA256 hash of the previously computed SHA256 hash (for a checksum)
		output[21] = hash1[0];	// Store the checksum in the last 4 bytes of the public key hash
		output[22] = hash1[1];
		output[23] = hash1[2];
		output[24] = hash1[3];
		ret = true;
	}
	return ret;
}

bool bitcoinPublicKeyToAddress(const uint8_t input[65], // The 65 bytes long ECDSA public key; first byte will always be 0x4 followed by two 32 byte components
							   uint8_t output[25])		// A bitcoin address (in binary( is always 25 bytes long.
{
	bool ret = false;

	if ( input[0] == 0x04)
	{
		uint8_t hash1[32]; // holds the intermediate SHA256 hash computations
		SHA256::computeSHA256(input,65,hash1);	// Compute the SHA256 hash of the input public ECSDA signature
		output[0] = 0;	// Store a network byte of 0 (i.e. 'main' network)
		RIPEMD160::computeRIPEMD160(hash1,32,&output[1]);	// Compute the RIPEMD160 (20 byte) hash of the SHA256 hash
		SHA256::computeSHA256(output,21,hash1);	// Compute the SHA256 hash of the RIPEMD16 hash + the one byte header (for a checksum)
		SHA256::computeSHA256(hash1,32,hash1); // now compute the SHA256 hash of the previously computed SHA256 hash (for a checksum)
		output[21] = hash1[0];	// Store the checksum in the last 4 bytes of the public key hash
		output[22] = hash1[1];
		output[23] = hash1[2];
		output[24] = hash1[3];
		ret = true;
	}
	return ret;
}

A579A1CEDA2894FDDB360E9D2941907835A290C72BFEC0443E1EFF64AAA61EAA

8B1D6A31B019E2DA16DE77F60C623B1442D5EC2E

008B1D6A31B019E2DA16DE77F60C623B1442D5EC2E

F83469929812FE7835C4650BBC6E32DB092B545F0D546B597C8BFBA0C7C26BD8

243A00619F100F1A1D84D418198875C023F45290574D5BAC64FEA8B7897B1852

243A0061

008B1D6A31B019E2DA16DE77F60C623B1442D5EC2E243A0061

1DgaASdtGgUavpNUE8ESBq3gmPbHh2ALnC