bitbot 0.0.1

data/.gitignore

@@ -0,0 +1,8 @@
+*.log
+*.output
+.bundle
+.gems
+*.pid
+bitbot.db
+pkg/
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/README.md

@@ -0,0 +1,139 @@
+# Bitbot
+
+An IRC bit-tip style bot. Just for fun, don't use with lots of coins.
+
+## Security
+
+**You probably don't want to use this.**
+
+This section is first because anything Bitcoin related seems to attract
+l33t hax0rs. This is just a toy. You probably shouldn't use it, and if
+you do, you shouldn't put much money into it. Here's why:
+
+Bitbot does not operate on nicknames, but usernames. Therefore, it's
+only secure on IRC networks where usernames are forced. *This probably
+isn't true of whatever IRC network you're on.* (On our IRC network,
+usernames cannot be spoofed.) In order to be secure, the bot would need
+to authenticate users in some other way, perhaps by using NickServ or
+something. Pull requests accepted.
+
+Bitbot uses an online wallet at https://blockchain.info. This was
+because it was the easiest path forward, but it is not the most secure.
+Blockchain.info itself seems reasonably secure, but if someone were to
+breach its servers, they would be able to steal all the coins stored by
+Bitbot. A better setup would be for Bitbot to perform its own
+transactions on the Bitcoin network. Pull requests accepted. :)
+
+Bitbot is based on a Ruby IRC library called
+[Cinch](https://github.com/cinchrb/cinch). I have no idea how secure
+Cinch is - it's possible that it has a remote code execution
+vulnerability. If it does, an attacker can steal all the coins from
+Bitbot.
+
+Hopefully the above has scared you off from installing this and using it
+on Freenode. If it didn't, then you deserve to lose whatever you put in.
+You could just send it to me directly instead:
+`1zachsQ82fM7DC4HZQXMAAmkZ2Qg7pH2V`.
+
+## How Does It Work
+
+Bitbot lets people in IRC send each other Bitcoin. It's loosely modelled
+after the [Reddit Bitcointip](http://redd.it/13iykn).
+
+The big difference is that in Bitbot, tips between users do not show up
+in the blockchain. Bitbot maintains a wallet with all of the deposited
+funds, and then keeps a record of transactions between users. Only
+deposits and withdrawals to and from Bitbot show up in the Bitcoin
+blockchain.
+
+We do this because our tips are generally pretty tiny, and if each one
+were a real transaction, our entire "Bitconomy" would be eaten up by
+transaction fees.
+
+## Installation
+
+ * Install the dependencies (sqlite3)
+
+ * Install the gem:
+
+```bash
+gem install bitbot
+```
+
+ * Create an online wallet at https://blockchain.info/wallet/ . Create a
+   secondary password on it, and I suggest locking access to the IP from
+   which your bot will be running for an little extra security. It's
+   probably also good to set up (encrypted) wallet backups to go to your
+   email address.
+
+ * Create a data directory for Bitbot:
+
+```bash
+$ mkdir ~/.bitbot
+```
+
+ * Create a bitbot.yml file that looks like this:
+
+```yaml
+irc:
+  server: irc.example.com
+  port: 8765
+  ssl: true
+  nick: bitbot
+  username: bitbot@example.com
+  password: blahblah
+
+blockchain:
+  wallet_id: <long guid>
+  password1: <password>
+  password2: <secondary password>
+
+data:
+  path: /home/me/.bitbot
+```
+
+ * Start the bot:
+
+```bash
+$ bitbot start <path to config.yml> 
+```
+
+## Usage
+
+### Help
+
+To get help, `/msg bitbot help`. He will respond with a list of commands
+he supports:
+
+```
+bitbot: Commands: deposit, balance, history, withdrawal
+```
+
+### Deposit
+
+To make a deposit to your Bitbot account, ask bitbot for your depositing
+address: `/msg bitbot deposit`. Bitbot will respond with a Bitcoin
+address to send coins to. Once 
+
+### Tipping
+
+To tip somebody, you must both be in a room with Bitbot. The syntax is
+`+tip <nickname> <amount in BTC> <message>`. When Bitbot sees that, it
+verifies that you have the funds to tip, does a `whois` on the recipient
+nickname, and then transfers the funds. He then responds with a
+confirmation:
+
+```
+bob: how do i make rails tests fast?
+john: refactor your app so you can test it without rails
+bob: +tip john 0.01 ur so smart
+bitbot:  [✔] Verified: bob ➜ ฿+0.01 [$1.12] ➜ john
+```
+
+### Withdrawing
+
+When you want to withdraw funds to another Bitcoin address, just tell
+Bitbot: `/msg bitbot withdraw <amount> <address>`. 
+
+Bitbot will verify that you have enough money, and send `<amount>` BTC -
+0.0005 (to cover the transaction fee) to the specified `<address>`.

data/Rakefile

@@ -0,0 +1,3 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+

data/bin/bitbot

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+
+require 'daemons'
+require 'yaml'
+
+require 'bitbot/bot'
+require 'bitbot/database'
+
+def usage
+  puts "Usage: #{File.basename($0)} {start|stop|run} <path to config.yml>"
+  exit 1
+end
+
+if ARGV.length < 2
+  usage()
+end
+
+config_file = File.expand_path(ARGV.pop)
+
+unless File.exist?(config_file)
+  usage()
+end
+
+config = YAML::load(File.open(config_file))
+unless File.exist?(File.dirname(config['data']['path']))
+  puts "Data directory does not exist: #{File.dirname(config['data']['path'])}"
+  exit 1
+end
+
+# Update the database file
+Bitbot::Database.new(File.join(config['data']['path'], "bitbot.db")).upgrade_schema()
+
+Daemons.run_proc('bitbot',
+                 :hard_exit => true,
+                 :backtrace => true,
+                 :ontop => false,
+                 :multiple => false,
+                 :monitor => true,
+                 :log_output => true) do
+
+  bot = Bitbot::Bot.new(config)
+
+  Thread.new do
+    loop do
+      begin
+        bot.update_exchange_rates()
+        bot.update_addresses()
+      rescue => e
+        puts "exception in loop addresses: #{e}"
+        puts e.backtrace
+      ensure
+        sleep 60
+      end
+    end
+  end
+
+  bot.start
+end
+

data/bitbot.gemspec

@@ -0,0 +1,27 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = %q{bitbot}
+  s.version     = "0.0.1"
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Zach Wily"]
+  s.email       = ["zach@zwily.com"]
+  s.homepage    = %q{http://github.com/zwily/bitbot}
+  s.summary     = %q{Bitcoin IRC Tip Bot}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.default_executable = %q{bitbot}
+  s.require_paths = ["lib"]
+
+
+  s.add_dependency "cinch"
+  s.add_dependency "daemons"
+  s.add_dependency "sqlite3"
+  s.add_dependency "httparty"
+
+  s.add_development_dependency "rspec", "~> 2.5"
+  s.add_development_dependency "yard"
+end
+

data/lib/bitbot/blockchain.rb

@@ -0,0 +1,70 @@
+require 'httparty'
+require 'cgi'
+require 'json'
+
+module Bitbot
+  class Blockchain
+    def initialize(id, password1, password2)
+      @id = id
+      @password1 = password1
+      @password2 = password2
+    end
+
+    def request(api, action = nil, params = {})
+      path = if api == :merchant
+               "merchant/#{@id}/#{action}"
+             elsif api == :ticker
+               "ticker"
+             else
+               "#{api}/#{action}"
+             end
+      url = "https://blockchain.info/#{path}?"
+      params.each do |key, value|
+        url += "#{key}=#{CGI::escape value.to_s}&"
+      end
+
+      response = HTTParty.get(url)
+      raise "HTTP Error: #{response}" unless response.code == 200
+
+      JSON.parse(response.body)
+    end
+
+    def create_deposit_address_for_user_id(user_id)
+      self.request(:merchant, :new_address,
+                   :password => @password1,
+                   :second_password => @password2,
+                   :label => user_id)
+    end
+
+    def get_details_for_address(address)
+      self.request(:address, address, :format => :json)
+    end
+
+    def get_addresses_in_wallet
+      response = self.request(:merchant, :list, :password => @password1)
+      response["addresses"]
+    end
+
+    def get_balance_for_address(address, confirmations = 1)
+      response = self.request(:merchant, :address_balance,
+                              :password => @password1,
+                              :address => address,
+                              :confirmations => confirmations)
+      response["balance"]
+    end
+
+    def create_payment(address, amount, fee)
+      response = self.request(:merchant, :payment,
+                              :password => @password1,
+                              :second_password => @password2,
+                              :to => address,
+                              :amount => amount,
+                              :fee => fee)
+      response
+    end
+
+    def get_exchange_rates
+      self.request(:ticker)
+    end
+  end
+end

data/lib/bitbot/bot.rb

@@ -0,0 +1,404 @@
+# coding: utf-8
+
+require 'cinch'
+require 'bitbot/database'
+require 'bitbot/blockchain'
+require 'ircstring'
+
+module Bitbot
+  class Bot < Cinch::Bot
+    def initialize(config = {})
+      @bot_config = config
+      @cached_addresses = nil
+      @cached_exchange_rates = nil
+
+      super() do
+        configure do |c|
+          c.server   = config['irc']['server']
+          c.port     = config['irc']['port']
+          c.ssl.use  = config['irc']['ssl']
+          c.channels = config['irc']['channels']
+          c.nick     = config['irc']['nick'] || 'bitbot'
+          c.user     = config['irc']['username'] || 'bitbot'
+          c.password = config['irc']['password']
+          c.verbose  = config['irc']['verbose']
+        end
+
+        on :private, /^help$/ do |m|
+          self.bot.command_help(m)
+        end
+
+        on :private, /^balance/ do |m|
+          self.bot.command_balance(m)
+        end
+
+        on :private, /^history/ do |m|
+          self.bot.command_history(m)
+        end
+
+        on :private, /^withdraw$/ do |m|
+          m.reply "Usage: withdraw <amount in BTC> <address>"
+        end
+
+        on :private, /^withdraw\s+([\d.]+)\s+([13][0-9a-zA-Z]{26,35})/ do |m, amount, address|
+          self.bot.command_withdraw(m, amount, address)
+        end
+
+        on :private, /^deposit/ do |m|
+          self.bot.command_deposit(m)
+        end
+
+        on :channel, /^\+tipstats$/ do |m|
+          self.bot.command_tipstats(m)
+        end
+
+        on :channel, /^\+tip\s+(\w+)\s+([\d.]+)\s+?(.*)/ do |m, recipient, amount, message|
+          self.bot.command_tip(m, recipient, amount, message)
+        end
+      end
+    end
+
+    def get_db
+      Bitbot::Database.new(File.join(@bot_config['data']['path'], "bitbot.db"))
+    end
+
+    def get_blockchain
+      Bitbot::Blockchain.new(@bot_config['blockchain']['wallet_id'],
+                             @bot_config['blockchain']['password1'],
+                             @bot_config['blockchain']['password2'])
+    end
+
+    def satoshi_to_str(satoshi)
+      str = "฿%.8f" % (satoshi.to_f / 10**8)
+      # strip trailing 0s
+      str.gsub(/0*$/, '')
+    end
+
+    def satoshi_to_usd(satoshi)
+      if @cached_exchange_rates && @cached_exchange_rates["USD"]
+        "$%.2f" % (satoshi.to_f / 10**8 * @cached_exchange_rates["USD"]["15m"])
+      else
+        "$?"
+      end
+    end
+
+    def satoshi_with_usd(satoshi)
+      btc_str = satoshi_to_str(satoshi)
+      if satoshi < 0
+        btc_str = btc_str.irc(:red)
+      else
+        btc_str = btc_str.irc(:green)
+      end
+
+      usd_str = "[".irc(:grey) + satoshi_to_usd(satoshi).irc(:blue) + "]".irc(:grey)
+
+      "#{btc_str} #{usd_str}"
+    end
+
+    # This should be called periodically to keep exchange rates up to
+    # date.
+    def update_exchange_rates
+      @cached_exchange_rates = get_blockchain().get_exchange_rates()
+    end
+
+    # This method needs to be called periodically, like every minute in
+    # order to process new transactions.
+    def update_addresses
+      cache_file = File.join(@bot_config['data']['path'], "cached_addresses.yml")
+      if @cached_addresses.nil?
+        # Load from the cache, if available, on first load
+        @cached_addresses = YAML.load(File.read(cache_file)) rescue nil
+      end
+
+      blockchain = get_blockchain()
+
+      # Updates the cached map of depositing addresses. 
+      new_addresses = {}
+      all_addresses = []
+
+      addresses = blockchain.get_addresses_in_wallet()
+      addresses.each do |address|
+        all_addresses << address["address"]
+        next unless address["label"] =~ /^\d+$/
+
+        user_id = address["label"].to_i
+
+        new_addresses[user_id] = address
+
+        # We set a flag on the address saying we need to get the
+        # confirmed balance IF the previous entry has the flag, OR
+        # the address is new OR if the balance does not equal the
+        # previous balance. We only clear the field when the balance
+        # equals the confirmed balance.
+        address["need_confirmed_balance"] = @cached_addresses[user_id]["need_confirmed_balance"] rescue true
+        if address["balance"] != (@cached_addresses[user_id]["balance"] rescue nil)
+          address["need_confirmed_balance"] = true
+        end
+      end
+
+      # Now go through new addresses, performing any confirmation checks
+      # for flagged ones.
+      new_addresses.each do |user_id, address|
+        if address["need_confirmed_balance"]
+          balance = blockchain.get_balance_for_address(address["address"])
+          address["confirmed_balance"] = balance
+
+          if address["confirmed_balance"] == address["balance"]
+            address["need_confirmed_balance"] = false
+          end
+
+          # Process any transactions for this address
+          self.process_new_transactions_for_address(address, user_id, all_addresses)
+        end
+      end
+
+      # Thread-safe? Sure, why not.
+      @cached_addresses = new_addresses
+
+      # Cache them on disk for faster startups
+      File.write(cache_file, YAML.dump(@cached_addresses))
+    end
+
+    def process_new_transactions_for_address(address, user_id, all_addresses)
+      db = get_db()
+      blockchain = get_blockchain()
+
+      existing_transactions = {}
+      db.get_incoming_transaction_ids().each do |txid|
+        existing_transactions[txid] = true
+      end
+
+      response = blockchain.get_details_for_address(address["address"])
+
+      username = db.get_username_for_user_id(user_id)
+      ircuser = self.user_with_username(username)
+
+      response["txs"].each do |tx|
+        # Skip ones we already have in the database
+        next if existing_transactions[tx["hash"]]
+
+        # Skip any transactions that have an existing bitbot address
+        # as an input
+        if tx["inputs"].any? {|input| all_addresses.include? input["prev_out"]["addr"] }
+          debug "Skipping tx with bitbot input address: #{tx["hash"]}"
+          next
+        end
+
+        # find the total amount for this address
+        amount = 0
+        tx["out"].each do |out|
+          if out["addr"] == address["address"]
+            amount += out["value"]
+          end
+        end
+
+        # Skip unless it's in a block (>=1 confirmation)
+        if !tx["block_height"] || tx["block_height"] == 0
+          ircuser.msg "Waiting for confirmation of transaction of " +
+            satoshi_with_usd(amount) +
+            " in transaction #{tx["hash"].irc(:grey)}"
+          next
+        end
+
+        # There is a unique constraint on incoming_transaction, so this
+        # will fail if for some reason we try to add it again.
+        if db.create_transaction_from_deposit(user_id, amount, tx["hash"])
+          # Notify the depositor
+          if ircuser
+            ircuser.msg "Received deposit of " +
+              satoshi_with_usd(amount) + ". Current balance is " +
+              satoshi_with_usd(db.get_balance_for_user_id(user_id)) + "."
+          end
+        end
+      end
+    end
+
+    def user_with_username(username)
+      self.bot.user_list.each do |user|
+        return user if user.user == username
+      end
+    end
+
+    def command_help(msg)
+      msg.reply "Commands: balance, history, withdraw, deposit, +tip, +tipstats"
+    end
+
+    def command_balance(msg)
+      db = get_db()
+      user_id = db.get_or_create_user_id_for_username(msg.user.user)
+
+      msg.reply "Balance is #{satoshi_with_usd(db.get_balance_for_user_id(user_id))}"
+    end
+
+    def command_deposit(msg, create = true)
+      db = get_db()
+      user_id = db.get_or_create_user_id_for_username(msg.user.user)
+
+      unless @cached_addresses
+        msg.reply "Bitbot is not initialized yet. Please try again later."
+        return
+      end
+
+      if address = @cached_addresses[user_id]
+        msg.reply "Send deposits to #{address["address"].irc(:bold)}. " +
+          "This address is specific to you, and any funds delivered " +
+          "to it will be added to your account after confirmation."
+        return
+      end
+
+      unless create
+        msg.reply "There was a problem getting your deposit address. " +
+          "Please contact your friends Bitbot admin."
+        return
+      end
+
+      # Attempt to create an address.
+      blockchain = get_blockchain()
+      blockchain.create_deposit_address_for_user_id(user_id)
+
+      # Force a refresh of the cached address list...
+      self.update_addresses()
+
+      self.command_deposit(msg, false)
+    end
+
+    def command_history(msg)
+      db = get_db()
+      user_id = db.get_or_create_user_id_for_username(msg.user.user)
+
+      command_balance(msg)
+
+      n = 0
+      db.get_transactions_for_user_id(user_id).each do |tx|
+        time = Time.at(tx[:created_at].to_i).strftime("%Y-%m-%d")
+        amount = satoshi_with_usd(tx[:amount])
+        action = if tx[:amount] < 0 && tx[:other_user_id]
+                   "to #{tx[:other_username]}"
+                 elsif tx[:amount] > 0 && tx[:other_user_id]
+                   "from #{tx[:other_username]}"
+                 elsif tx[:withdrawal_address]
+                   "withdrawal to #{tx[:withdrawal_address]}"
+                 elsif tx[:incoming_transaction]
+                   "deposit from tx #{tx[:incoming_transaction]}"
+                 end
+
+        msg.reply "#{time.irc(:grey)}: #{amount} #{action} #{"(#{tx[:note]})".irc(:grey) if tx[:note]}"
+
+        n += 1
+        break if n >= 10
+      end
+    end
+
+    def command_withdraw(msg, amount, address)
+      db = get_db()
+      user_id = db.get_or_create_user_id_for_username(msg.user.user)
+
+      satoshi = (amount.to_f * 10**8).to_i
+
+      # Perform the local transaction in the database. Note that we
+      # don't do the blockchain update in the transaction, because we
+      # don't want to roll back the transaction if the blockchain update
+      # *appears* to fail. It might look like it failed, but really
+      # succeed, letting someone withdraw money twice.
+      # TODO: don't hardcode fee
+      begin
+        db.create_transaction_from_withdrawal(user_id, satoshi, 500000, address)
+      rescue InsufficientFundsError
+        msg.reply "You don't have enough to withdraw #{satoshi_to_str(satoshi)} + 0.0005 fee"
+        return
+      end
+
+      blockchain = get_blockchain()
+      response = blockchain.create_payment(address, satoshi, 500000)
+      if response["tx_hash"]
+        msg.reply "Sent #{satoshi_with_usd(satoshi)} to #{address.irc(:bold)} " +
+          "in transaction #{response["tx_hash"].irc(:grey)}."
+      else
+        msg.reply "Something may have gone wrong with your withdrawal. Please contact " +
+          "your friendly Bitbot administrator to investigate where your money is."
+      end
+    end
+
+    def command_tipstats(msg)
+      db = get_db()
+      stats = db.get_tipping_stats
+
+      str = "Stats: ".irc(:grey) +
+        "tips today: " +
+        satoshi_with_usd(0 - stats[:total_tipped]) + " " +
+        "#{stats[:total_tips]} tips "
+
+      if stats[:tippers].length > 0
+        str += "biggest tipper: ".irc(:black) +
+          stats[:tippers][0][0].irc(:bold) +
+          " (#{satoshi_with_usd(0 - stats[:tippers][0][1])}) "
+      end
+
+      if stats[:tippees].length > 0
+        str += "biggest recipient: ".irc(:black) +
+          stats[:tippees][0][0].irc(:bold) +
+          " (#{satoshi_with_usd(stats[:tippees][0][1])}) "
+      end
+
+      msg.reply str
+    end
+
+    def command_tip(msg, recipient, amount, message)
+      db = get_db()
+
+      # Look up sender
+      user_id = db.get_or_create_user_id_for_username(msg.user.user)
+
+      # Look up recipient
+      recipient_ircuser = msg.channel.users.keys.find {|u| u.name == recipient }
+      unless recipient_ircuser
+        msg.user.msg("Could not find #{recipient} in the channel list.")
+        return
+      end
+      recipient_user_id = db.get_or_create_user_id_for_username(recipient_ircuser.user)
+
+      # Convert amount to satoshi
+      satoshi = (amount.to_f * 10**8).to_i
+      if satoshi <= 0
+        msg.user.msg("Cannot send a negative amount.")
+        return
+      end
+
+      # Attempt the transaction (will raise on InsufficientFunds)
+      begin
+        db.create_transaction_from_tip(user_id, recipient_user_id, satoshi, message)
+      rescue InsufficientFundsError
+        msg.reply "Insufficient funds! It's the thought that counts.", true
+        return
+      end
+
+      # Success! Let the room know...
+      msg.reply "[✔] Verified: ".irc(:grey).irc(:bold) +
+        msg.user.user.irc(:bold) +
+        " ➜ ".irc(:grey) +
+        satoshi_with_usd(satoshi) +
+        " ➜ ".irc(:grey) +
+        recipient_ircuser.user.irc(:bold)
+
+      # ... and let the sender know privately ...
+      msg.user.msg "You just sent " +
+        recipient_ircuser.user.irc(:bold) + " " +
+        satoshi_with_usd(satoshi) +
+        " in " +
+        msg.channel.name.irc(:bold) +
+        " bringing your balance to " +
+        satoshi_with_usd(db.get_balance_for_user_id(user_id)) +
+        "."
+
+      # ... and let the recipient know privately.
+      recipient_ircuser.msg msg.user.user.irc(:bold) +
+        " just sent you " +
+        satoshi_with_usd(satoshi) +
+        " in " +
+        msg.channel.name.irc(:bold) +
+        " bringing your balance to " +
+        satoshi_with_usd(db.get_balance_for_user_id(recipient_user_id)) +
+        ". Type 'help' to list bitbot commands."
+    end
+  end
+end

data/lib/bitbot/database.rb

@@ -0,0 +1,142 @@
+require 'sqlite3'
+
+module Bitbot
+  class InsufficientFundsError < StandardError; end
+
+  class Database
+    def initialize(path)
+      @db = SQLite3::Database.new path
+      @db.execute('PRAGMA foreign_keys = ON')
+    end
+
+    def upgrade_schema
+      @db.execute(<<-ENDSQL)
+        create table if not exists users (
+          id integer primary key autoincrement,
+          created_at integer not null,
+          username text not null unique
+        )
+      ENDSQL
+
+      @db.execute(<<-ENDSQL)
+        create table if not exists transactions (
+          id integer primary key autoincrement,
+          created_at integer not null,
+          amount numeric not null,
+          note text,
+          withdrawal_address text,
+          incoming_transaction text unique,
+          user_id int references users(id) not null,
+          other_user_id int references users(id)
+        )
+      ENDSQL
+    end
+
+    def get_or_create_user_id_for_username(username)
+      user_id = @db.get_first_value("select id from users where username = ?", [ username ])
+      unless user_id
+        @db.execute("insert into users(created_at, username) values (?, ?)", [ Time.now.to_i, username ])
+        user_id = @db.get_first_value("select last_insert_rowid()")
+      end
+
+      user_id
+    end
+
+    def get_username_for_user_id(user_id)
+      @db.get_first_value("select username from users where id = ?", [ user_id ])
+    end
+
+    def get_balance_for_user_id(user_id)
+      @db.get_first_value("select coalesce(sum(amount), 0) from transactions where user_id = ?", [ user_id ])
+    end
+
+    def get_transactions_for_user_id(user_id)
+      result = []
+      @db.execute("select t.id, t.created_at, t.amount, t.note, t.withdrawal_address, t.incoming_transaction, t.other_user_id, u.username from transactions t left outer join users u on t.other_user_id = u.id where user_id = ? order by t.created_at desc", [ user_id ]) do |row|
+        result << {
+          :id => row[0],
+          :created_at => row[1],
+          :amount => row[2],
+          :note => row[3],
+          :withdrawal_address => row[4],
+          :incoming_transaction => row[5],
+          :other_user_id => row[6],
+          :other_username => row[7]
+        }
+      end
+      result
+    end
+
+    def get_tipping_stats(from = nil)
+      # If no from is specified, use midnight of today.
+      if from.nil?
+        # TODO: this is hardcoding an offset of -0700 - fix that to make
+        # the timezone configurable
+        now = Time.now - 60 * 60 * 7
+        from = Time.local(now.year, now.month, now.day)
+      end
+      from = from.to_i
+
+      stats = {}
+      
+      stats[:total_tipped] = @db.get_first_value("select coalesce(sum(amount), 0) from transactions t where t.other_user_id is not null and t.user_id <> t.other_user_id and t.amount < 0 and t.created_at > ?", [ from ])
+      stats[:total_tips] = @db.get_first_value("select count(*) from transactions t where t.other_user_id is not null and t.user_id <> t.other_user_id and t.amount < 0 and t.created_at > ?", [ from ])
+      stats[:tippers] = @db.execute("select * from (select username, sum(amount) total from transactions t, users u where t.user_id = u.id and other_user_id is not null and amount < 0 and user_id <> other_user_id and t.created_at >= ? group by username) foo order by total asc", [ from ])
+      stats[:tippees] = @db.execute("select * from (select username, sum(amount) total from transactions t, users u where t.user_id = u.id and amount > 0 and user_id <> other_user_id and t.created_at >= ? group by username) foo order by total desc", [ from ])
+      stats
+    end
+
+    # Returns an array of all the Bitcoin transaction ids for deposits
+    def get_incoming_transaction_ids
+      transaction_ids = []
+      @db.execute("select incoming_transaction from transactions where incoming_transaction is not null") do |row|
+        transaction_ids << row[0]
+      end
+
+      transaction_ids
+    end
+
+    # Adds a transaction with a deposit. Returns true if the row was
+    # added, and false if the insert failed for some reason (like if the
+    # transaction_id already exists).
+    def create_transaction_from_deposit(user_id, amount, transaction_id)
+      @db.execute("insert into transactions (created_at, amount, incoming_transaction, user_id) values (?, ?, ?, ?)",
+                  [ Time.now.to_i, amount, transaction_id, user_id ])
+      return @db.changes == 1
+    end
+
+    # Adds a transaction for a withdrawal.
+    def create_transaction_from_withdrawal(user_id, amount, fee, address)
+      @db.transaction(:exclusive) do
+        # verify current balance
+        current_balance = self.get_balance_for_user_id(user_id)
+        if current_balance < (amount + fee)
+          raise InsufficientFundsError, "Insufficient funds; Current balance: #{current_balance} for amount #{amount} + fee #{fee}"
+        end
+
+        @db.execute("insert into transactions (created_at, user_id, amount, withdrawal_address)
+                     values (?, ?, ?, ?)", [ Time.now.to_i, user_id, (0 - (amount + fee)), address ])
+      end
+
+      true
+    end
+
+    def create_transaction_from_tip(from_user_id, to_user_id, amount, message)
+      @db.transaction(:exclusive) do
+        # verify current balance
+        current_balance = self.get_balance_for_user_id(from_user_id)
+        if current_balance < amount
+          raise InsufficientFundsError, "Insufficient funds; Current balance: #{current_balance} for amount #{amount}"
+        end
+
+        now = Time.now.to_i
+        @db.execute("insert into transactions (created_at, user_id, amount, note, other_user_id)
+                    values (?, ?, ?, ?, ?)", [ now, from_user_id, (0 - amount), message, to_user_id ])
+        @db.execute("insert into transactions (created_at, user_id, amount, note, other_user_id)
+                    values (?, ?, ?, ?, ?)", [ now, to_user_id, amount, message, from_user_id ])
+      end
+
+      true
+    end
+  end
+end

data/lib/ircstring.rb

@@ -0,0 +1,55 @@
+module StyledIrcString
+  CODES = {
+    :color     => "\x03",
+    :bold      => "\x02",
+    :underline => "\x1f",
+    :inverse   => "\x16",
+    :clear     => "\x0f",
+  }
+
+  COLORS = {
+    0  => %w(white),
+    1  => %w(black),
+    2  => %w(blue navy),
+    3  => %w(green),
+    4  => %w(red),
+    5  => %w(brown maroon),
+    6  => %w(purple),
+    7  => %w(orange olive),
+    8  => %w(yellow),
+    9  => %w(light_green lime),
+    10 => %w(teal a_green blue_cyan),
+    11 => %w(light_cyan cyan aqua),
+    12 => %w(light_blue royal),
+    13 => %w(pink light_purple fuchsia),
+    14 => %w(grey),
+    15 => %w(light_grey silver),
+  }    
+
+  def code_for_color(color)
+    COLORS.each do |code, colors|
+      if colors.include? color.to_s
+        return "%02d" % code
+      end
+    end
+
+    nil
+  end
+
+  def irc(attr1, attr2 = nil)
+    if CODES[attr1]
+      return "#{CODES[attr1]}#{self}#{CODES[:clear]}"
+    elsif fg_color = code_for_color(attr1)
+      bg_color = code_for_color(attr2)
+      bg_string = bg_color ? ",#{bg_color}" : ""
+
+      return "#{CODES[:color]}#{fg_color}#{bg_string}#{self}#{CODES[:clear]}"
+    end
+
+    self
+  end
+end
+
+class String
+  include StyledIrcString
+end

metadata

@@ -0,0 +1,153 @@
+--- !ruby/object:Gem::Specification
+name: bitbot
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Zach Wily
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cinch
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: daemons
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.5'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- zach@zwily.com
+executables:
+- bitbot
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- bin/bitbot
+- bitbot.gemspec
+- lib/bitbot/blockchain.rb
+- lib/bitbot/bot.rb
+- lib/bitbot/database.rb
+- lib/ircstring.rb
+homepage: http://github.com/zwily/bitbot
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Bitcoin IRC Tip Bot
+test_files: []
+has_rdoc: