Implementing bitcoin send logic..what is the problem?

[ghost]

#include "Bitcoin/Address.h"
#include "Bitcoin/OutPoint.h"
#include "Bitcoin/Script.h"
#include "Bitcoin/Transaction.h"
#include "Bitcoin/TransactionBuilder.h"
#include "Bitcoin/TransactionSigner.h"
#include "Bitcoin/SigHashType.h"

#include <TrustWalletCore/TWCoinType.h>
#include <TrustWalletCore/TWAnySigner.h>
#include <TrustWalletCore/TWCoinTypeConfiguration.h>
#include <TrustWalletCore/TWHDWallet.h>
#include <TrustWalletCore/TWPrivateKey.h>
#include <TrustWalletCore/TWPublicKey.h>
#include <TrustWalletCore/TWBitcoinScript.h>
#include <TrustWalletCore/TWString.h>
#include <TrustWalletCore/TWData.h>

#include <gtest/gtest.h>
// #include <google/protobuf/util/json_util.h>

#include
#include

#include "HexCoding.h"
#include "PrivateKey.h"
#include "PublicKey.h"
#include "Coin.h"

#include "uint256.h"

// #include "Ethereum/Transaction.h"
// #include "Ethereum/Signer.h"

#include <boost/lexical_cast.hpp>
#include <boost/multiprecision/cpp_int.hpp>

using namespace std ;

/// Converts a range of bytes to a hexadecimal string representation.
template
inline std::string hex(const Iter begin, const Iter end) {
static constexpr std::array<char, 16> hexmap = {
'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
};

std::string result;
result.reserve((end - begin) * 2);

for (auto it = begin; it < end; ++it) {
    auto val = static_cast<uint8_t>(*it);
    result.push_back(hexmap[val >> 4]);
    result.push_back(hexmap[val & 0x0f]);
}

return result;

}

/// Converts a collection of bytes to a hexadecimal string representation.
template
inline std::string hex(const T& collection) {
return hex(std::begin(collection), std::end(collection));
}

/// same as hex, with 0x prefix
template
inline std::string hexEncoded(const T& collection) {
return hex(std::begin(collection), std::end(collection)).insert(0, "0x");
}

/// Converts a uint64_t value to a hexadecimal string.
inline std::string hex(uint64_t value) {
auto bytes = reinterpret_cast<const uint8_t*>(&value);
return hex(std::reverse_iterator<const uint8_t*>(bytes + sizeof(value)),
std::reverse_iterator<const uint8_t*>(bytes));
}

/// Parses a string of hexadecimal values.
///
/// \returns the array or parsed bytes or an empty array if the string is not
/// valid hexadecimal.
template
inline TW::Data parse_hex(const Iter begin, const Iter end) {
auto it = begin;

// Skip `0x`
if (end - begin >= 2 && *begin == '0' && *(begin + 1) == 'x') {
    it += 2;
}
try {
    std::string temp;
    boost::algorithm::unhex(it, end, std::back_inserter(temp));
    return TW::Data(temp.begin(), temp.end());
} catch (...) {
    return {};
}

}

/// Parses a string of hexadecimal values.
///
/// \returns the array or parsed bytes or an empty array if the string is not
/// valid hexadecimal.
inline TW::Data parse_hex(const std::string& string) {
return parse_hex( string.begin(), string.end() );
}

void privateKeyToResult( TWPrivateKey* priKey, string& res_out)
{
// take the key, but may need to take extension as well
res_out = hex(priKey->impl.bytes);
if (priKey->impl.extensionBytes.size() > 0) {
res_out += hex(priKey->impl.extensionBytes);
res_out += hex(priKey->impl.chainCodeBytes);
}
}

void pubPri(const TWCoinType coinType, const string& PrivateKey, string& PublicKey)
{
TW::Data privDat;
try {
privDat = parse_hex(PrivateKey) ;
auto priv = TW::PrivateKey(privDat) ;
auto pub = priv.getPublicKey((TWPublicKeyType)TW::publicKeyType( coinType ));
PublicKey = hex(pub.bytes);

    // cout << "Public key created, type " << (int)TW::publicKeyType( coinType ) << ", length " << pub.bytes.size() << endl;
    // return true;
} catch (exception& ex) {
    cout << "Error: " << ex.what() << endl;
    // return false; 
}

}

int main() {

////////////////////////////////////////////////////////////////////////////////////////////////
//// Sample
////////////////////////////////////////////////////////////////////////////////////////////////


const auto hash0 = parse_hex("fff7f7881a8099afa6940d42d1e7f6362bec38171ea3edf433541db4e4ad969f");
const auto hash1 = parse_hex("ef51e1b804cc89d182d279655c3aa89e815b1b309fe287d9b2b55d57b90ec68a");


TW::Bitcoin::SigningInput input;
input.hashType = TWBitcoinSigHashTypeAll;
const auto amount = 40000; // 0x06B22C20
input.amount = amount;
input.byteFee = 20; // not relevant
input.toAddress = "bc1qggf044cpt9cgqs7uxrwh46xdzkvunhdx34ngnp";
input.changeAddress = "bc1qggf044cpt9cgqs7uxrwh46xdzkvunhdx34ngnp";

const auto utxoKey0 = TW::PrivateKey(parse_hex("b52f3fe74de22cf5b21ee94f3d0f61a99455c2eae77d6ecdebc5fe94b14db10f"));
const auto pubKey0 = utxoKey0.getPublicKey(TWPublicKeyTypeSECP256k1);
// EXPECT_EQ(hex(pubKey0.bytes), "03c9f4836b9a4f77fc0d81f7bcb01b7f1b35916864b9476c241ce9fc198bd25432");

const auto utxo0Script = TW::Bitcoin::Script::buildPayToPublicKey(pubKey0.bytes);
TW::Data key2;
utxo0Script.matchPayToPublicKey(key2);
// EXPECT_EQ(hex(key2), hex(pubKey0.bytes));
input.privateKeys.push_back(utxoKey0);



const auto utxoKey1 = TW::PrivateKey(parse_hex("b52f3fe74de22cf5b21ee94f3d0f61a99455c2eae77d6ecdebc5fe94b14db10f"));
const auto pubKey1 = utxoKey1.getPublicKey(TWPublicKeyTypeSECP256k1);
// EXPECT_EQ(hex(pubKey1.bytes), "025476c2e83188368da1ff3e292e7acafcdb3566bb0ad253f62fc70f07aeee6357");
const auto utxoPubkeyHash1 = TW::Hash::ripemd(TW::Hash::sha256(pubKey1.bytes));
// EXPECT_EQ(hex(utxoPubkeyHash1), "1d0f172a0ecb48aee1be1f2687d2963ae33f71a1");
input.privateKeys.push_back(utxoKey1);
input.lockTime = 0x11;

TW::Bitcoin::UTXO utxo0;
utxo0.script = utxo0Script;
utxo0.amount = 1000000; // note: this amount is not specified in the test
utxo0.outPoint = TW::Bitcoin::OutPoint(hash0, 0, 0xffffffee);
input.utxos.push_back(utxo0);

TW::Bitcoin::UTXO utxo1;
auto utxo1Script = TW::Bitcoin::Script::buildPayToWitnessProgram(utxoPubkeyHash1);
utxo1.script = utxo1Script;
utxo1.amount = 600000000; // 0x23C34600 0046c323
utxo1.outPoint = TW::Bitcoin::OutPoint(hash1, 1, UINT32_MAX);
input.utxos.push_back(utxo1); 

// Set plan to force both UTXOs and exact output amounts
TW::Bitcoin::TransactionPlan plan;
plan.amount = amount;
plan.availableAmount = 600000000 + 1000000;
plan.fee = 265210000; // very large, the amounts specified (in1, out0, out1) are not consistent/realistic
plan.change = 223450000; // 0x0d519390
plan.branchId = {0};
plan.utxos.push_back(utxo0);
plan.utxos.push_back(utxo1);
input.plan = plan;






TW::Bitcoin::Proto::SigningOutput output;

cout << "#1" << endl;


auto result = TW::Bitcoin::TransactionSigner<TW::Bitcoin::Transaction, TW::Bitcoin::TransactionBuilder>::sign(input);

if (!result) {
    cout << "#1-1" << endl;
    output.set_error(result.error());
} else {
    const auto& tx = result.payload();
    *output.mutable_transaction() = tx.proto();

    TW::Data encoded;
    tx.encode(encoded);
    output.set_encoded(encoded.data(), encoded.size());

    TW::Data txHashData = encoded;
    if (tx.hasWitness()) {
        txHashData.clear();
        tx.encode(txHashData, TW::Bitcoin::Transaction::SegwitFormatMode::NonSegwit);
    }

    auto txHash = TW::Hash::sha256d(txHashData.data(), txHashData.size());
    std::reverse(txHash.begin(), txHash.end());
    output.set_transaction_id(hex(txHash));



    TW::Data serialized;
    tx.encode(serialized);


    cout << "#436 hex(txHash)        : '" <<  hex(txHash)      << "'" << endl;

    cout << "#1 serialized.size()    : '" <<  serialized.size()      << "'" << endl;
    cout << "#1 hex(serialized)      : '" <<  hex(serialized)      << "'" << endl;

    cout << "#1 encoded.size()       : '" <<  encoded.size()      << "'" << endl;
    cout << "#1 hex(encoded)         : '" <<  hex(encoded)      << "'" << endl;

    cout << "#1 txHashData.size()    : '" <<  txHashData.size()      << "'" << endl;
    cout << "#1 hex(txHashData)      : '" <<  hex(txHashData)      << "'" << endl;

    cout << "#1 txHash.size()        : '" <<  txHash.size()      << "'" << endl;
    cout << "#1 hex(txHash)          : '" <<  hex(txHash)      << "'" << endl;


}

}