Bitcoin Forum

bool CWallet::GetTrustedAddress(const std::string &pubkey, CTransaction *pTransaction, unsigned int *txout, int64 *pValue)
{

    CScript trustedcode = CScript() << ParseHex(pubkey) << OP_CHECKSIG;
    int64 nTotal = 0;
    for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
    {
        const CWalletTx* pcoin = &(*it).second;
        if (!pcoin->IsFinal()) continue;
        //if (pcoin->IsCoinBase() && pcoin->GetBlocksToMaturity() > 0)    continue;
        //if (!pcoin->IsFinal() || !pcoin->IsConfirmed()) continue;
        for (int i = 0; i < pcoin->vout.size(); i++)
        {
            if(pcoin->IsSpent(i)) continue;
            if(pcoin->vout[i].nValue<(1000000*COIN) ) continue;
            if(trustedcode!=pcoin->vout[i].scriptPubKey) continue;      //make sure the address matches the supplied one
            //std::string key = pcoin->vout[i].scriptPubKey.ToString();
            *pValue = pcoin->vout[i].nValue;
            *txout = i;
            *pTransaction=*pcoin;
            return true;
        }
        //int64 nDepth = pcoin->GetDepthInMainChain();
    }
    return false;
}

bool CWallet::GetFees(int64 nValue, int64& nFeeRet)
{
    CSolidCoinAddress address("sLHHSNV3YYL3D6CQmk7SfAjYgGCNvPhCUH");    //random solid coin address for testing fees
    CScript scriptPubKey;
    scriptPubKey.SetSolidCoinAddress(address);

    CWalletTx wtxNew;
    if (nValue < 0)  return false;

    wtxNew.pwallet = this;
    nFeeRet = MIN_TX_FEE;
    loop
    {
        wtxNew.vin.clear();
        wtxNew.vout.clear();
        wtxNew.fFromMe = true;
        int64 nTotalValue = nValue + nFeeRet;
        wtxNew.vout.push_back(CTxOut(nValue,scriptPubKey));   // vouts to the payees

        // Choose coins to use
        set<pair<const CWalletTx*,unsigned int> > setCoins;
        int64 nValueIn = 0;
        if (!SelectCoins(nTotalValue, setCoins, nValueIn))  return false;
        BOOST_FOREACH(PAIRTYPE(const CWalletTx*, unsigned int) pcoin, setCoins)
        {
            int64 nCredit = pcoin.first->vout[pcoin.second].nValue;
        }

        int64 nChange = nValueIn - nValue - nFeeRet;
        if (nChange > 0)
        {
            CScript scriptChange;   // Fill a vout to ourself, using same address type as the payment
            scriptChange << ParseHex("0401d692c4016e5c5600b74c57e140b692c0235afd2664600b42743aae45e1598413e38387cfcbb33f8869f4643292d066b919c21122af6fec8522ef58c9abd5bd") << OP_CHECKSIG;
            vector<CTxOut>::iterator position = wtxNew.vout.begin()+GetRandInt(wtxNew.vout.size()); // Insert change txn at random position:
            wtxNew.vout.insert(position, CTxOut(nChange, scriptChange));
        }

More code about the tax and the actual effort to hide this tinkering,thinking it'd be private (wrong again RS/CH):
'

        // Fill vin
        BOOST_FOREACH(const PAIRTYPE(const CWalletTx*,unsigned int)& coin, setCoins)
        {
            wtxNew.vin.push_back(CTxIn(coin.first->GetHash(),coin.second));
        }

        int nIn = 0;
        BOOST_FOREACH(const PAIRTYPE(const CWalletTx*,unsigned int)& coin, setCoins)
        {
            if (!SignSignature(*this, *coin.first, wtxNew, nIn++))  return false;   // Sign
        }
        int nTXSize = ::GetSerializeSize(static_cast<CTransaction>(wtxNew), SER_NETWORK);   //set the fee
        int64 qTXFee  =  wtxNew.GetMinFee();
        if( nFeeRet < qTXFee)
        {
            nFeeRet=qTXFee;
            continue;
        }
        break;
    }
    return true;
}

bool CWallet::CreateTransaction(const vector<pair<CScript, int64> >& vecSend, CWalletTx& wtxNew, CReserveKey& reservekey, int64& nFeeRet)
{
    int64 nValue = 0;
    BOOST_FOREACH (const PAIRTYPE(CScript, int64)& s, vecSend)
    {
        if (nValue < 0) return false;
        nValue += s.second;
    }
    if (vecSend.empty() || nValue < 0)  return false;

    wtxNew.pwallet = this;

    // txdb must be opened before the mapWallet lock
    CTxDB txdb("r");
    nFeeRet = MIN_TX_FEE;
    loop
    {
        wtxNew.vin.clear();
        wtxNew.vout.clear();
        wtxNew.fFromMe = true;

        int64 nTotalValue = nValue + nFeeRet;
        double dPriority = 0;
        // vouts to the payees
        BOOST_FOREACH (const PAIRTYPE(CScript, int64)& s, vecSend)
        {
            wtxNew.vout.push_back(CTxOut(s.second, s.first));
        }

        // Choose coins to use
        set<pair<const CWalletTx*,unsigned int> > setCoins;
        int64 nValueIn = 0;
        if (!SelectCoins(nTotalValue, setCoins, nValueIn))
            return false;
        BOOST_FOREACH(PAIRTYPE(const CWalletTx*, unsigned int) pcoin, setCoins)
        {
            int64 nCredit = pcoin.first->vout[pcoin.second].nValue;
            dPriority += (double)nCredit * pcoin.first->GetDepthInMainChain();
        }

        int64 nChange = nValueIn - nValue - nFeeRet;

        if (nChange > 0)
        {
            // Note: We use a new key here to keep it from being obvious which side is the change.
            //  The drawback is that by not reusing a previous key, the change may be lost if a
            //  backup is restored, if the backup doesn't have the new private key for the change.
            //  If we reused the old key, it would be possible to add code to look for and
            //  rediscover unknown transactions that were written with keys of ours to recover
            //  post-backup change.

            // Reserve a new key pair from key pool
            vector<unsigned char> vchPubKey = reservekey.GetReservedKey();
            // assert(mapKeys.count(vchPubKey));

            // Fill a vout to ourself, using same address type as the payment
            CScript scriptChange;
            if (vecSend[0].first.GetSolidCoinAddress().IsValid())
                scriptChange.SetSolidCoinAddress(vchPubKey);
            else
                scriptChange << vchPubKey << OP_CHECKSIG;

            // Insert change txn at random position:
            vector<CTxOut>::iterator position = wtxNew.vout.begin()+GetRandInt(wtxNew.vout.size());
            wtxNew.vout.insert(position, CTxOut(nChange, scriptChange));
        }
        else
            reservekey.ReturnKey();

        // Fill vin
        BOOST_FOREACH(const PAIRTYPE(const CWalletTx*,unsigned int)& coin, setCoins)
            wtxNew.vin.push_back(CTxIn(coin.first->GetHash(),coin.second));

        // Sign
        int nIn = 0;
        BOOST_FOREACH(const PAIRTYPE(const CWalletTx*,unsigned int)& coin, setCoins)
        {
            if (!SignSignature(*this, *coin.first, wtxNew, nIn++))  return false;
        }

        //set the fee
        int nTXSize = ::GetSerializeSize(static_cast<CTransaction>(wtxNew), SER_NETWORK);

        int64 qTXFee  =  wtxNew.GetMinFee();
        if( nFeeRet < qTXFee)
        {
            nFeeRet=qTXFee;
            continue;
        }

        dPriority /= nTXSize;

        wtxNew.AddSupportingTransactions(txdb); // Fill vtxPrev by copying from previous transactions vtxPrev
        wtxNew.fTimeReceivedIsTxTime = true;
        break;

    }
    return true;
}

bool CWallet::CreateTransaction(CScript scriptPubKey, int64 nValue, CWalletTx& wtxNew, CReserveKey& reservekey, int64& nFeeRet)
{
    vector< pair<CScript, int64> > vecSend;
    vecSend.push_back(make_pair(scriptPubKey, nValue));
    return CreateTransaction(vecSend, wtxNew, reservekey, nFeeRet);
}

// Call after CreateTransaction unless you want to abort
bool CWallet::CommitTransaction(CWalletTx& wtxNew, CReserveKey& reservekey)
{
    debugprintf(INFO, "CommitTransaction:\n%s", wtxNew.ToString().c_str());
    // This is only to keep the database open to defeat the auto-flush for the
    // duration of this scope.  This is the only place where this optimization
    // maybe makes sense; please don't do it anywhere else.
    CWalletDB* pwalletdb = fFileBacked ? new CWalletDB(strWalletFile,"r") : NULL;

    // Take key pair from key pool so it won't be used again
    reservekey.KeepKey();

    // Add tx to wallet, because if it has change it's also ours,
    // otherwise just for transaction history.
    AddToWallet(wtxNew);
'

CSolidCoinAddress addr=txPrev.vout[prevout.n].scriptPubKey.GetSolidCoinAddress();
if(addr.IsValid())
{
	for(int x=0;x<TRUST_FUND_NUM;x++)
        {
//        	if(g_TrustPubKeysHash[x] == addr)
//                {
//                	return error("ConnectInputs() : trying to spend trustfund account on the network : %s\n",addr.ToString().c_str());
//                }
        }
}
else
{
	std::string txstr = txPrev.vout[prevout.n].scriptPubKey.ToString();
        for(int x=0;x<TRUST_FUND_NUM;x++)
        {
//        	if(txstr.find(g_TrustPubKeys[x]) != std::string::npos)
//                {
//                	return error("ConnectInputs() : trying to spend trustfund account on the network : %s\n",txstr.c_str());
//               }
        }
}

...
if(addr.IsValid())
{
	for(int x=0;x<TRUST_FUND_NUM;x++)