Implemented test code to allow the creation of a raw transaction from armoryengine.

Author: tsquareX

.gitignore

@@ -1,3 +1,3 @@
-*.py
+*.pyc
 *.o
 

keepkey_app/SConscript

@@ -2,5 +2,5 @@ from SCons.Script import *
 from scons_util import *
 
 Import('env')
-init_project('keepkey_app', env, deps=['crypto'])
+init_project('keepkey_app', env, deps=['crypto', 'client'])
 

keepkey_app/local/bitcoin.cpp

@@ -2,24 +2,39 @@
  * @brief    Implements the top level bitcoin API.
  */
 
+#include <cstring>
+#include <string>
+
 #include <crypto/public/crypto.h>
 
 #include "bitcoin.h"
 
 namespace cd {
 
-   const char* make_mnemonic() {
+   std::string make_mnemonic() {
        return  mnemonic_generate(MNEMONIC_STRENGTH);
    }
 
-   bool make_wallet(const char* seed) {
+   HDNode make_wallet(std::string &seed) {
+      HDNode wallet;
 
-      return false;
+      /*
+       * The glories of inconsistent constness.
+       */
+      uint8_t *tmp_seed = const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(seed.c_str()));
+      hdnode_from_seed(tmp_seed, seed.length(), &wallet);
+
+      return wallet;
    }
 
+   HDNode make_account_from_wallet(HDNode& wallet) {
+
+   }
 
    bool sign_transaction() {
       return false;
    }
+
+
 }
 

keepkey_app/local/bitcoin.h

@@ -1,6 +1,10 @@
 #ifndef BITCOIN_H
 #define BITCOIN_H
 
+#include <string>
+
+#include <crypto/public/crypto.h>
+
 /**
  * Top level API for handling bitcoin workflows.
  */
@@ -20,9 +24,10 @@ namespace cd {
     *
     * @note The mnemonic is generated assuming a strength of 128 bits.
     */
-   const char* make_mnemonic();
+   std::string make_mnemonic();
+
+   HDNode make_wallet(std::string& seed);
 
-   bool make_wallet(const char* seed);
 
    bool sign_transaction();
 };

keepkey_app/local/keepkey_main.cpp

@@ -1,40 +1,97 @@
-#include <assert.h>
-#include <stdio.h>
+#include <cassert>
+#include <cstring>
+#include <iomanip>
+#include <iostream>
+#include <string>
+#include <sstream>
+#include <vector>
+
+#include <crypto/public/crypto.h>
 
 #include "bitcoin.h"
 
 
 /*
  * Performs user prompting, etc. to make and confirm mnemonic.
  */
-const char* get_mnemonic() {
+std::string get_mnemonic() {
 
     char answer = 'n';
-    const char* mnemonic = NULL;
-
+    std::string mnemonic;
 
     do {
         /*
          * Generate seed and wait for user affirmation.
          */
         mnemonic = cd::make_mnemonic();
 
-        assert(mnemonic != 0);
-
-        printf("Generated seed: \"%s\"\n", mnemonic);
-        printf("    Is this OK? y/n: ");
-        scanf("%c", &answer);
+        std::cout << "\nGenerated seed: \"" <<  mnemonic << "\"" << std::endl;
+        std::cout << "    Is this OK? y/n: " << std::endl;
+        std::cin >> answer;
     } while (answer != 'y');
 
-    printf("mnemonic CONFIRMED.\n");
+    std::cout << "mnemonic CONFIRMED." << std::endl;
 
     return mnemonic;
 }
 
+bool read_and_sign(std::string &tx_fn) {
+    /*
+    FILE* fp = fopen(tx_fn, "r");
+
+    if(fp == NULL) {
+        std::cout << "Transaction file: " << tx_fn << " not found." << std::endl;
+        return false;
+    }
+    */
+    return false;
+}
+
+std::string hexdump(std::vector<uint8_t> &v) {
+    std::ostringstream ret;
+
+    for(size_t i=0; i < v.size(); i++) {
+        ret << std::hex << std::setfill('0') << std::setw(2) << v[i];
+        if(i != v.size()-1) {
+            ret << " ";
+        }
+    }
+
+    return ret.str();
+}
+
+void print_wallet(HDNode& wallet) {
+    std::cout << "Created bip32 wallet:" << std::endl;
+    std::cout << "  depth       : " <<  wallet.depth << std::endl;
+    std::cout << "  fingerprint : " <<  wallet.fingerprint << std::endl;
+    std::cout << "  child_num   : " <<  wallet.child_num << std::endl; 
+    std::vector<uint8_t> v;
+    v.assign(wallet.chain_code, wallet.chain_code + sizeof(wallet.chain_code));
+    /*
+    std::cout << "  chain_code  : " << hexdump(std::vector<uint8_t>(wallet.chain_code)) << std::endl;
+    std::cout << "  private_key : " << hexdump(wallet.private_key) << std::endl;
+    std::cout << "  public_key  : " << hexdump(wallet.public_key) << std::endl;
+    */
+}
+
 int main(int argc, char *argv[]) {
 
-    printf("Making seed ...\n");
-    const char* mnemonic = get_mnemonic();
+    std::cout << "Making seed ..." << std::endl;
+    std::string mnemonic = get_mnemonic();
+
+    /**
+     * Make the bip32 wallet.
+     */
+    HDNode wallet = cd::make_wallet(mnemonic);
+    print_wallet(wallet);
+
+    /*
+     * Read transaction from file and do it.
+     */
+    std::string transaction_filename("tx.txt");
+    std::cout << "Reading transaction from " <<  transaction_filename << " ... " << std::endl;
+    read_and_sign(transaction_filename);
+    std::cout << "Transaction signed." << std::endl;
 
     return 0;
 }

keepkey_app/test/init.sh

@@ -0,0 +1,2 @@
+ARMORY_PATH=~/src/BitcoinArmory
+export PYTHONPATH=$PYTHONPATH:$ARMORY_PATH

keepkey_app/test/make_raw_tx.py

@@ -0,0 +1,89 @@
+# Run with python make_raw_tx.py --testnet
+from armoryengine import *
+
+wallet_name = '/home/tom/.armory/testnet3/armory_2bZuo2ari_.wallet'
+
+#
+# Source bitcoin addresses for the transaction
+#
+source_addr_list = ['myHnTiAfku2nqLBvj4CA5DXiXKR1pdaAkW']
+
+# 
+# Destination bitcoin address for the transaction.
+#
+dest_list = [('mk5pFDdTFfnUke4fo9J4weqrX2vKLFokcE', long(1))]
+
+
+
+# 
+# The intermediate file that contains the transaction to be sent to the
+# keepkey.
+#
+tx_unsigned_outfile = 'tx_unsigned_out.dat'
+
+
+
+def createTxFromAddrList(walletObj, addrList, recipList, \
+                                          fee=0, changeAddr=None):
+   #
+   # Warning: Assumes the wallet is synced with the blockchain already.
+   # Ensure that you've started armory up already, which does that 
+   # automatically at startup.
+   #
+
+   # Check that all addresses are actually in the specified wallet
+   print '\nVerifying transaction addresses.'
+   for addr in addrList:
+      addr160 = addrStr_to_hash160(addr)
+      if not walletObj.hasAddr(addr160):
+         raise WalletAddressError, 'Address is not in wallet! [%s]' % addr
+
+   # 
+   # Load the block chain
+   #
+   start = RightNow()
+   TheBDM.setBlocking(True)
+   TheBDM.setOnlineMode(True)
+   # The setOnlineMode should block until blockchain loading is complete
+   print 'Loading blockchain took %0.1f sec' % (RightNow() - start)
+
+   topBlock = TheBDM.getTopBlockHeight()
+   print '\n\nCurrent Top Block is:', topBlock
+   TheBDM.getTopBlockHeader().pprint()
+
+   print '\nCollecting Unspent TXOut List...'
+   # getAddrTxOutList() returns a C++ vector<UnspentTxOut> object, which must 
+   # be converted to a python object using the [:] notation:  it's a weird 
+   # consequence of mixing C++ code with python via SWIG...
+   utxoList = []
+   for addr in addrList:
+      addr160 = addrStr_to_hash160(addr)
+      unspentTxOuts = walletObj.getAddrTxOutList(addr160, 'Spendable')
+      utxoList.extend(unspentTxOuts[:])
+   
+   # Display what we found
+   totalUtxo = sumTxOutList(utxoList)
+   totalSpend   = sum([pair[1] for pair in recipList])
+   print 'Available:  %d unspent outputs from %d addresses: %s BTC' % \
+                  (len(utxoList), len(addrList), coin2str(totalUtxo, ndec=2))
+
+   # Print more detailed information
+   pprintUnspentTxOutList(utxoList, 'Available outputs: ')
+
+def main():
+    print "Opening armory wallet %s" % wallet_name
+    wlt = PyBtcWallet().readWalletFile(wallet_name)
+    TheBDM.registerWallet(wlt)
+
+    print "Creating unsigned transaction: "
+    print "  Testnet test bitcoin     : " + source_addr_list[0]
+    print "  Tx Unsigned Outfile      : " + tx_unsigned_outfile
+    print "  Current blockchain state : " + TheBDM.getBDMState()
+    raw_tx = createTxFromAddrList(wlt, source_addr_list, dest_list)
+
+    execCleanShutdown()
+
+if __name__ == '__main__':
+    main()
+
+