monero 0.0.0.8 → 0.0.12

data/lib/monero_rpc/client.rb

@@ -0,0 +1,49 @@
+class MoneroRPC::Client
+  include MoneroRPC::Wallet
+  include MoneroRPC::Transfer
+
+  attr_accessor :host, :port, :username, :password, :debug, :in_transfer_clazz, :out_transfer_clazz
+
+  def initialize(args= {})
+    self.host     = args.fetch(:host,     MoneroRPC.config.host)
+    self.port     = args.fetch(:port,     MoneroRPC.config.port)
+    self.username = args.fetch(:username, MoneroRPC.config.username)
+    self.password = args.fetch(:password, MoneroRPC.config.password)
+    self.debug    = args.fetch(:debug,    MoneroRPC.config.debug)
+    self.in_transfer_clazz = args.fetch(:in_transfer_clazz, MoneroRPC.config.in_transfer_clazz || "MoneroRPC::IncomingTransfer")
+    self.out_transfer_clazz = args.fetch(:out_transfer_clazz, MoneroRPC.config.out_transfer_clazz || "MoneroRPC::OutgoingTransfer")
+  end
+
+  def close!
+    request("stop_wallet")
+  end
+
+  def request(method, params="")
+    # TODO
+    # who can implement digest auth with net/http?
+    # this is really ugly!
+    data = '{"jsonrpc":"2.0","id":"0","method": "'+method+'", "params": '+params.to_json+' }'
+    args = ""
+    args << " -s"
+    args << " -u #{username}:#{password} --digest"
+    args << " -X POST #{base_uri}/json_rpc"
+    args << " -d '#{data}'"
+    args << " -H 'Content-Type: application/json'"
+
+    p "curl #{args}" if debug
+    json = JSON.parse(`curl #{args}`)
+
+    # Error handling
+    if json["error"]
+      raise "#{json["error"]["message"]} | code: #{json["error"]["code"]}"
+    end
+    json["result"]
+  end
+
+  private
+
+  def base_uri
+    URI.parse("http://#{host}:#{port}")
+  end
+
+end

data/lib/monero_rpc/config.rb

@@ -0,0 +1,13 @@
+require 'singleton'
+module MoneroRPC
+  class Config
+    include Singleton
+    attr_accessor :host, :port, :username, :password, :debug, :in_transfer_clazz, :out_transfer_clazz
+
+    def initialize
+      self.in_transfer_clazz = "MoneroRPC::IncomingTransfer"
+      self.out_transfer_clazz = "MoneroRPC::OutgoingTransfer"
+    end
+
+  end
+end

data/lib/{rpc → monero_rpc}/payment.rb

@@ -1,6 +1,4 @@
-module RPC
-
+module MoneroRPC
   class Payment
   end
-
 end

data/lib/{rpc → monero_rpc}/transfer.rb

@@ -22,34 +22,29 @@
 # get_tx_hex - boolean; Return the transaction as hex string after sending
 
 
-module RPC
-  # => {"integrated_address"=>"A7TmpAyaPeZLnugTKRSwGJhW4vnYv8RAVdRvYyvbistbHUnojyTHyHcYpbZvbTZHDsi4rF1EK5TiYgnCN6FWM9HjfwGRvbCHYCZAaKSzDx", "payment_id"=>"c7e7146b3335aa54"}
-
-  class Transfer
-
-    def self.create(address, amount, args={})
-      send_bulk([address: address, amount: amount], args)
-    end
-
-    def self.send_bulk(destinations, args={})
+module MoneroRPC::Transfer
+  def create_transfer(address, amount, args={})
+    send_bulk_transfer([address: address, amount: amount], args)
+  end
 
-      mixin = args.fetch(:mixin, 4)
-      fee = args.fetch(:fee, 1) # ignored anyways
-      unlock_time = args.fetch(:unlock_time, 0)
-      payment_id = args.fetch(:payment_id, nil)
-      get_tx_key = args.fetch(:get_tx_key, true)
-      priority = args.fetch(:priority, 0)
-      do_not_relay = args.fetch(:do_not_relay, false)
-      get_tx_hex = args.fetch(:get_tx_hex, false)
+  def send_bulk_transfer(destinations, args={})
 
+    mixin = args.fetch(:mixin, 7)
+    fee = args.fetch(:fee, 1) # ignored anyways
+    unlock_time = args.fetch(:unlock_time, 0)
+    payment_id = args.fetch(:payment_id, nil)
+    get_tx_key = args.fetch(:get_tx_key, true)
+    priority = args.fetch(:priority, 0)
+    do_not_relay = args.fetch(:do_not_relay, false)
+    get_tx_hex = args.fetch(:get_tx_hex, false)
 
-      options = {
-        destinations: destinations, fee: fee, mixin: mixin, unlock_time: unlock_time,
-        payment_id: payment_id, get_tx_key: get_tx_key, priority: priority, do_not_relay: do_not_relay, get_tx_hex: get_tx_hex
-      }
 
-      RPC::Client.request("transfer", options)
-    end
+    options = {
+      destinations: destinations, fee: fee, mixin: mixin, unlock_time: unlock_time,
+      payment_id: payment_id, get_tx_key: get_tx_key, priority: priority, do_not_relay: do_not_relay, get_tx_hex: get_tx_hex
+    }
 
+    request("transfer", options)
   end
+
 end

data/lib/monero_rpc/transfer_class.rb

@@ -0,0 +1,30 @@
+module MoneroRPC
+  class TransferClass
+
+    attr_accessor :address, :amount, :double_spend_seen, :fee, :height, :note,
+      :payment_id, :subaddr_index, :timestamp, :txid, :type, :unlock_time,
+      :destinations, :confirmations, :suggested_confirmations_threshold, :subaddr_indices
+
+    def initialize(args={})
+      args.each do |k,v|
+        self.send("#{k}=", v)
+      end
+    end
+
+    def confirmed?
+      confirmations >= 10
+    end
+
+    def pending?
+      height == 0
+    end
+
+    def locked?
+      raise "TODO"
+    end
+
+  end
+end
+
+class MoneroRPC::IncomingTransfer < MoneroRPC::TransferClass; end
+class MoneroRPC::OutgoingTransfer < MoneroRPC::TransferClass; end

data/lib/monero_rpc/version.rb

@@ -0,0 +1,3 @@
+module MoneroRPC
+  VERSION = "0.0.12"
+end

data/lib/monero_rpc/wallet.rb

@@ -0,0 +1,157 @@
+module MoneroRPC::Wallet
+
+  def create_address(label="")
+    request("create_address", label: label)
+  end
+
+  def get_address
+    get_addresses(0, [0]).first["address"]
+  end
+  alias_method :address, :get_address
+
+  def get_addresses(account_index=0, address_index=[0])
+    request("get_address", {account_index: account_index, address_index: address_index})["addresses"]
+  end
+
+  def getbalance
+    request("getbalance")
+  end
+
+  def balance
+    XMR.new(getbalance["balance"])
+  end
+
+  def unlocked_balance
+    XMR.new(getbalance["unlocked_balance"])
+  end
+
+  def getaddress
+    request("getaddress")["address"]
+  end
+
+  def getheight
+    request("getheight")["height"]
+  end
+
+  def query_key(type)
+    raise ArgumentError unless ["mnemonic", "view_key"].include?(type.to_s)
+    request("query_key", {key_type: type})["key"]
+  end
+  def view_key; query_key(:view_key); end
+  def mnemonic_seed; query_key(:mnemonic); end
+
+
+  def make_integrated_address(payment_id = "")
+    # TODO
+    # Check if payment_id is correct format
+    request("make_integrated_address", {payment_id: payment_id})
+  end
+
+  def split_integrated_address(address)
+    request("split_integrated_address", {integrated_address: address})
+  end
+
+  def incoming_transfers(type)
+    raise ArgumentError unless ["all", "available", "unavailable"].include?(type.to_s)
+    json = request("incoming_transfers", {transfer_type: type})
+    json["transfers"] || []
+  end
+
+  def get_payments(payment_id)
+    payments = request("get_payments", {payment_id: payment_id})["payments"] || []
+    # TODO
+    # make it a MoneroRPC::Payment that hase a amount as XMR and confirmations (getheight - tx.block_height)
+    payments.map{|x| Payment.from_raw(x) }
+  end
+
+  def get_bulk_payments(payment_ids, min_block_height)
+    payments = request("get_bulk_payments", {"payment_ids": payment_ids, "min_block_height": min_block_height})
+    return payments
+  end
+
+
+    # in - boolean;
+    # out - boolean;
+    # pending - boolean;
+    # failed - boolean;
+    # pool - boolean;
+    # filter_by_height - boolean;
+    # min_height - unsigned int;
+    # max_height - unsigned int;
+  def get_transfers(args={})
+    f_in = args.fetch(:in, true)
+    out = args.fetch(:out, false)
+    pending = args.fetch(:pending, true)
+    failed = args.fetch(:failed, false)
+    pool = args.fetch(:pool, true)
+    filter_by_height = args.fetch(:filter_by_height, false)
+    min_height = args.fetch(:min_height, 0)
+    max_height = args.fetch(:max_height, 0)
+
+    options = {in: f_in, out: out, pending: pending, failed: failed, pool: pool, filter_by_height: filter_by_height, min_height: min_height}
+    options[:max_height] = max_height if max_height > min_height
+
+    h = Hash.new
+    json = request("get_transfers", options)
+    json.map{|k, v|
+      h[k] = v.collect{|transfer|
+        if k == "in"
+          in_transfer_clazz.constantize.new(transfer)
+        else
+          out_transfer_clazz.constantize.new(transfer)
+        end
+      }
+    }
+    return h
+  end
+
+  def get_all_incoming_transfers(args={})
+    pending = args.fetch(:pending, true)
+    min_height = args.fetch(:min_height, 0)
+    max_height = args.fetch(:max_height, 0)
+
+    all = get_transfers(filter_by_height: true, min_height: min_height, max_height: max_height, in: true, out: false, pending: true, pool: true)
+    [ all["in"], all["pending"], all["pool"]].flatten.compact
+  end
+
+  def get_all_outgoing_transfers(args={})
+    pending = args.fetch(:pending, true)
+    min_height = args.fetch(:min_height, 0)
+    max_height = args.fetch(:max_height, 0)
+
+    all = get_transfers(filter_by_height: true, min_height: min_height, max_height: max_height, in: false, out: true, pending: pending, pool: true)
+    [ all["out"], all["pending"], all["pool"]].flatten.compact
+  end
+
+  def get_transfer_by_txid(txid)
+    request("get_transfer_by_txid", {txid: txid })
+  end
+
+  # creates a wallet and uses it
+  # if wallet exists, will automatically uses it!
+  def create_wallet(filename, password, language="English")
+    # TODO
+    # language correct format?
+    options = { filename: filename, password: password, language: language }
+    !! request("create_wallet", options)
+  end
+  alias_method :create, :create_wallet
+
+  # returns current balance if open successfull
+  def open_wallet(filename, password="")
+    options = { filename: filename, password: password}
+    if request("open_wallet", options)
+      balance
+    else
+      false
+    end
+  end
+  alias_method :open, :open_wallet
+
+  # stops current MoneroRPC process!
+  def stop_wallet
+    close!
+  end
+  alias_method :close, :stop_wallet
+
+end

data/monero.gemspec

@@ -1,11 +1,11 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'rpc/version'
+require 'monero_rpc/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "monero"
-  spec.version       = RPC::VERSION
+  spec.version       = MoneroRPC::VERSION
   spec.authors       = ["Tim Kretschmer"]
   spec.email         = ["tim@krtschmr.de"]
   spec.description   = %q{A Monero-Wallet-RPC ruby client}
@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency "rspec", "~> 3.0"
 
   spec.required_rubygems_version = '>= 1.3.6'
 

data/spec/monero_spec.rb

@@ -0,0 +1,109 @@
+require "spec_helper"
+
+RSpec.describe MoneroRPC do
+  let(:monero_rpc) { MoneroRPC.new }
+
+  it "has a version number" do
+    expect(MoneroRPC::VERSION).not_to be nil
+  end
+
+  it "gets the current address" do
+    address = monero_rpc.address
+    expect(address.length).to be 95
+  end
+
+  it "creates a new subaddress with a label" do
+    subaddress = monero_rpc.create_address "wallet1"
+    expect(subaddress['address'].length).to be 95
+    expect(subaddress['address_index']).to be_truthy
+  end
+
+  it "creates an integrated address for a payment" do
+    address = monero_rpc.make_integrated_address
+    payment_id = address['payment_id']
+    expect(address['integrated_address'].length).to be 106
+    expect(payment_id.length).to be 16
+  end
+
+  it "lists all addresses of the wallet" do
+    addresses = monero_rpc.get_addresses
+    addresses.each do |adr|
+      expect(adr['address']).to be_a(String)
+      expect(adr['address'].length).to be 95
+      expect(adr['address_index']).to be_an(Integer)
+      expect(adr['label']).to be_a(String)
+      expect(adr['used']).to be(true).or(be(false))
+    end
+  end
+
+  it "gets the balance of the current wallet" do
+    balance = monero_rpc.balance
+    expect(balance).to be_a(Money)
+    expect(balance.fractional).to be_an(Integer)
+    expect(balance.currency).to be_a(Money::Currency)
+  end
+
+  it "returns a formatted balance with dot as decimal separator" do
+    balance = monero_rpc.balance.format
+    expect(balance).to be_a(String)
+    expect(balance).to include('.')
+  end
+
+  it "gets the unlocked balance" do
+    balance = monero_rpc.unlocked_balance
+    expect(balance).to be_a(Money)
+    expect(balance.fractional).to be_an(Integer)
+    expect(balance.currency).to be_a(Money::Currency)
+  end
+
+  it "gets the balance and unlocked balance" do
+    balance = monero_rpc.getbalance
+    expect(balance['balance']).to be_an(Integer)
+    expect(balance['unlocked_balance']).to be_an(Integer)
+  end
+
+  it "gets the current block height" do
+    height = monero_rpc.getheight
+    expect(height).to be_an(Integer)
+  end
+
+  # the wallet locks for approx 10 blocks so this test will fail if
+  # balance is not yet unlocked
+  it "sends XMR to a standard address" do
+    subaddress = monero_rpc.create_address "receiving_wallet"
+    amount = 20075
+    transfer = monero_rpc.create_transfer(subaddress['address'], amount)
+    expect(transfer['amount']).to eq(amount)
+    expect(transfer['fee']).to be_an(Integer)
+    expect(transfer['multisig_txset']).to be_empty
+    expect(transfer['tx_blob']).to be_empty
+    expect(transfer['tx_hash']).to be_truthy
+    expect(transfer['tx_key']).to be_truthy
+    expect(transfer['tx_metadata']).to be_empty
+    expect(transfer['unsigned_txset']).to be_empty
+  end
+
+  it "sends XMR to multiple recipients" do
+    subaddress1 = monero_rpc.create_address "receiving_wallet"
+    subaddress2 = monero_rpc.create_address "receiving_wallet2"
+    amount1 = 20075
+    amount2 = 30075
+
+    recipients = [
+      { address: subaddress1['address'], amount: amount1 },
+      { address: subaddress2['address'], amount: amount2 }
+    ]
+
+    transfer = monero_rpc.send_bulk_transfer(recipients)
+
+    expect(transfer['amount']).to eq(amount1+amount2)
+    expect(transfer['fee']).to be_an(Integer)
+    expect(transfer['multisig_txset']).to be_empty
+    expect(transfer['tx_blob']).to be_empty
+    expect(transfer['tx_hash']).to be_truthy
+    expect(transfer['tx_key']).to be_truthy
+    expect(transfer['tx_metadata']).to be_empty
+    expect(transfer['unsigned_txset']).to be_empty
+  end
+
+end