I've created a new plugin for Electrum that provides quite sophisticated Paper Wallet functions. I'd appreciate if users interested in this could have a look and test it. I've done a basic amount of testing on my own Ubuntu install but have not attempted to use it on other OS.

PaperGen allows users to easily:

- generate addresses in bulk (or use existing ones)
- print paper wallets to PDF using SVG templates (samples provided)
- fund those addresses with one multi-output transaction

For additional info see my new repo readme at,
https://github.com/bkkcoins/papergen

If you have the scrypt module available then BIP38 support is enabled. (sudo pip install scrypt).

You can tweak or create new SVG templates with Inkscape. I provided a few samples using the Mike Caldwell colornotes images. Details on variables/layout rules in readme.

Advantages of using this method for paper wallets:

- only need one app if already working offline with Electrum
- can create bulk wallets for giveaways / gifts based off a seed so that unclaimed funds can be swept back
- easy to split a single balance into a series of separate paper keys, thereby reducing risk of a single large theft
- easy to tweak your own layout graphics using Inkscape

Please have a look. I welcome feedback. Use care with real funds as this probably needs more testing before it's fully trustworthy. ie. BETA software

[mixer]

I've created a mixer plugin for Electrum to support in-client use of the blockchain.info mixer. It's not quite standalone as Electrum doesn't really support dynamic loading plugins (which would be a nice thing to work on someday), but the changes to the main program are very minimal to hook it in, and the plugin itself is very simple.

It gives you two new features. A button to request a forwarding address when you send coins, with mixer fee estimate, and a right-click menu option for a forwarding address when showing a QR code for a receive address. These simply make an API call and present the address for the user to confirm.

This plugin will not be integrated into Electrum main line because the devs feel it maybe endangers the project by having a mixer associated with it. I feel it improves usability for those who want more privacy and may be a useful stop gap until the Dark Wallet guys finish up their work.

The plugin is available to anyone who wants to use it in a fork I created just for this purpose, in a branch called "mixer" based off the current master,

https://github.com/tkhaew/electrum/tree/mixer see below


Have a look if you're inclined and comments are welcome.

[Project: Klondike.]

Project: Klondike.

I'm opening this thread to discuss my work on a 16 chip ASIC board.

Updated - See more updated info below before asking questions.

The project home is at: http://github.com/bkkcoins/klondike

I have been working on this for a few weeks now. Current status: board is tentatively ready for first prototypes. There may be some errors, so fresh eyes may help.

Summary Preliminary Specs:

10cm x 10cm board
16 chips/board
24A 1.2V, 1A 3.3V supply on board (~32W total)
PCI Express Power connector for use with ATX PSU
USB mini type B connector, no power draw
PIC USB micro controller on board with bootloader for USB firmware upgrades
I2C board-to-board, daisy chain connector
Fan 3 pin connector (on board temp sensor and PWM speed control)

This board will connect via USB to a host controller like PC, RaspPi, TL-703N etc. capable of running cgminer. Several boards can be chained to run off one USB host.

Updated, May 14th:

I've completed a tentative final board design. There a few things left to do but mostly I'm waiting on communication protocol docs for the Avalon now. I've started working on firmware, and hope to make some progress over the next week. I'll have time while the first prototype boards are made, and I'll be able to debug and test code before the boards arrive.

People keep asking me about what it will cost. First, I am not expecting to sell assembled ready to use boards myself. There are several forum members and companies in contact with me who have expressed interest in building and selling licensed finished boards. When those products are available I will post info here for everyone.

I may be offering DIY kits of [board + parts] to users who have experience and want to assemble their own boards. There may be wholesale pricing as well for large orders. This is not a beginner project. There are 307 components on the board and they're all tiny SMD parts requiring quite a sophisticated assembly process - not just a soldering iron. But, that said, if you know what you're doing, you may be able to order kits at some point and build them or have them built locally. I will keep posting more info as the project progresses and when a real product exists I'll open a web store for taking orders. There is no product to buy at this time so please don't ask how to order or how much it costs. As soon as that info is available it will be posted right here.

Here is the most up to date rendering of the Klondike 16 board and it's little brother the K1. There may also follow later a 4up big brother, the K64. But first let me build a working prototype.

K16


K1 / Nano

[sellers]

So. I've been a member on Bitmit.net for over a year and sold a couple tings too.

But this last week I've started getting lots of commission fee notices in my email. I was totally surprised by this and it's added up to about $7 so far this week. I went exploring the affiliate program info and found out a couple things that explain this.

1. Bitmit pays referral fees for sellers as well as buyers.

2. Someone who joined last year via my link is now selling a lot on Bitmit and every time they complete an order I get a commission.

3. It's pretty small but actually generous from Bitmit's point of view. They pay 15% of fees and as far as I can tell they pay it to seller and buyer referred by affiliates - so it must be costing them 30% of fees.

This is pretty cool and I just wanted people to know. It's a small trickle of worthwhile bitcoin income. Not only do you help Bitmit become the new eBay, but you help Bitcoin get more useful and increase visibility, and you help yourself ongoing into the future too.

Someone who signs up now may become a big seller next year or the year after that.

So if this was news to you and you want to get going selling your junk or products on Bitmit - go ahead and use my signature link to check it out. I'd love for you to do that.

This is my public service announcement for today.

I have some Saphire 5830 cards I've mined on for two years. I haven't pushed them hard and have kept them at stable temperatures long term, running with no monitors on Linux..

I want to sell them to gamers locally here in Thailand where they have trouble getting the latest cards and all GPU cards are way over priced. But I don't want to scam anyone if they are having problems. I've heard of artifacts and such but don't know how to check that.

On Linux. What would be a good test to know if they are still working fine or having issues. I rarely play games so have no idea how to check this.

Interesting article about adapting the blockchain for the Fedwire system.

http://jpkoning.blogspot.com/2013/04/why-fed-is-more-likely-to-adopt-bitcoin.html

At the end he points readers to 3 blogger who actually know Bitcoin in depth. This alone is useful as there are so many that write without knowing.

A few day ago there was much discussion on reddit about fees and confirmation times. I decided to make a small python script to monitor how long transactions take to get confirmed for various values and fees paid.

Here is what my default HTML output looks like. This should be fairly accurate data.


I've been testing it out today and it seems to work ok. So I've put it up on my github repo and hope that others find it useful. I don't have a public facing server with bitcoind running right now so if someone wants to serve a web page with the stats real time then that would be welcomed.

The program outputs two formats. It takes an HTML template and inserts data so you have a web page that gets updated for every block. And it has a CSV data dump as well for importing into other programs.

The code is in my github misc repo along with some other handy Bitcoin utils.

Please let me know if you host it somewhere or find any bugs or issues.

I'm working on a script to provides stats on confirmation speed for various trx amount/fee ranges.

I've got most of it working but when I try to sum trx inputs to calculate the fee I find that usually the inputs trx are already missing. I presume they've been pruned quickly as the block was processed.

The output should still be there if it's just been used as input in a new trx. But since I rely on the API the block gets processed before I can grab the inputs I need. Maybe I need to grab the inputs before the block arrives?

How do I make bitcoind stop pruning? Do I need to set a compile option and rebuild and will it need to fully sync the blockchain again?

Or is there some way I can query the network asking for pruned trx I need?

Just because I was curious I decided to make a simple cmd line python tool that can output the MPK given a seed. It just uses the same code as Electrum client but is much simpler. I was thinking this may be handy as a simple way to generate a wallet offline. The idea is that you only need this very simple script, which can either be copy/pasted or typed in by hand, and a LiveCD/USB to create a wallet.

I was thinking that you can roll dice to gen the seed. Write it down as you go. Then save the MPK for later restore on your desktop Electrum. This way the seed never exists on your desktop and cannot be hacked.

Restoring a wallet from MPK allows watching address balances and generating new addresses but not spending from the addresses. Type command "electrum restore" and pasting the MPK when it asks for seed will create a watch-only wallet.

Code:

#!/usr/bin/env python
#
# Read a seed from stdin and output MPK (Master Public Key).
# Input one seed per line hex (32 chars).
#
# Outputs the SEED and MPK for restoring to Electrum.
# SEED for full wallet, MPK for watch only wallet.
# eg.
#     hexdump -v -e '/1 "%02X"' -n 16 /dev/urandom | mpk
# or
#     echo "1279666de665e6c662d2f45538842acd" |mpk

import sys, ecdsa, hashlib

# secp256k1, http://www.oid-info.com/get/1.3.132.0.10
_p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2FL
_r = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141L
_b = 0x0000000000000000000000000000000000000000000000000000000000000007L
_a = 0x0000000000000000000000000000000000000000000000000000000000000000L
_Gx = 0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798L
_Gy = 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8L
curve_secp256k1 = ecdsa.ellipticcurve.CurveFp( _p, _a, _b )
generator_secp256k1 = ecdsa.ellipticcurve.Point( curve_secp256k1, _Gx, _Gy, _r )
oid_secp256k1 = (1,3,132,0,10)
SECP256k1 = ecdsa.curves.Curve("SECP256k1", curve_secp256k1, generator_secp256k1, oid_secp256k1 )

for seed in sys.stdin:
    oldseed = seed = seed[:32].replace(' ', '')
    for i in range(100000):
        seed = hashlib.sha256(seed + oldseed).digest()
    master_private_key = ecdsa.SigningKey.from_secret_exponent( ecdsa.util.string_to_number( seed ), curve = SECP256k1 )
    print "Seed:", oldseed, "\nMPK:", master_private_key.get_verifying_key().to_string().encode('hex')

This is in my "misc" github repo with my other small scripts.
Although I have tested this to work I suggest you verify yourself. No warranty implied.

So let's say you put your bitcoins in a brain wallet.

In your next life you could visit a psychic and get in touch with your past life to remember your phrase and recover your funds.

Or maybe it's hard to remember words from a past life, so better you write them somewhere long term, like a stone wall. Then you just have to conjure up the location from your past life.

The only way to take your savings with you when you die?

No one today is likely old enough but maybe in ten years we'll hear stories of someone having a seance and discovering the phrase that unlocked their riches.

  He he he.

No longer need this. Deleted.

[Creating an Electrum (pruning) Server Amazon EC2 instance and AMI.]

Creating an Electrum (pruning) Server Amazon EC2 instance and AMI.

I chose to run an Electrum server on EC2 because I already use this service for other work. It's not the best bang-for-buck performance wise but it does have it's advantages. It's proven to be quite robust in my past use and I like that I only pay according to my use as I start/stop instances. It's easy to make snapshots and experiment with.

This step-by-step tutorial shows you how to create an Electrum Server AMI (Amazon Machine Image). An AMI is a ready-to-run virtual machine that you can start when desired, or leave running always. Using spot instances you accept some variability in uptime for a much lower running cost. At this time the monthly cost to run an AMI like this is roughtly $6.84 ($5.04 cpu + $1.80 storage). It's possible to have a small data transfer fee as well (if very busy).

I use timkay's handy cmd line tool here. EC2 operations can also be done easily from the AWS (Web) Console, point and click style, but I won't explain here which buttons and clicks are equivalent. Each command has some equivalent on the web interface.

1. If you want the timkay ec2 cmd line tools.

Code:

cd ~
wget http://github.com/timkay/aws/raw/master/aws
nano .awssecret  (put your EC2 access key and secret key here)
chmod 600 .awssecret
sudo perl aws --install  (creates links for short names)
rm aws
ec2din --simple (test it works)

You can put --simple in a ~/.awsrc file if you always want simple listings.

2. Start an Ubuntu 12.04 server spot instance.

I suggest using a high CPU instance (c1.medium) for compiling and initial blockchain download (saves much time, costs a few cents more), and then switching down to a regular small instance (m1.small) for economy during normal operation (t1.micro is just too small). The blockchain is on a separate data volume so can be detached and attached as needed. This is the process I follow below.

Before requesting a spot instance you'll want to be sure you have a security group with the right port ranges open. If you have one already you can specify the group. If not then this will create a group for electrum with suitable ports, and then use that group when startign the instance.

Code:

ec2addgrp electrum -d "allow electrum ports"
ec2auth electrum -P icmp -s 127.0.0.0/8
ec2auth electrum -P tcp -p 0-65535 -s 127.0.0.0/8
ec2auth electrum -P udp -p 0-65535 -s 127.0.0.0/8
ec2auth electrum -P tcp -p 22 -s 0.0.0.0/0
ec2auth electrum -P tcp -p 8333 -s 0.0.0.0/0
ec2auth electrum -P tcp -p 8081-8082 -s 0.0.0.0/0
ec2auth electrum -P tcp -p 50001-50002 -s 0.0.0.0/0
ec2dgrp |less -S  (check your results)

To request a spot instance we specify AMI, max price, type, security group and login key name. This AMI code is for the Ubuntu 12.04 64bit virtual server image.

Code:

ec2rsi ami-9c78c0f5 -p 0.02 -t c1.medium -g electrum -k MyKey
ec2dsir --simple   (check for status of spot request)
ec2din --simple    (check if instance is running, takes a few minutes sometimes, and copy the public url output)

3. Login to the new instance.

You can make login cmd simpler by editing your .ssh/config file to, eg.

Code:

Host *.compute-1.amazonaws.com
User ubuntu
IdentityFile ~/.ssh/MyKey.pem

Then login with only,

Code:

ssh <public-url-from-above>

4. Prepare your tools - build.

For Ubuntu 12.04 then you need to add this line to your /etc/apt/sources.list (for python-leveldb).

Code:

deb http://archive.ubuntu.com/ubuntu precise-backports main universe

Code:

sudo apt-get update
sudo apt-get install git htop build-essential libssl-dev libboost-all-dev libdb5.1++-dev python-leveldb python-setuptools
cd /usr/src
sudo git clone http://github.com/bitcoin/bitcoin
sudo git clone http://github.com/spesmilo/electrum-server
sudo easy_install jsonrpclib
sudo chown -R ubuntu: *
cd bitcoin
patch -p1 <../electrum-server/patch/patch
cd src
make -f makefile.unix  USE_UPNP=-
sudo cp bitcoind /usr/bin/
sudo ln -s /usr/src/electrum-server/server.py /usr/bin/electrum

5. Create a data volume and attach to server. (to hold blockchain data)

At this writing the bitcoin/electrum data is about 6GB so I'm creating an EBS data volume of 10G. This will be big enough for a while anyway.

Again these cmds use the timkay tools; you can use the AWS Console, your choice.

Code:

ec2din |less -S  (copy the zone id and instance id for your server)
ec2cvol --size 10 --zone <your-zone-id>  (create  volume, choose zone to match your instance)
ec2dvol |less -S   (check for status, repeat until the new volume is available, copy the volume id given)
ec2attvol <volume-id-above> -i <instance-id-from-above> -d /dev/sdf  (attach to your instance as device /dev/sdf)

sudo mkfs -t ext4 /dev/xvdf  (for some odd reason /dev/sdf maps to /dev/xvdf)
mkdir /home/ubuntu/.bitcoin
sudo mount /dev/xvdf /home/ubuntu/.bitcoin
mkdir /home/ubuntu/.bitcoin/electrum_db

6. Configure and start bitcoin.

Let it run until the blockchain is up to date (a long time!).

Code:

cd ~
sudo chown ubuntu: .bitcoin
cat << END > /home/ubuntu/.bitcoin/bitcoin.conf
rpcuser=electrum
rpcpassword=<long-rpc-pwd-here>
END

bitcoind -daemon

You should see a messge that bitcoind is starting and you can monitor it with the getinfo cmd. The blockchain should be far along before you can start Electrum, but you can continue with SSL certs and config files while waiting.

Code:

bitcoind getinfo

7. Create an SSL certificate and key.

There are 4 connection modes in Electrum client TCP,TCP/SSL,HTTP,HTTPS. A certificate is required for the server to start. You can use a self-signed one for TCP/SSL. For HTTPS to work you will need one that is recognized by the client. So either install your own root on the client or get one from a recognized authority. StartSSL.com provides free, but well recognized server certificates. I describe briefly how to create your own self-signed for TCP/SSL mode below.

Code:

openssl genrsa -des3 -out server.key 2048   (use any pwd as we will remove it after)
openssl req -new -key server.key -out server.csr  (answer as suitable, common name is usually your domain name)
sudo openssl rsa -in server.key -out /etc/ssl/electrum.key  (this step removes pwd)
sudo chown ubuntu: /etc/ssl/electrum.key  (since electrum runs as ubuntu we need the key readable by ubuntu)
sudo chmod 600 /etc/ssl/electrum.key  (make sure only owner can read)

(now create the certificate, good for 1 year)
sudo openssl x509 -req -days 365 -in server.csr -signkey server.key -out /etc/ssl/electrum.crt
rm server.key server.csr

8. Configure and start Electrum.

Start out as private (no irc) for testing.

Code:

sudo su
cat << END > /etc/electrum.conf
[server]
host = <your-hostname-here> (make sure the hostname resolves or will not bind)
native_port = 50000
stratum_tcp_port:50001
stratum_http_port:8081
ssl_certfile = /etc/ssl/electrum.crt
ssl_keyfile = /etc/ssl/electrum.key
password = <your-long-electrum-pwd-here>
banner = Welcome to Electrum!
irc = no
cache = yes
backend = leveldb

[bitcoind]
host = localhost
port = 8332
user = electrum
password = <long-rpc-pwd-here>

[leveldb]
path = /run/shm/electrum_db
END

cat << END >/usr/bin/start-electrum
#!/bin/bash
nohup /usr/bin/python -u /usr/bin/electrum &>> /var/log/electrum.log &
END

chmod +x /usr/bin/start-electrum
touch /var/log/electrum.log
chown ubuntu: /var/log/electrum.log

cat << END >/etc/logrotate.d/electrum
/var/log/electrum.log
/home/ubuntu/.bitcoin/debug.log
{
        rotate 5
        copytruncate
        daily
        missingok
        notifempty
        compress
        delaycompress
        sharedscripts
}

END
exit

Edit /etc/electrum.conf to have correct host name and passwords. You can place any "wall" or banner text in the file /etc/electrum.banner.

You can start electrum, but if it catches up with bitcoind block count it will shut down. I started electrum when bitcoind had reached about 170,000 blocks, and this worked for me. Electrum won't start listening for clients until it is fully up to date.

Code:

start-electrum

Check the log file for results. It should show initializing the database, and catching up blocks.

Code:

less /var/log/electrum.log

You can stop Electrum (but it doesn't work until it's caught up and starts listening).

Code:

electrum stop

9. Wait for Electrum to catch up (takes a quite while) and test with a client.

Bitcoin took around 7 hours for me to fully download the blockchain to 211,860. Electrum had reached around block 194,000  by that time. It took roughly another 2 hours for Electrum to fully catch up.

10. Configure both servers to start at boot time.

We initialized electrum with it's data in shared memory (/run/shm/electrum_db) for speed, but we need to move this to the data volume for persistence. So first thing is to move it over, and edit /etc/electrum.conf for the new location.

Code:

electrum stop
mv /run/shm/electrum_db /home/ubuntu/.bitcoin/
sudo sed -i 's/\/run\/shm/\/home\/ubuntu\/.bitcoin/' /etc/electrum.conf

Create an init config so both start on boot. (be sure to change your hostname here)

Code:

sudo su
cat << END >/etc/init/electrum.conf
description     "Start Electrum server"

start on runlevel [2345]
stop on runlevel [016]

exec su -c /usr/bin/init-electrum ubuntu
END

cat << END >/usr/bin/init-electrum
#!/bin/bash
hostname <your-hostname-here>
hostname >/etc/hostname
bitcoind -daemon
until [ "`nc -z localhost 8332;echo $?`" == "0" ]; do sleep 5; done
start-electrum
END

chmod +x /usr/bin/init-electrum

cat << END >> /etc/fstab
/dev/xvdf  /home/ubuntu/.bitcoin  ext4  defaults  0  2
END
exit

Now stop electrum and bitcoind and try out the init manually to be sure it works.

Code:

electrum stop
bitcoind stop
sudo start electrum
htop

In htop you should see bitcoind running. The init script makes sure Electrum only starts after bitcoind is listening on rpc port 8332, so it may take a while (you can see the 5 second polling).

11. Create an AMI from this running instance.

First, now is the time to make Electrum public if you want that for the AMI. Any changes to persist across all instances need to be made before creating the AMI.

Code:

sed -i 's/irc = no/irc = yes/' /etc/electrum.conf

It's possible to create an AMI from the command line but I prefer using the AWS console as I find it is less mistake prone. Open the AWS Console and go to Instance view. Select the correct instance. Choose Actions (above) and Create AMI Image. A panel of options pops up. Enter an AMI name (like Electrum) and description. Click "Create Image".

A snapshot will be created for each the root and data volumes we have. This process takes time and you can view progress on the "Snapshots" and "AMIs" views of the console by clicking the refresh button. During this process the running instance will reboot. After a while the snapshots will complete, and then the new AMI will change status to availble.

12. Start the new AMI as a small instance.

Now you can try starting a working Electrum server from this AMI. This time we'll start a small instance as it costs less to run. Similar to before:

Code:

ec2rsi <new-ami-id-from-console> -p 0.01 -t m1.small -g electrum -k MyKey
ec2dsir --simple   (check for status of spot request)
ec2din --simple    (check if instance is running, takes a few minutes sometimes, and copy the public url output)

Login and check if electrum is up. Try a client to test availability.

Final steps and tweaks.

The AMI created above is not ideal, but it's a starting point for tweaking to perfection. For one, it starts with a snapshot of the data volume and when stopped this new volume will be left existing. What we really need is for the AMI to start alone, attaching the data volume after boot. That way all updates and changes made to the data will persist on the original volume. Another issue is with DNS and IP addresses. This can be solved with an Elastic IP and associating it during the boot process. Finally, it would be nice if the hostname and IP could be given to the instance, when requesting the start up, allowing multiple instances and more flexibility. I have worked out these details but will save that for part two - Seeking Perfection, or upon request.

Please submit feedback or corrections below and I'll try to update as needed.

First time - I'm just looking over the bitcoin source code now and trying to figure out how to add something or even if I need to add it. I'm trying to understand about the data handling as I see now there are a few different cpp files related to this.

What I see is below and my guess at what it relates to (wrt data storage)

db.cpp - appears to be older Berkeley DB code for wallet, logging, peers
leveldb.cpp - seems like interface /support for leveldb
txdb.cpp - looks like a transaction info db using leveldb (keyed by txid?)
main.cpp - appears to write accepted blocks to a simple sequential file (and also some undo data)

I don't see a data file that stores address history, or transactions indexed by address for quick retrieval by address unless I'm mistaken.

So I've been thinking of adding some code to store this data as blocks are "Accepted", enabling quick access to transaction info by address.

Am I missing something? Anyone have relevant comments. Thx.

I'm selling my domain name,

VANITYCOIN.COM

on Bitmit. If you have a use for an attractive bitcoin related domain like this, then take a look.

https://www.bitmit.net/en/item/10773-vanitycoin-com-domain-name

I also have a fully functional web site programmed in Python / MySql and working daemon to manage a GPU farm backend and relay results to the web server. It includes all code to do third party key combining allowing for secure vanity names.

This is not included in this auction above but if someone wants to buy this code for their own use in building a working vanity address service then please contact me for details and negotiation. I can probably set up the site for private testing if desired. I can also consult/program for someone without the needed expertise but I don't intend to pursue it further myself.

The server stack is based on Linux, UWSGI, Nginx, MySql, Python.

My fully tested and working code is written in Python with AJAX user interface, MySql database with replication to copy the data to a backend server running 1 or more GPU cards. I have a modified version of vanitygen that interfaces more cleanly with the Python GPU management code. There is a small Python daemon which monitors new blocks via blockchain.info and detects any user payments to validate and update the payments database. There is no wallet on the server so any refunds (if that's even offered) would be manual. There is no code for regex vanity searches but it is designed such that regex matches could be offered via Amazon EC2 spot instances on demand.

This code would be a great starting point for a vanity address service but may require adapting to any final offering.

How many people are successfully using Coinbase? I was thinking of giving them a try but when I read things like link below it just reminds me of MyBitcoin and I don't want a flaky entity having access to my bank.

https://bitcointalk.org/index.php?topic=128335.0

If this has taken over a week and he's still had no response for support then I'll stay far away until things are much more proven than this. I've used FC4B many times and support is very fast and they have an ongoing thread on this forum for communication. Coinbase seems to offer a lower fee and so that's why I was considering it.

Is there a Coinbase thread here that is monitored continuously?

I have 3x 5830 rig and may try under-volting when the block reward halves.
Currently I average around 900 MH/s @ roughly 520 W.
Depending on how difficulty adjust after the halving I may either stop completely or see if under-volting allows me to continue for a while longer.

Can anyone provide a ball park estimate what I might expect with some under-volting? eg. maybe 700 MH/s @ 400W or something?

I may pick up a Smart Phone someday.

I'd like an Android based one because I like Linux and tinkering. I'd be looking for a cheap or second hand one that is capable and has good functionality without being the latest greatest toy. It needs to be fairly small/compact - not a monster phone, as I prefer it being as light and easy to carry as my regular mobile phone.

I'd prefer one that doesn't have some lame limitations that prevent future upgrades or usability but I know nothing about what's available. What do I need? Well, mostly just a bitcoin wallet, for handling mobile transactions. I could see an ssh app being useful for server admin if such a thing is available.

Any suggestions for a decent model/brand? Samsung / HTC?

(Please don't suggest anything Apple as I won't own their products)

I don't know if this has been solved yet already but I was thinking about the subscription model that Paypal has and how to offer it with Bitcoin.

It seems to me that a simple script output (eg. OP_CHECK_HEIGHT) could be used that checks the block height on pre-signed transactions that would make sure a transaction would not be acepted on the network until a certain block height had been reached.

A customer could sign such a transaction (or series of them) and the merchant could store them to submit at a later block height.

This should work similar to subscribed Paypal payments as they still depend on a balance being on the input address in order to go thru. So a customer could cut the subscription off at any time by withdrawing / not depositing sufficient funds on the address. And the merchant at that time would warn / cancel services.

Does some script like this already exist or could one be created? Wouldn't it then just depend on a special client program to create and manage such transactions? Any issues here?

[split key paper wallets]

When reading the forum today about this reported 8000 btc theft I had this idea that is a bit of a twist on usual usage patterns.

I believe a paper wallet is the closest thing to highly secure cold storage. But the problem is that you need to print the keys on a guaranteed secure computer. That's hard to be sure about.

So how about using the third-party key addition technique to print two partial keys on paper in two different places?

So you generate some keys on bitaddress.org and print them out. But you don't use these keys for your wallet. You take them to another system, somewhere else totally independent of the first one and you scan in the public key.

With the publickey you can use vanitygen (with the -P option) to generate addresses and partial keys, and print them out on that system.

Now you have addresses and two separately produced pieces of paper that only can be used for spends when both keys are scanned in and combined.

Either system could be compromised in any way and as long as the same person/group didn't compromise both then they would never be able to use the partial keys alone.

If this sounds like a good idea I may make up a simple web page that any joe-average can use in two easy steps to create split key paper wallets.

I've developed 90% of a Vanity Address web site using the third-party partial-key support in VanityGen. Would you use it?

I have it working here for test purposes and I'm trying to make final determinations about how to go live or even if it's worth going live. Is there demand?

I've designed it to be as safe as possible for users wanting vanity addresses instantly without hassle for a trivially small fee. Typically you can get dozens or hundreds of matching addresses for a few milliBTC (ie. few US$ cents). Longer matches taking more time cost a bit more, based on processing time.

It works like this:
- you login with a user id and passphrase which is used to generate a "login key pair" in browser.
- your login creates a payment address you can use to maintain a small balance
- you enter in a match pattern and qty and are quoted a price instantly.
- you click to submit the request
 
In most cases your addresses are generated immediately (depends on how many requests are pending) and the results are available with a single click in several formats (html, csv, sql, json).

The public key from the login key pair is used as a unique token on the server and is the only identifying info stored. It is also what is used to generate the addresses. When you click the results item in your request log the addresses are received and combined in browser with your login private key and displayed in a list of vanity addresses/keys.

My server makes use of two backends - for normal prefix matches requests are passed off to a GPU mining rig for processing. For regex matches requests are based on a per hour fee and an Amazon EC2 instance is started to do the search. Both are transparent to end users. You just see the status go from waiting funds >> pending >> processing >> completed.

You can also save a backup of your login key (also as word list like Electrum) in case you forget your login details. This uniquely identifies each user.

Now why am I explaining all this? Well, I'm wondering if people would even use such a service.
If I've done my coding correctly it should be just as secure as blockchain.info or any other online wallet that handles keys. But maybe people would be afraid to use a key gen web site.

Feedback?

(btw I could offer an api for this such that other sites/services could request vanity addresses and use them in their offerings to users easily without doing their own backend coding / mgmt)

(also btw any small balance kept by users is 100% in offline addresses. Any refunds would be by request and processed manually in a batch. In most cases users would never have more than a few bitcents on balance anyway)