cryptos 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7eab144e238bbc87fd1a9d71dab7c57d590a294b30a489b1cd85e87f9a2e60db
-  data.tar.gz: 19ecae744e1f98ebc17ebfcde4ec4673183085455b62641f0d684d569aa2c50b
+  metadata.gz: 821b977f9586beced716c6274e4c4de1b2bd59eacb2ca2d1f00ba7555cda7a46
+  data.tar.gz: aef2d8dcd9b5ef0155925df43d89fb8738fe09cfa1e99d9d78065a82ee3bcf6c
 SHA512:
-  metadata.gz: 373c5b5c1775ce8c485aa7f93706c7619ce78a09b42e499b3ff5d22256385c33767cfa681fc3c76d2ce55016fe6456861da5bfe7ca4c5866db7dfecd70af750f
-  data.tar.gz: 42851acdf1e22ee3c6537be65c3537c6dc9c7dea69e556bc676f1cd322bdca0782467f2092850adbe5026a32c8b378803fc95eb0d3696df098e66451e60a7f12
+  metadata.gz: cc3b5bc76776036438e1bb65efa1988f7fd0c8c12adcd57feab46bf94103086a024b5e92b7774891e27eaa9ed330b48ea7e841ddd87bbe5e816d2762f2cee353
+  data.tar.gz: 51fb82e5739d2a160f7968dcc8fa37f72b805614e85407051789b3b060c08a49a8153e9cba83f212a8aa236c5325f3a2f7ff05ca91cc2b42c650924a2e8c22f6

data/.travis.yml

@@ -5,6 +5,13 @@ cache: bundler
 rvm:
   - 2.5.3
 
+env:
+  global:
+    - CC_TEST_REPORTER_ID=38c8686e073a8123e72d8f7c580edbfae244922662e6202e9a964152b6b234a0
+
+apt_packages:
+  - bitcoind
+
 before_install:
   - gem install bundler -v 1.16.6
   - sudo apt-add-repository ppa:bitcoin/bitcoin -y
@@ -13,13 +20,14 @@ before_install:
   - wget https://download.litecoin.org/litecoin-0.16.3/linux/litecoin-0.16.3-x86_64-linux-gnu.tar.gz
   - tar -xvf litecoin-0.16.3-x86_64-linux-gnu.tar.gz
   - export PATH=./litecoin-0.16.3/bin:$PATH
-  - echo $PATH
-
-apt_packages:
-  - bitcoind
+  - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
+  - chmod +x ./cc-test-reporter
 
 before_script:
-  # - mkdir -p /home/travis/.bitcoin && cp bitcoin.conf /home/travis/.bitcoin/bitcoin.conf
   - bitcoind -regtest -daemon
   - litecoind -regtest -daemon
   - sleep 15
+  - ./cc-test-reporter before-build
+
+after_script:
+  - ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT

data/Gemfile.lock

@@ -1,20 +1,23 @@
 PATH
   remote: .
   specs:
-    cryptos (0.0.1)
+    cryptos (0.0.2)
       hashie
       httparty
 
 GEM
   remote: https://rubygems.org/
   specs:
+    bump (0.7.0)
     coderay (1.1.2)
     diff-lcs (1.3)
+    docile (1.3.1)
     ecdsa (1.2.0)
     hashie (3.6.0)
     httparty (0.16.3)
       mime-types (~> 3.0)
       multi_xml (>= 0.5.2)
+    json (2.1.0)
     method_source (0.9.2)
     mime-types (3.2.2)
       mime-types-data (~> 3.2015)
@@ -37,17 +40,24 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.8.0)
     rspec-support (3.8.0)
+    simplecov (0.16.1)
+      docile (~> 1.1)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
+  bump
   bundler
   cryptos!
   ecdsa
   pry
   rake
   rspec
+  simplecov
 
 BUNDLED WITH
    1.17.1

data/README.md

@@ -1,10 +1,11 @@
 # Cryptos
 [![Build Status](https://travis-ci.org/icostan/cryptos.svg?branch=master)](https://travis-ci.org/icostan/cryptos)
-[![Test Coverage](https://api.codeclimate.com/v1/badges/50a2b33cfb10cd5293dc/test_coverage)](https://codeclimate.com/github/icostan/cryptos/test_coverage)
+[![Maintainability](https://api.codeclimate.com/v1/badges/d929c152bff4fe5be78f/maintainability)](https://codeclimate.com/github/icostan/cryptos/maintainability)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/d929c152bff4fe5be78f/test_coverage)](https://codeclimate.com/github/icostan/cryptos/test_coverage)
+[![Gem Version](https://badge.fury.io/rb/cryptos.svg)](https://badge.fury.io/rb/cryptos)
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/cryptos`. To experiment with that code, run `bin/console` for an interactive prompt.
+Cryptos project is meant to provide an unified Ruby API to work with different crypto-currencies but the ultimate goal is to support atomic-swaps between any two coins.
 
-TODO: Delete this and the text above, and describe your gem
 
 ## Installation
 
@@ -24,7 +25,102 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+### Scenario 1: Spend coinbase transaction
+
+Alright, let's begin, first thing first, lets generate private and public keys:
+
+```ruby
+2.5.3 :001 > private_key = Cryptos::PrivateKey.generate
+ => #<Cryptos::PrivateKey:0x00007f8cc10c0ad0 @value=1991485315816438798044329630916774278846523543844864946402119577704095054145, @order=115792089237316195423570985008687907852837564279074904382605163141518161494337>
+2.5.3 :002 > public_key = Cryptos::PublicKey.new private_key
+ => #<Cryptos::PublicKey:0x00007f8cc105ed58 @private_key=#<Cryptos::PrivateKey:0x00007f8cc10c0ad0 @value=1991485315816438798044329630916774278846523543844864946402119577704095054145, @order=115792089237316195423570985008687907852837564279074904382605163141518161494337>, @x=107779388491921327681974754398507503201871466663959093103394577491037829153768, @y=78060352001932916201234328232450653863791592111885208305671830584742527863131>
+```
+
+Based in publik key above lets create a Bitcoin address:
+
+```ruby
+2.5.3 :003 > from_address = Cryptos::Bitcoin::Address.new public_key
+ => #<Cryptos::Bitcoin::Address:0x00007f8cc12fc560 @public_key=#<Cryptos::PublicKey:0x00007f8cc105ed58 @private_key=#<Cryptos::PrivateKey:0x00007f8cc10c0ad0 @value=1991485315816438798044329630916774278846523543844864946402119577704095054145, @order=115792089237316195423570985008687907852837564279074904382605163141518161494337>, @x=107779388491921327681974754398507503201871466663959093103394577491037829153768, @y=78060352001932916201234328232450653863791592111885208305671830584742527863131>, @testnet=true>
+```
+
+Before going any further we need to install bitcoin-core daemon and start node in regtest mode:
+
+```shell
+# in MacOS
+brew install bitcoin
+
+# in Linux (Debian based)
+apt-get install bitcoin
+
+# start Bitcoin daemon in regtest mode
+bitcoin-cli -regtest -printtoconsole
+```
+
+Now we create a simple Cli connector that will communicate to underlying bitcoin daemon.
+
+```ruby
+2.5.3 :004 > cli = Cryptos::Connectors::Cli.new
+ => #<Cryptos::Connectors::Cli:0x00007f8cc12ece30 @program="bitcoin-cli", @network="regtest", @verbose=false>
+```
+
+Import address into node and generate 101 blocks. If you ask why 101 then it is because coinbase transactions are spendable after 100 confirmatinos.
+
+```ruby
+2.5.3 :005 > from_address.import cli
+ => true
+2.5.3 :006 > cli.generate_to_address from_address, blocks: 101
+ => true
+```
+
+Generate and import destination address to send BTC to then check that it has no money in it.
+
+```ruby
+2.5.3 :007 > to_address = Cryptos::Bitcoin::Address.new Cryptos::PublicKey.new Cryptos::PrivateKey.generate
+ => #<Cryptos::Bitcoin::Address:0x00007f8cc134f2b0 @public_key=#<Cryptos::PublicKey:0x00007f8cc128fa78 @private_key=#<Cryptos::PrivateKey:0x00007f8cc128faa0 @value=104555233989943463494354097619221894829574308702717051161491781222000198727347, @order=115792089237316195423570985008687907852837564279074904382605163141518161494337>, @x=1402024405898287938501468401055931693243587868828983898835308320263377717122, @y=89146164815925753866667564550747587615674131412309491381641677989226156891240>, @testnet=true>
+2.5.3 :008 > to_address.import cli
+ => true
+2.5.3 :009 > cli.get_received_by_address to_address
+ => "0.00000000"
+```
+
+Alright, now we get to real stuff, transactions: create input from our ```from_address```, send 123_456_789 Satoshis (1.23456789 BTC) to our ```to_address``` and change amount back to ```from_address```.
+
+```ruby
+2.5.3 :010 > input = Cryptos::Input.from_utxo cli, from_address
+ => #<struct Cryptos::Input value=2500000000.0, tx_hash="33fc8506d7a5880cfddca3c950f95fa461398fb764da4527169d5574a7c00c7b", index=0, script_sig=nil, sequence=68719476735>
+2.5.3 :011 > output = Cryptos::Output.p2pkh to_address, 123_456_789
+ => #<struct Cryptos::Output value=123456789, script_pubkey=#<Cryptos::Script:0x00007f8cc12ed8a8 @script="OP_DUP OP_HASH160 9aae79929e4364ab3aabe1f83a875304d1b67a3a OP_EQUALVERIFY OP_CHECKSIG">>
+2.5.3 :012 > change = Cryptos::Output.p2pkh_change from_address, input, output
+ => #<struct Cryptos::Output value=2376533211.0, script_pubkey=#<Cryptos::Script:0x00007f8cc12cfdd0 @script="OP_DUP OP_HASH160 57a58e05aedfbb6bd97b373baf65ce7cc318351b OP_EQUALVERIFY OP_CHECKSIG">>
+2.5.3 :013 > transaction = Cryptos::Transaction.from_ioc input, output, change
+ => #<struct Cryptos::Transaction version=1, inputs=[#<struct Cryptos::Input value=2500000000.0, tx_hash="33fc8506d7a5880cfddca3c950f95fa461398fb764da4527169d5574a7c00c7b", index=0, script_sig=nil, sequence=68719476735>], outputs=[#<struct Cryptos::Output value=123456789, script_pubkey=#<Cryptos::Script:0x00007f8cc12ed8a8 @script="OP_DUP OP_HASH160 9aae79929e4364ab3aabe1f83a875304d1b67a3a OP_EQUALVERIFY OP_CHECKSIG">>, #<struct Cryptos::Output value=2376533211.0, script_pubkey=#<Cryptos::Script:0x00007f8cc12cfdd0 @script="OP_DUP OP_HASH160 57a58e05aedfbb6bd97b373baf65ce7cc318351b OP_EQUALVERIFY OP_CHECKSIG">>], locktime=0>
+```
+
+Sign and broadcast the transaction:
+
+```ruby
+2.5.3 :014 > transaction.sign_single_input from_address
+ => "01000000017b0cc0a774559d162745da64b78f3961a45ff950c9a3dcfd0c88a5d70685fc33000000006a473044022020b53986c2ef08d54137e57f1c231a0c2fe1b6dc88c7208ecef6f7474bae985002203027db653202da53ce081da46431ef1f88f3e1bf47254940a58740a86506cbc3012103ee48f8db1d9a5dfc1b620dbe9566b77d995e0325b91d3b661a697272920f43e8ffffffff0215cd5b07000000001976a9149aae79929e4364ab3aabe1f83a875304d1b67a3a88acdb04a78d000000001976a91457a58e05aedfbb6bd97b373baf65ce7cc318351b88ac00000000"
+2.5.3 :015 > transaction.broadcast cli
+ => true
+```
+
+Mine new block that will contain our hand crafted transaction and VOILA! output amount was transafered to new address.
+
+```ruby
+2.5.3 :016 > cli.generate blocks: 1
+ => true
+2.5.3 :017 > cli.get_received_by_address to_address
+ => "1.23456789"
+```
+
+### Scenario 2: Spend multisig transaction
+
+TBD
+
+### Scenario 3: Atomic swaps between BTC and LTC
+
+TBD
 
 ## Development
 

data/TODOs.org

@@ -7,3 +7,4 @@
   * autoload modules
   * deterministic signature (https://tools.ietf.org/html/rfc6979)
   * refactor elliptic curve module, extract to classes
+  * implement #to_s method for all classes, right now they are too verbose

data/bin/run

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+private_key = Cryptos::PrivateKey.generate
+public_key = Cryptos::PublicKey.new private_key
+from_address = Cryptos::Bitcoin::Address.new public_key
+cli = Cryptos::Connectors::Cli.new
+from_address.import cli
+cli.generate_to_address from_address, blocks: 101
+to_address = Cryptos::Bitcoin::Address.new Cryptos::PublicKey.new Cryptos::PrivateKey.generate
+to_address.import cli
+cli.get_received_by_address to_address
+input = Cryptos::Input.from_utxo cli, from_address
+output = Cryptos::Output.p2pkh to_address, 123_456_789
+change = Cryptos::Output.p2pkh_change from_address, input, output
+transaction = Cryptos::Transaction.from_ioc input, output, change
+transaction.sign_single_input from_address
+transaction.broadcast cli
+cli.generate blocks: 1
+cli.get_received_by_address to_address

data/cryptos.gemspec

@@ -42,4 +42,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec'
   spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'bump'
 end

data/lib/cryptos.rb

@@ -3,9 +3,11 @@ require 'hashie'
 
 require 'cryptos/version'
 
-require 'cryptos/base'
+require 'cryptos/utils/bytes'
+require 'cryptos/utils/hexas'
+require 'cryptos/utils/hashes'
+
 require 'cryptos/base58'
-require 'cryptos/hashing'
 require 'cryptos/elliptic_curve'
 require 'cryptos/connectors/cli'
 

data/lib/cryptos/address.rb

@@ -1,7 +1,7 @@
 module Cryptos
   class Address
-    include Base58, Hashing
-    extend Base58, Hashing
+    include Base58, Utils::Hashes
+    extend Base58, Utils::Hashes
 
     attr_reader :public_key
     attr_reader :testnet
@@ -16,7 +16,7 @@ module Cryptos
     #
     def generate(network)
       prefix = network.to_s(16).rjust 2, '0'
-      ripemd160 = hash160 public_key.compressed
+      ripemd160 = hash160 public_key.to_sec
       with_version = "#{prefix}#{ripemd160}"
       checksum = hash256(with_version)[0, 8]
       wrap_encode = "#{with_version}#{checksum}"
@@ -28,7 +28,7 @@ module Cryptos
     end
 
     def to_hash160
-      hash160(public_key.compressed)
+      hash160(public_key.to_sec)
     end
 
     def p2pkh
@@ -39,6 +39,10 @@ module Cryptos
       generate p2sh_prefix
     end
 
+    def import(cli)
+      cli.import_address self
+    end
+
     def to_s
       p2pkh
     end

data/lib/cryptos/base58.rb

@@ -1,24 +1,29 @@
-module Base58
-  def base58_encode(ripe160_hash)
-    alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
-    value = ripe160_hash.to_i 16
-    output = ''
-    while value > 0
-      remainder = value % 58
-      value /= 58
-      output += alphabet[remainder]
+module Cryptos
+  module Base58
+    include Utils::Bytes
+
+    def base58_encode(ripe160_hash)
+      alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+      value = ripe160_hash.to_i 16
+      output = ''
+      while value > 0
+        remainder = value % 58
+        value /= 58
+        output += alphabet[remainder]
+      end
+      output += alphabet[0] * [ripe160_hash].pack('H*').bytes.find_index{|b| b != 0}
+      output.reverse
     end
-    output += alphabet[0] * [ripe160_hash].pack('H*').bytes.find_index{|b| b != 0}
-    output.reverse
-  end
-  def base58_decode(address)
-    alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
-    int_val = 0
-    address.reverse.chars.each_with_index do |char, index|
-      char_index = alphabet.index(char)
-      int_val += char_index * 58**index
+
+    def base58_decode(address)
+      alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+      int_val = 0
+      address.reverse.chars.each_with_index do |char, index|
+        char_index = alphabet.index(char)
+        int_val += char_index * 58**index
+      end
+      # TODO: hard coded 25 bytes?
+      bignum_to_bytes(int_val, 25).unpack('H*').first
     end
-    # TODO: hard coded 25 bytes?
-    bignum_to_bytes(int_val, 25).unpack('H*').first
   end
 end

data/lib/cryptos/bitcoin/script.rb

@@ -1,4 +1,6 @@
-module Bitcoin
-  class Script
+module Cryptos
+  module Bitcoin
+    class Script
+    end
   end
 end

data/lib/cryptos/connectors/cli.rb

@@ -1,30 +1,68 @@
-module Connectors
-  class Cli
-    attr_reader :program, :network
+module Cryptos
+  module Connectors
+    class Cli
+      attr_reader :program, :network, :verbose
 
-    def initialize(program = 'bitcoin-cli', network = 'regtest')
-      @program = program
-      @network = network
-    end
+      def initialize(program: 'bitcoin-cli', network: 'regtest', verbose: false)
+        @program = program
+        @network = network
+        @verbose = verbose
+      end
+
+      def import_address(address, run_mode: :system)
+        run "importaddress #{address} '' false", run_mode: run_mode
+      end
+
+      def generate_to_address(address, blocks: 101, run_mode: :system, verbose: false)
+        run "generatetoaddress #{blocks} #{address}"
+      end
+
+      def generate(blocks: 1, run_mode: :system)
+       run "generate #{blocks}"
+      end
+
+      def list_unspent(address, run_mode: :inline)
+        run "listunspent 1 9999 \"[\\\"#{address}\\\"]\"", run_mode: run_mode
+      end
+
+      def send_raw_transaction(rawtx, run_mode: :system)
+        run "sendrawtransaction #{rawtx}", run_mode: run_mode
+      end
+
+      def test_raw_transaction(rawtx, run_mode: :inline)
+        run "testmempoolaccept '[\"#{rawtx}\"]'", run_mode: run_mode
+      end
+
+      def get_block_count
+        run("getblockcount", run_mode: :inline).to_i
+      end
+
+      def get_received_by_address(address)
+        result = run "getreceivedbyaddress #{address}", run_mode: :inline
+        result.strip
+      end
+
+      # private
 
-    def run(args, run_mode: :inline, v: false)
-      cmd = "#{program} -#{network} #{args}"
-      puts "==> #{cmd}"
-      case run_mode
-      when :inline
-        output = `#{cmd}`
-        puts output if v
-        output
-      when :system
-        success = system cmd
-        fail "failed command: #{args}" unless success
-        success
-      when :daemon
-        pid = spawn cmd
-        sleep (ENV['BOOTSTRAP'] || 10).to_i
-        pid
-      else
-        raise "dont know how to run #{run_mode}"
+      def run(args, run_mode: :system, debug: false)
+        cmd = "#{program} -#{network} #{args}"
+        puts "==> #{cmd} run_mode=#{run_mode} verbose=#{debug}" if debug || verbose
+        case run_mode
+        when :inline
+          output = `#{cmd}`
+          puts output if debug || verbose
+          output
+        when :system
+          success = system cmd, out: '/dev/null'
+          fail "failed command: #{args}" unless success
+          success
+        when :daemon
+          pid = spawn cmd
+          sleep (ENV['BOOTSTRAP'] || 10).to_i
+          pid
+        else
+          raise "dont know how to run #{run_mode}"
+        end
       end
     end
   end

data/lib/cryptos/der.rb

@@ -1,23 +1,27 @@
-Der = Struct.new :der, :length, :ri, :rl, :r, :si, :sl, :s, :sighash_type do
-  def initialize(der: 0x30, length: 0x44, ri: 0x02, rl: 0x20, r: nil, si: 0x02, sl: 0x20, s: nil, sighash_type: 0x01)
-    super der, length, ri, rl, r, si, sl, s, sighash_type
-  end
+module Cryptos
+  Der = Struct.new :der, :length, :ri, :rl, :r, :si, :sl, :s, :sighash_type do
+    include Utils::Hashes, Utils::Hexas
 
-  def serialize
-    r_bytes = bignum_to_bytes(r, 32, false)
-    if r_bytes.first & 0x80 == 128
-      r_bytes = [0x00] + r_bytes
-      self.length += 1
-      self.rl += 1
+    def initialize(der: 0x30, length: 0x44, ri: 0x02, rl: 0x20, r: nil, si: 0x02, sl: 0x20, s: nil, sighash_type: 0x01)
+      super der, length, ri, rl, r, si, sl, s, sighash_type
     end
-    byte_to_hex(der) + byte_to_hex(length) +
-      byte_to_hex(ri) + byte_to_hex(rl) + bytes_to_hex(r_bytes) +
-      byte_to_hex(si) + byte_to_hex(sl) + to_hex(bignum_to_bytes(s, 32)) +
-      byte_to_hex(sighash_type)
-  end
 
-  def self.parse(signature)
-    fields = *[signature].pack('H*').unpack('CCCCH66CCH64C')
-    Der.new r: fields[4], s: fields[7], sighash_type: fields[8]
+    def serialize
+      r_bytes = bignum_to_bytes(r, 32, false)
+      if r_bytes.first & 0x80 == 128
+        r_bytes = [0x00] + r_bytes
+        self.length += 1
+        self.rl += 1
+      end
+      byte_to_hex(der) + byte_to_hex(length) +
+        byte_to_hex(ri) + byte_to_hex(rl) + bytes_to_hex(r_bytes) +
+        byte_to_hex(si) + byte_to_hex(sl) + bignum_to_hex(s) +
+        byte_to_hex(sighash_type)
+    end
+
+    def self.parse(signature)
+      fields = *[signature].pack('H*').unpack('CCCCH66CCH64C')
+      Der.new r: fields[4], s: fields[7], sighash_type: fields[8]
+    end
   end
 end

data/lib/cryptos/elliptic_curve.rb

@@ -1,10 +1,12 @@
-module EllipticCurve
-  Group = Struct.new :gx, :gy, :prime, :order, :cofactor
-  Secp256k1 = Group.new 0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798,
-                        0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8,
-                        0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F,
-                        0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141,
-                        1
+module Cryptos
+  module EllipticCurve
+    Group = Struct.new :gx, :gy, :prime, :order, :cofactor
+    Secp256k1 = Group.new 0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798,
+                          0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8,
+                          0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F,
+                          0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141,
+                          1
+  end
 end
 
 EC_Gx = 0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798
@@ -17,6 +19,8 @@ LOW_S = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0
 #
 # Elliptic Curve
 #
+include Cryptos::Utils::Bytes
+
 def extended_euclidean_algorithm(a, b)
   s, old_s = 0, 1
   t, old_t = 1, 0

data/lib/cryptos/input.rb

@@ -1,7 +1,10 @@
 module Cryptos
-  Input = Struct.new :value, :tx_hash, :index, :unlock_script, :sequence do
-    def self.from_utxo(data, index = 0, options = {debug: false})
-      utxo = JSON.parse(data)[index]
+  Input = Struct.new :value, :tx_hash, :index, :script_sig, :sequence do
+    include Utils::Hexas, Utils::Hashes
+
+    def self.from_utxo(cli, address, index = 0, options = {debug: false})
+      utxos = cli.list_unspent address
+      utxo = JSON.parse(utxos)[index]
       puts utxo if options[:debug]
       txid = utxo['txid']
       vout = utxo['vout']
@@ -9,12 +12,20 @@ module Cryptos
       sequence = options[:sequence] || 0xfffffffff
       Input.new amount * 10**8, txid, vout, sequence: sequence
     end
-    def initialize(value, tx_hash, index, unlock_script: '', sequence: 0xfffffffff)
-      super value, tx_hash, index, unlock_script, sequence
+
+    def self.from_tx(transaction, index = 0, options = {})
+      amount = transaction.outputs[index].value
+      sequence = options[:sequence] || 0xfffffffff
+      Input.new amount, transaction.hash, index, sequence: sequence
+    end
+
+    def initialize(value, tx_hash, index, script_sig: nil, sequence: 0xfffffffff)
+      super value, tx_hash, index, script_sig, sequence
     end
+
     def serialize
-      script_hex = script_to_hex(unlock_script)
-      hash_to_hex(tx_hash) + int_to_hex(index) +
+      script_hex = script_sig ? script_sig.to_hex : ''
+      hex_to_little(tx_hash) + int_to_hex(index) +
         byte_to_hex(hex_size(script_hex)) + script_hex + int_to_hex(sequence)
     end
   end

data/lib/cryptos/output.rb

@@ -1,15 +1,24 @@
 module Cryptos
-  Output = Struct.new :value, :lock_script do
+  Output = Struct.new :value, :script_pubkey do
+    include Utils::Hexas
+
     def self.p2pkh(address, amount)
-      output_script = Cryptos::Script.for_address address
+      output_script = Cryptos::Script.p2pkh address
       Output.new amount, output_script
     end
+
+    def self.multisig(a1, a2, amount)
+      redeem_script = Cryptos::Script.multisig a1, a2
+      Output.new amount, Cryptos::Script.p2sh(redeem_script)
+    end
+
     def self.p2pkh_change(address, input, output, fee = 10_000)
       change_value = input.value - output.value - fee
       Output.p2pkh address, change_value
     end
+
     def serialize
-      script_hex = script_to_hex(lock_script)
+      script_hex = script_pubkey.to_hex
       long_to_hex(value) + byte_to_hex(hex_size(script_hex)) + script_hex
     end
   end

data/lib/cryptos/private_key.rb

@@ -4,6 +4,9 @@ module Cryptos
   class PrivateKey
     attr_reader :value, :order
 
+    # Generates new private key
+    # @param group [EllipticCurve::Group] EC group this
+    # @return the private key
     def self.generate(group = EllipticCurve::Secp256k1)
       value = 1 + SecureRandom.random_number(group.order - 1)
       new value, group.order

data/lib/cryptos/public_key.rb

@@ -1,27 +1,27 @@
 module Cryptos
   class PublicKey
-    attr_reader :x, :y, :private_key
+    include Utils::Bytes, Utils::Hexas
 
-    def self.from_pk(private_key)
-      new *ec_multiply(private_key.value, EC_Gx, EC_Gy, EC_p), private_key
-    end
+    attr_reader :x, :y, :private_key
 
-    def initialize(x, y, private_key)
-      @x = x
-      @y = y
+    def initialize(private_key)
       @private_key = private_key
+      @x, @y = *ec_multiply(private_key.value, EC_Gx, EC_Gy, EC_p)
     end
 
     def check!
       (x**3 + 7 - y**2) % EC_p == 0 || raise('public key point is not on the curve')
     end
 
-    def compressed
-      "#{y > 0 ? '02' : '03'}#{x.to_s(16)}"
-    end
-
-    def uncompressed
-      "04#{x.to_s(16)}#{y.to_s(16)}"
+    # Serialize public key as SEC (Standards for Efficient Cryptography) format
+    # @param compressed [true, false] the format to return, either compressed or uncompressed
+    # @return address in SEC format
+    def to_sec(compressed = true)
+      if compressed
+        "#{y.even? ? '02' : '03'}#{x_to_sec}"
+      else
+        "04#{x_to_sec}#{y_to_sec}"
+      end
     end
 
     def coordinates
@@ -31,5 +31,15 @@ module Cryptos
     def to_s
       coordinates.to_s
     end
+
+    private
+
+    def x_to_sec
+      bin_to_hex bignum_to_bytes(x, 32)
+    end
+
+    def y_to_sec
+      bin_to_hex bignum_to_bytes(y, 32)
+    end
   end
 end

data/lib/cryptos/script.rb

@@ -1,20 +1,96 @@
 module Cryptos
   class Script
-    def self.for_address(address)
-      hash160 = address.to_hash160
-      if address.to_s.start_with? '2'
-        "OP_HASH160 #{hash160} OP_EQUAL"
-      else
-        p2pkh hash160
-      end
+    include Utils::Hexas, Utils::Hashes
+
+    OPCODES = {
+      'OP_0' =>  0x00,
+      'OP_1' =>  0x51,
+      'OP_2' =>  0x52,
+      'OP_DUP' =>  0x76,
+      'OP_HASH160' =>  0xA9,
+      'OP_EQUAL' =>  0x87,
+      'OP_EQUALVERIFY' =>  0x88,
+      'OP_CHECKSIG' =>  0xAC,
+      'OP_CHECKMULTISIG' => 0xAE
+    }.freeze
+
+    attr_reader :script
+
+    # scriptSig for pay-to-pubkey-hash outputs
+    # @param der - signature in der format
+    # @param public_key - the public key
+    # @return script - a Script object holding scriptSig
+    def self.sig_pubkey(der, public_key)
+      new "#{der.serialize} #{public_key.to_sec}"
+    end
+
+    # scriptSig for pay-to-multisig-hash outputs
+    def self.sig_multisig(der1, der2, redeem_script)
+      new "OP_0 #{der1.serialize} #{der2.serialize} #{redeem_script.serialize}"
+    end
+
+    def self.p2pkh(address_or_hex)
+      hash160 = if address_or_hex.is_a? String
+                  Address.to_hash160 address_or_hex
+                else
+                  address_or_hex.to_hash160
+                end
+      new "OP_DUP OP_HASH160 #{hash160} OP_EQUALVERIFY OP_CHECKSIG"
+    end
+
+    def self.p2sh(script)
+      new "OP_HASH160 #{script.to_hash160} OP_EQUAL"
+    end
+
+    # multisign redeem script
+    def self.multisig(address1, address2)
+      new "OP_2 #{address1.public_key.to_sec} #{address2.public_key.to_sec} OP_2 OP_CHECKMULTISIG"
+    end
+
+    def self.bare(script)
+      new script
+    end
+
+    def initialize(script)
+      @script = script
+    end
+
+    def to_hash160
+      hash160 to_hex
+    end
+
+    def to_hex
+      @hex ||= to_asm.split.map { |token| token.start_with?('OP') ? opcode(token) : data(token) }.join
+    end
+    alias :serialize :to_hex
+
+    def to_asm
+      script.to_s
+    end
+
+    def to_s
+      to_asm
+    end
+
+    def size
+      [to_hex].pack('H*').size
+    end
+
+    private
+
+    def opcode(token)
+      raise "opcode #{token} not found" unless OPCODES.include?(token)
+      byte_to_hex OPCODES[token]
     end
 
-    def self.for_public(pa)
-      p2pkh Address.to_hash160 pa
+    def data(token)
+      bin_size = data_size token
+      # TODO: data size is defined as 1-9 bytes
+      byte_to_hex(bin_size) + token
     end
 
-    def self.p2pkh(hash160)
-      "OP_DUP OP_HASH160 #{hash160} OP_EQUALVERIFY OP_CHECKSIG"
+    def data_size(token)
+      [token].pack('H*').size
     end
   end
 end

data/lib/cryptos/transaction.rb

@@ -1,8 +1,11 @@
 module Cryptos
   Transaction = Struct.new :version, :inputs, :outputs, :locktime do
+    include Utils::Hexas, Utils::Hashes
+
     def self.from_ioc(input, output, change, version: 1, locktime: 0)
       new version, [input], [output, change], locktime
     end
+
     def serialize
       inputs_hex = inputs.map(&:serialize).join
       outputs_hex = outputs.map(&:serialize).join
@@ -11,33 +14,58 @@ module Cryptos
     end
 
     def hash
-      hash_to_hex sha256(sha256(serialize))
+      hex_to_little sha256(sha256(serialize))
     end
 
-    def signature_hash(lock_script = nil, sighash_type = 0x01)
-      inputs.first.unlock_script = lock_script if lock_script
+    def signature_hash(script_pubkey = nil, sighash_type = 0x01)
+      inputs.first.script_sig = script_pubkey if script_pubkey
       hash = sha256(sha256(serialize + int_to_hex(sighash_type)))
       [hash].pack('H*')
     end
 
-    def sign(private_key, public_key, lock_script, sighash_type = 0x01)
-      bytes_string = signature_hash lock_script, sighash_type
+    def sign(private_key, public_key, script_pubkey, sighash_type = 0x01)
+      bytes_string = signature_hash script_pubkey, sighash_type
       r, s = ecdsa_sign private_key.value, bytes_string
-      der = Der.new r: r, s: s
-      inputs.first.unlock_script = "#{der.serialize} #{public_key.compressed}"
+      der = Cryptos::Der.new r: r, s: s
+      inputs.first.script_sig = Script.sig_pubkey(der, public_key)
       serialize
     end
+
     def sign_input(index, address, sighash_type = 0x01)
-      # TODO: get lock_script from input?
-      lock_script = Cryptos::Script.for_address address
-      bytes_string = signature_hash lock_script, sighash_type
+      # TODO: get script_pubkey from input?
+      script_pubkey = Cryptos::Script.p2pkh address
+      bytes_string = signature_hash script_pubkey, sighash_type
+
       r, s = ecdsa_sign address.public_key.private_key.value, bytes_string
-      der = Der.new r: r, s: s
-      inputs[index].unlock_script = "#{der.serialize} #{address.public_key.compressed}"
+      der = Cryptos::Der.new r: r, s: s
+      inputs[index].script_sig = Script.sig_pubkey der, address.public_key
+
       serialize
     end
+
+    def sign_single_input(address)
+      sign_input 0, address
+    end
+
+    def multi_sign_input(index, address1, address2, sighash_type = 0x01)
+      redeem_script = Cryptos::Script.multisig address1, address2
+      bytes_string = signature_hash redeem_script, sighash_type
+
+      r, s = ecdsa_sign address1.public_key.private_key.value, bytes_string
+      der1 = Cryptos::Der.new r: r, s: s
+      r, s = ecdsa_sign address2.public_key.private_key.value, bytes_string
+      der2 = Cryptos::Der.new r: r, s: s
+      inputs[index].script_sig = Script.sig_multisig der1, der2, redeem_script
+
+      serialize
+    end
+
+    def broadcast(cli)
+      cli.send_raw_transaction serialize
+    end
+
     def to_s
-      "Transaction[inputs:#{inputs.map &:value}, outputs:#{outputs.map &:value}"
+      inputs.to_s + outputs.to_s
     end
   end
 end

data/lib/cryptos/utils/bytes.rb

@@ -0,0 +1,20 @@
+module Cryptos
+  module Utils
+    module Bytes
+      def bytes_to_bignum(bytes_string)
+        bytes_string.bytes.reduce { |n, b| (n << 8) + b }
+      end
+
+      def bignum_to_bytes(n, length=nil, stringify=true)
+        a = []
+        while n > 0
+          a << (n & 0xFF)
+          n >>= 8
+        end
+        a.fill 0x00, a.length, length - a.length if length
+        bytes = a.reverse
+        stringify ? bytes.pack('C*') : bytes
+      end
+    end
+  end
+end

data/lib/cryptos/utils/hashes.rb

@@ -0,0 +1,21 @@
+require 'digest'
+
+module Cryptos
+  module Utils
+    module Hashes
+      def sha256(data)
+        Digest::SHA256.hexdigest([data].pack('H*'))
+      end
+
+      def hash160(data)
+        sha256 = Digest::SHA256.digest([data].pack('H*'))
+        Digest::RMD160.hexdigest sha256
+      end
+
+      def hash256(data)
+        sha256 = Digest::SHA256.digest([data].pack('H*'))
+        Digest::SHA256.hexdigest sha256
+      end
+    end
+  end
+end

data/lib/cryptos/utils/hexas.rb

@@ -0,0 +1,39 @@
+module Cryptos
+  module Utils
+    module Hexas
+      include Bytes
+
+      def bin_to_hex(binary_bytes)
+        binary_bytes.unpack('H*').first
+      end
+
+      def byte_to_hex(value)
+        bin_to_hex [value].pack('C')
+      end
+
+      def bytes_to_hex(value)
+        bin_to_hex value.pack('C*')
+      end
+
+      def int_to_hex(value)
+        bin_to_hex [value].pack('V')
+      end
+
+      def long_to_hex(value)
+        bin_to_hex [value].pack('Q<')
+      end
+
+      def bignum_to_hex(value, size = 32)
+        bin_to_hex bignum_to_bytes(value, size)
+      end
+
+      def hex_to_little(value)
+        bin_to_hex [value].pack('H*').reverse
+      end
+
+      def hex_size(hex)
+        [hex].pack('H*').size
+      end
+    end
+  end
+end

data/lib/cryptos/version.rb

@@ -1,3 +1,3 @@
 module Cryptos
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cryptos
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Iulian Costan
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-11-26 00:00:00.000000000 Z
+date: 2018-12-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -108,6 +108,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bump
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: The easiest way to craft your own transactions for multiple crypto currencies
 email:
 - iulian.costan@gmail.com
@@ -127,11 +155,11 @@ files:
 - Rakefile
 - TODOs.org
 - bin/console
+- bin/run
 - bin/setup
 - cryptos.gemspec
 - lib/cryptos.rb
 - lib/cryptos/address.rb
-- lib/cryptos/base.rb
 - lib/cryptos/base58.rb
 - lib/cryptos/bitcoin.rb
 - lib/cryptos/bitcoin/address.rb
@@ -141,7 +169,6 @@ files:
 - lib/cryptos/der.rb
 - lib/cryptos/deribit/client.rb
 - lib/cryptos/elliptic_curve.rb
-- lib/cryptos/hashing.rb
 - lib/cryptos/input.rb
 - lib/cryptos/litecoin.rb
 - lib/cryptos/litecoin/address.rb
@@ -150,6 +177,9 @@ files:
 - lib/cryptos/public_key.rb
 - lib/cryptos/script.rb
 - lib/cryptos/transaction.rb
+- lib/cryptos/utils/bytes.rb
+- lib/cryptos/utils/hashes.rb
+- lib/cryptos/utils/hexas.rb
 - lib/cryptos/version.rb
 homepage: https://github.com/icostan/cryptos
 licenses: []

data/lib/cryptos/base.rb

@@ -1,74 +0,0 @@
-require 'json'
-require 'digest'
-
-class Struct
-  OPCODES = {
-    'OP_DUP' =>  0x76,
-    'OP_HASH160' =>  0xA9,
-    'OP_EQUAL' =>  0x87,
-    'OP_EQUALVERIFY' =>  0x88,
-    'OP_CHECKSIG' =>  0xAC
-  }.freeze
-
-  def opcode(token)
-    raise "opcode #{token} not found" unless OPCODES.include?(token)
-    OPCODES[token].to_s 16
-  end
-
-  def data(token)
-    bin_size = hex_size token
-    # TODO: data size is defined as 1-9 bytes
-    byte_to_hex(bin_size) + token
-  end
-
-  def hex_size(hex)
-    [hex].pack('H*').size
-  end
-
-  def to_hex(binary_bytes)
-    binary_bytes.unpack('H*').first
-  end
-
-  def hash_to_hex(value)
-    to_hex [value].pack('H*').reverse
-  end
-
-  def int_to_hex(value)
-    to_hex [value].pack('V')
-  end
-
-  def byte_to_hex(value)
-    to_hex [value].pack('C')
-  end
-
-  def bytes_to_hex(bytes)
-    to_hex bytes.pack('C*')
-  end
-
-  def long_to_hex(value)
-    to_hex [value].pack('Q<')
-  end
-
-  def script_to_hex(script_string)
-    script_string.split.map { |token| token.start_with?('OP') ? opcode(token) : data(token) }.join
-  end
-
-  def sha256(hex)
-    Digest::SHA256.hexdigest([hex].pack('H*'))
-  end
-end
-
-def bytes_to_bignum(bytes_string)
-  bytes_string.bytes.reduce { |n, b| (n << 8) + b }
-end
-
-def bignum_to_bytes(n, length=nil, stringify=true)
-  a = []
-  while n > 0
-    a << (n & 0xFF)
-    n >>= 8
-  end
-  a.fill 0x00, a.length, length - a.length if length
-  bytes = a.reverse
-  stringify ? bytes.pack('C*') : bytes
-end

data/lib/cryptos/hashing.rb

@@ -1,13 +0,0 @@
-require 'digest'
-
-module Hashing
-  def hash160(data)
-    sha256 = Digest::SHA256.digest([data].pack('H*'))
-    Digest::RMD160.hexdigest sha256
-  end
-
-  def hash256(data)
-    sha256 = Digest::SHA256.digest([data].pack('H*'))
-    Digest::SHA256.hexdigest sha256
-  end
-end