func makeValidTxnNoError(t *testing.T, mv *visor.Visor) coin.Transaction {
	we := wallet.NewWalletEntry()
	tx, err := mv.Spend(mv.Wallets[0].GetID(), visor.Balance{10 * 1e6, 0}, 0,
		we.Address)
	assert.Nil(t, err)
	return tx
}

// Transfers all the coins and hours in genesis block to an address
func transferAllToAddress(v *visor.Visor, gb visor.SignedBlock,
	dest coin.Address) (visor.SignedBlock, error) {
	sb := visor.SignedBlock{}
	if gb.Block.Head.BkSeq != uint64(0) {
		return sb, errors.New("Must be genesis block")
	}
	// Send the entire genesis block to dest
	if len(gb.Block.Body.Transactions) != 1 {
		log.Panic("Genesis block has only 1 txn")
	}
	tx := gb.Block.Body.Transactions[0]
	if len(tx.Out) != 1 {
		log.Panic("Genesis block has only 1 output")
	}
	amt := visor.NewBalance(tx.Out[0].Coins, tx.Out[0].Hours)
	tx, err := v.Spend(amt, 0, dest)
	if err != nil {
		return sb, err
	}
	// Add the tx to the unconfirmed pool so it can get picked up
	err, _ = v.RecordTxn(tx)
	if err != nil {
		return sb, err
	}
	// Put the tx in a block and commit
	sb, err = v.CreateBlock(gb.Block.Head.Time + 1)
	if err != nil {
		return sb, err
	}
	err = v.ExecuteSignedBlock(sb)
	if err != nil {
		return sb, err
	}
	return sb, nil
}

//modify to return error
// NOT WORKING
// actually uses visor
func (self *WalletRPC) GetWalletBalance(v *visor.Visor,
	walletID wallet.WalletID) (wallet.BalancePair, error) {

	wlt := self.Wallets.Get(walletID)
	if wlt == nil {
		log.Printf("GetWalletBalance: ID NOT FOUND: id= %s", walletID)
		return wallet.BalancePair{}, errors.New("Id not found")
	}
	auxs := v.Blockchain.Unspent.AllForAddresses(wlt.GetAddresses())
	puxs := v.Unconfirmed.SpendsForAddresses(&v.Blockchain.Unspent,
		wlt.GetAddressSet())

	coins1, hours1 := v.AddressBalance(auxs)
	coins2, hours2 := v.AddressBalance(auxs.Sub(puxs))

	confirmed := wallet.Balance{coins1, hours1}
	predicted := wallet.Balance{coins2, hours2}

	return wallet.BalancePair{confirmed, predicted}, nil
}

func transferCoins(mv *visor.Visor, v *visor.Visor) error {
	// Give the nonmaster some money to spend
	addr := v.Wallet.GetAddresses()[0]
	tx, err := mv.Spend(visor.Balance{10 * 1e6, 0}, 0, addr)
	if err != nil {
		return err
	}
	mv.RecordTxn(tx)
	sb, err := mv.CreateAndExecuteBlock()
	if err != nil {
		return err
	}
	return v.ExecuteSignedBlock(sb)
}

func makeMoreBlocks(mv *visor.Visor, n int,
	now uint64) ([]visor.SignedBlock, error) {
	dest := visor.NewWalletEntry()
	blocks := make([]visor.SignedBlock, n)
	for i := 0; i < n; i++ {
		tx, err := mv.Spend(visor.Balance{10 * 1e6, 0}, 0, dest.Address)
		if err != nil {
			return nil, err
		}
		mv.RecordTxn(tx)
		sb, err := mv.CreateBlock(now + uint64(i) + 1)
		if err != nil {
			return nil, err
		}
		err = mv.ExecuteSignedBlock(sb)
		if err != nil {
			return nil, err
		}
		blocks[i] = sb
	}
	return blocks, nil
}

func makeValidTxn(mv *visor.Visor) (coin.Transaction, error) {
	we := visor.NewWalletEntry()
	return mv.Spend(visor.Balance{10 * 1e6, 0}, 0, we.Address)
}

func makeValidTxn(mv *visor.Visor) (coin.Transaction, error) {
	we := wallet.NewWalletEntry()
	return mv.Spend(mv.Wallets[0].GetID(), wallet.Balance{10 * 1e6, 0}, 0,
		we.Address)
}