keoken 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 23b1ae2d3240583fad89b5acaad6923edd0daedc1b24a99c906ebed1d7c8fb4b
-  data.tar.gz: a39bfbafdad72692b19424b536d3818bae2847b905e344b2ba37a3f9d514573e
+  metadata.gz: 910f95d9e5c38b7bd38a3931b31172285811a45d0dcfdbd280d0c9f86c177a8c
+  data.tar.gz: f6d5dbc887a6bb374da47157dcede765a4f236f2d241058b9e9bd3e08b60e196
 SHA512:
-  metadata.gz: 509d886950b38bea4f0ebd1a5522354b634f46824caee6df85f2a89e9f95445d17f651c91141944332fd1eeb529828386cc300fbc32853258c1ec0face1a8ba9
-  data.tar.gz: 4bc290015e815d72b52a6e952e3df2a6fc86f0d7345a568844dca6bedb5a032c6e5e5fb131be22aab64fc46ca19413d2feca51fd6b058525061475a32ec631ed
+  metadata.gz: a3b15901f51755d600d766fab2c96c4a0e42b2722368d763d27a4930761882060f5ab2d7f9f053e1639c3cc841bf862b6556c9cb0fd8214c0a0211a13bb8667c
+  data.tar.gz: a0c828852eb3b6929c39b78e9454add080bb142b708bff5c60488eec17b5ffeb6f015f74a994e8aaf0e5ab2ae046bb43571e2343a2ea9fe31b5d75c4ed32c5b8

data/.rubocop.yml

@@ -0,0 +1,2 @@
+Metrics/LineLength:
+  Max: 120

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    keoken (0.1.0)
+    keoken (0.1.1)
       bitcoin-ruby (~> 0.0.18)
 
 GEM

data/README.md

@@ -22,17 +22,17 @@ Or install it yourself as:
 
 ## Usage
 
+It uses bitcoin-ruby, but you can use Trezor or Electrum, the most important command is the script,
+which you can obtain with token.hex,
+then you can send it as an output with a scriptPubKey and a value of 0.
+In order to crate a token you need two outputs,
+the change address with an amount less than original (for fees)
+and the other one for the script. To send money you need three outputs,
+the change address, the address who owns the recipient token and the script.
+
 ### Create token and send it to the blockchain
 
 ```ruby
-# It uses bitcoin-ruby, but you can use Trezor or Electrum, the most important command is the script,
-# which you can obtain with token.hex,
-# then you can send it as an output with a scriptPubKey and a value of 0.
-# In order to crate a token you need two outputs,
-# the change address with an amount less than original (for fees)
-# and the other one for the script. To send money you need three outputs,
-# the change address, the address who owns the recipient token and the script.
-
 Bitcoin.network = :testnet3
 token = Keoken::Token.new(name: "test-keoken-bitex")
 token.create(1_000_000)

data/lib/keoken/backend/base.rb

@@ -0,0 +1,55 @@
+module Keoken
+  module Backend
+    class Base
+      attr_accessor :inputs, :bitprim_transaction
+
+      def initialize
+        @inputs = []
+        @bitprim_transaction = Keoken::Bitprim::Transaction.new
+      end
+
+      protected
+
+      def build_inputs(address)
+        utxos = bitprim_transaction.utxos(address)
+        utxos.each do |utxo|
+          txid = utxo['txid']
+          transaction = bitprim_transaction.tx(txid)
+          outputs = transaction['vout'].select do |vout|
+            addresses = vout['scriptPubKey']['addresses']
+            if addresses
+              addresses.any? { |vout_address| vout_address == address }
+            end
+          end
+          raise Keoken::OutputNotFound if outputs.empty?
+          output = outputs.first
+          @inputs.push(
+            tx_id: txid,
+            position: output['n'],
+            input_script: output['scriptPubKey']['hex'],
+            input_amount: output['value'].sub!(/\./, '').sub!(/^0+/, '').to_i
+          )
+        end
+      end
+
+      def build_fee(type)
+        total = @inputs.map { |input| input[:input_amount].to_i }.inject(:+)
+        estimate_fee = @bitprim_transaction.estimate_fee.to_f
+        [total,
+         ((10 + 149 * @inputs.length + 35 * output_length(type)) * estimate_fee)
+           .to_s[0..9].sub!(/\./, '').sub!(/0+/, '')]
+      end
+
+      private
+
+      def output_length(type)
+        case type
+        when :create
+          2
+        when :send
+          3
+        end
+      end
+    end
+  end
+end

data/lib/keoken/backend/bitcoin_ruby/transaction.rb

@@ -1,9 +1,9 @@
 module Keoken
   module Backend
     module BitcoinRuby
-      class Transaction
+      class Transaction < Keoken::Backend::Base
         attr_accessor :to_json, :raw
-        extend Bitcoin::Builder
+        include Bitcoin::Builder
 
         # Create the transaction to broadcast in order to create tokens.
         #
@@ -13,7 +13,7 @@ module Keoken
         #
         # @return [Keoken::Backend::BitcoinRuby::Transaction] An object instanciated with the transaction to broadcast.
         #
-        def self.build_for_creation(address, key, script)
+        def build_for_creation(address, key, script)
           build(address, nil, key, script, :create)
         end
 
@@ -26,7 +26,7 @@ module Keoken
         #
         # @return [Keoken::Backend::BitcoinRuby::Transaction] An object instanciated with the transaction to broadcast.
         #
-        def self.build_for_send_amount(address, address_dest, key, script)
+        def build_for_send_amount(address, address_dest, key, script)
           build(address, address_dest, key, script, :send)
         end
 
@@ -40,39 +40,17 @@ module Keoken
         #
         # @return [Keoken::Backend::BitcoinRuby::Transaction] An object instanciated with the transaction to broadcast.
         #
-        def self.build(address, addr2, key, script, type)
-          bitprim_transaction = Keoken::Bitprim::Transaction.new
-          utxos = bitprim_transaction.utxos(address)
-          inputs = []
-          utxos.each do |utxo|
-            txid = utxo['txid']
-            transaction = bitprim_transaction.tx(txid)
-            outputs = transaction['vout'].select do |vout|
-              addresses = vout['scriptPubKey']['addresses']
-              if addresses
-                addresses.any? { |vout_address| vout_address == address }
-              end
-            end
-            raise Keoken::OutputNotFound if outputs.empty?
-            output = outputs.first
-            inputs.push(
-              tx_id: txid,
-              position: output['n'],
-              input_script: output['scriptPubKey']['hex'],
-              input_amount: output['value'].sub!(/\./, '').sub!(/^0+/, '').to_i
-            )
-          end
-          total = inputs.map { |input| input[:input_amount].to_i }.inject(:+)
-          estimate_fee = bitprim_transaction.estimate_fee.to_f
-          fee = ((10 + 149 * inputs.length + 35 * output_length(type)) * estimate_fee).to_s[0..9].sub!(/\./, '').sub!(/0+/, '')
+        def build(address, addr2, key, script, type)
+          build_inputs(address)
+          total, fee = build_fee(type)
           case type
           when :create
             output_amount = total - fee.to_i
-            create(inputs, output_amount, key.addr, key, script)
+            create(@inputs, output_amount, key.addr, key, script)
           when :send
             output_amount = total - (fee.to_i * 2)
             output_amount_to_addr2 = fee.to_i
-            send_amount(inputs, output_amount, key.addr, output_amount_to_addr2, addr2, key, script)
+            send_amount(@inputs, output_amount, key.addr, output_amount_to_addr2, addr2, key, script)
           end
         end
 
@@ -86,8 +64,7 @@ module Keoken
         #
         # @return [Keoken::Backend::BitcoinRuby::Transaction] An object instanciated with the transaction to broadcast.
         #
-        def self.create(inputs, output_amount, output_address, key, script)
-          token = new
+        def create(inputs, output_amount, output_address, key, script)
           tx = build_tx do |t|
             inputs.each do |input|
               t.input do |i|
@@ -106,9 +83,9 @@ module Keoken
               o.to(script, :custom)
             end
           end
-          token.to_json = tx.to_json
-          token.raw = tx.to_payload.bth
-          token
+          @to_json = tx.to_json
+          @raw = tx.to_payload.bth
+          self
         end
 
         # Create the transaction to broadcast in order to send amount between tokens.
@@ -123,8 +100,7 @@ module Keoken
         #
         # @return [Keoken::Backend::BitcoinRuby::Transaction] An object instanciated with the transaction to broadcast.
         #
-        def self.send_amount(inputs, output_amount, output_address, output_amount_to_addr2, addr2, key, script)
-          token = self.new
+        def send_amount(inputs, output_amount, output_address, output_amount_to_addr2, addr2, key, script)
           tx = build_tx do |t|
             inputs.each do |input|
               t.input do |i|
@@ -149,18 +125,9 @@ module Keoken
               o.to(script, :custom)
             end
           end
-          token.to_json = tx.to_json
-          token.raw = tx.to_payload.bth
-          token
-        end
-
-        def self.output_length(type)
-          case type
-          when :create
-            2
-          when :send
-            3
-          end
+          @to_json = tx.to_json
+          @raw = tx.to_payload.bth
+          self
         end
       end
     end

data/lib/keoken/backend/trezor/transaction.rb

@@ -0,0 +1,100 @@
+module Keoken
+  module Backend
+    module Trezor
+      class Transaction < Keoken::Backend::Base
+        attr_accessor :to_json
+
+        # Create the transaction to broadcast in order to create tokens.
+        #
+        # @param address [String] Address that will contain the token.
+        # @param path [Array] Address derivation path.
+        # @param script [String] The token script.
+        #
+        # @return [Keoken::Backend::Trezor::Transaction] A serialized object ready for Trezor signing.
+        #
+        def build_for_creation(address, path, script)
+          build_inputs(address)
+          total, fee = build_fee(type)
+          output_amount = total - fee.to_i
+          create(@inputs, path, address, output_amount, script)
+        end
+
+        # Create the transaction to broadcast in order to send amount between tokens.
+        #
+        # @param address [String] Address that will contain the token.
+        # @param address_dest [String] Address to receive the tokens.
+        # @param path [Array] Address derivation path.
+        # @param script [String] The token script.
+        #
+        # @return [Keoken::Backend::Trezor::Transaction] A serialized object ready for Trezor signing.
+        #
+        def build_for_send_amount(address, address_dest, path, script)
+          build_inputs(address)
+          total, fee = build_fee(type)
+          output_amount = total - (fee.to_i * 2)
+          output_amount_to_addr2 = fee.to_i
+          send(@inputs, path, output_amount, address, output_amount_to_addr2, address_dest, script)
+        end
+
+        private
+
+        def create(inputs, path, address, output_amount, script)
+          {
+            inputs: 
+              inputs.map do |input|
+                {
+                  address_n: path,
+                  prev_index: input[:position],
+                  prev_hash: input[:tx_id],
+                  amount: input[:input_amount]
+                }
+              end,
+            outputs: [
+              {
+                address: address,
+                amount: output_amount,
+                script_type: 'PAYTOADDRESS'
+              },
+              {
+                op_return_data: script,
+                amount: '0',
+                script_type: 'PAYTOOPRETURN'
+              }
+            ]
+          }
+        end
+
+        def send(inputs, path, output_amount, address, output_amount_to_addr2, addr2, script)
+          {
+            inputs: 
+              inputs.map do |input|
+                {
+                  address_n: path,
+                  prev_index: input[:position],
+                  prev_hash: input[:tx_id],
+                  amount: input[:input_amount]
+                }
+              end,
+            outputs: [
+              {
+                address: address,
+                amount: output_amount,
+                script_type: 'PAYTOADDRESS'
+              },
+              {
+                address: addr2,
+                amount: output_amount_to_addr2,
+                script_type: 'PAYTOADDRESS'
+              },
+              {
+                op_return_data: script,
+                amount: '0',
+                script_type: 'PAYTOOPRETURN'
+              }
+            ]
+          }
+        end
+      end
+    end
+  end
+end

data/lib/keoken/errors/data_not_parsed.rb

@@ -0,0 +1,7 @@
+module Keoken
+  class DataNotParsed < StandardError
+    def initialize(msg = 'Data can not be parsed')
+      super
+    end
+  end
+end

data/lib/keoken/parser.rb

@@ -0,0 +1,53 @@
+module Keoken
+  class Parser
+    attr_accessor :data, :transaction_type, :name, :amount
+    def initialize(script)
+      binary = script.htb
+      @data  = binary.bytes
+    end
+
+    def prefix
+      result = @data.slice!(0)
+      raise Keoken::DataNotParsed, 'OP_RETURN missing' unless result == Bitcoin::Script::OP_RETURN.to_i
+      result = @data.slice!(0)
+      raise Keoken::DataNotParsed, 'Prefix size missing' unless result == Keoken::PREFIX_SIZE.to_i
+      result = @data.slice!(0..Keoken::PREFIX.htb.bytes.length - 1)
+      raise Keoken::DataNotParsed, 'Prefix not provided' unless result == Keoken::PREFIX.htb.bytes
+      bytesize = @data.slice!(0)
+      raise Keoken::DataNotParsed, 'Bytesize not provided' unless bytesize == @data.length
+    end
+
+    def set_transaction_type
+      result = @data.slice!(0..3).join
+      @transaction_type = if result == Keoken::TYPE_CREATE_ASSET
+        :create
+      elsif result == Keoken::TYPE_SEND_TOKEN
+        :send
+      else
+        raise Keoken::DataNotParsed, 'Transaction type not valid'
+      end
+      @transaction_type
+    end
+
+    def name_or_id
+      name = []
+      end_of_name = false
+      loop do
+        tmp = @data.slice!(0)
+        end_of_name ||= tmp > 0
+        next if tmp.zero? && !end_of_name
+        break if tmp.zero? && end_of_name
+        name.push tmp
+      end
+      if @transaction_type == :create
+        name.map { |n| n.to_s(16).htb }.join
+      elsif @transaction_type == :send
+        name.map { |n| n.to_s(16) }.join
+      end
+    end
+
+    def amount
+      @data.map { |byte| byte.zero? ? "#{byte}0" : byte.to_s }.join.to_i
+    end
+  end
+end

data/lib/keoken/token.rb

@@ -1,6 +1,6 @@
 module Keoken
   class Token
-    attr_accessor :hex, :name, :id
+    attr_accessor :data_script, :name, :id, :amount, :transaction_type
 
     # Creates a new token object.
     #
@@ -9,8 +9,8 @@ module Keoken
     # @option options [Number] :id The id of token to obtain an amount to send to another address.
     #
     def initialize(options = {})
-      @name = options[:name]
-      @id = options[:id]
+      @name   = options[:name]
+      @id     = options[:id]
     end
 
     # Generate the script to create a token.
@@ -21,17 +21,13 @@ module Keoken
     #
     def create(amount)
       raise Keoken::NameNotFound unless @name
-      data_script =
-        [Keoken::VERSION_NODE,
-         Keoken::TYPE_CREATE_ASSET,
-         name_to_hex(@name),
-         Keoken::PREFIX_BYTE_AMOUNT[0..(Keoken::AMOUNT_SIZE - amount.to_s.length - 1)] + amount.to_s].flatten.join
-      data_length = data_script.htb.bytesize.to_s(16)
-
-      @hex = [Bitcoin::Script::OP_RETURN.to_s(16),
-              Keoken::PREFIX_SIZE,
-              Keoken::PREFIX,
-              data_length].join + data_script
+      @data_script =
+        [
+          Keoken::VERSION_NODE,
+          Keoken::TYPE_CREATE_ASSET,
+          name_to_hex(@name),
+          Keoken::PREFIX_BYTE_AMOUNT[0..prefix_length(amount)] + amount.to_s
+        ].flatten.join
       self
     end
 
@@ -43,25 +39,77 @@ module Keoken
     #
     def send_amount(amount)
       raise Keoken::IdNotFound unless @id
-      data_script =
-        [Keoken::VERSION_NODE,
-         Keoken::TYPE_SEND_TOKEN,
-         Keoken::PREFIX_BYTE_ASSET_ID[0..(Keoken::ASSET_ID_SIZE - @id.to_s.length - 1)] + @id.to_s,
-         Keoken::PREFIX_BYTE_AMOUNT[0..(Keoken::AMOUNT_SIZE - amount.to_s.length - 1)] + amount.to_s].flatten.join
+      asset_length = Keoken::ASSET_ID_SIZE - @id.to_s.length - 1
+      @data_script =
+        [
+          Keoken::VERSION_NODE,
+          Keoken::TYPE_SEND_TOKEN,
+          Keoken::PREFIX_BYTE_ASSET_ID[0..asset_length] + @id.to_s,
+          Keoken::PREFIX_BYTE_AMOUNT[0..prefix_length(amount)] + amount.to_s
+        ].flatten.join
+      self
+    end
 
-      data_length = data_script.htb.bytesize.to_s(16)
+    # Hexadecimal value of script.
+    #
+    # @return [String] Hexadecimal value of script token.
+    def hex
+      [
+        Bitcoin::Script::OP_RETURN.to_s(16),
+        Keoken::PREFIX_SIZE,
+        Keoken::PREFIX,
+        data_length
+      ].join + @data_script
+    end
 
-      @hex = [Bitcoin::Script::OP_RETURN.to_s(16),
-              Keoken::PREFIX_SIZE,
-              Keoken::PREFIX,
-              data_length].join + data_script
-      self
+    # JSON serialization of object
+    #
+    # return [String] JSON serialization of token object.
+    def to_json
+      {
+        id: @id,
+        name: @name,
+        amount: @amount,
+        transaction_type: @transaction_type
+      }.to_json
+    end
+
+    # Deserialization of object
+    #
+    # return [Hash] Deserialization of token object.
+    def to_hash
+      {
+        id: @id,
+        name: @name,
+        amount: @amount,
+        transaction_type: @transaction_type
+      }
+    end
+
+    def parse_script(script)
+      parser = Keoken::Parser.new(script)
+      parser.prefix
+      @transaction_type = parser.set_transaction_type
+      if @transaction_type == :create
+        @name = parser.name_or_id
+      else
+        @id = parser.name_or_id
+      end
+      @amount = parser.amount
     end
 
     private
 
+    def data_length
+      @data_script.htb.bytesize.to_s(16)
+    end
+
+    def prefix_length(amount)
+      Keoken::AMOUNT_SIZE - amount.to_s.length - 1
+    end
+
     def name_to_hex(name)
-      asset_bytes = name.bytes.map{|n| n.to_s(16)}
+      asset_bytes = name.bytes.map { |n| n.to_s(16) }
       asset_bytes + ['00']
     end
   end

data/lib/keoken/version.rb

@@ -1,3 +1,3 @@
 module Keoken
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'.freeze
 end

data/lib/keoken.rb

@@ -2,19 +2,22 @@ require 'bitcoin'
 
 require 'keoken/extensions/bitcoin/script'
 require 'keoken/token'
+require 'keoken/parser'
+require 'keoken/backend/base'
 require 'keoken/backend/bitcoin_ruby/transaction'
 require 'keoken/bitprim/transaction'
 require 'keoken/errors/id_not_found'
 require 'keoken/errors/name_not_found'
+require 'keoken/errors/data_not_parsed'
 
 module Keoken
-  PREFIX_SIZE = '04'
-  PREFIX = '00004b50'
-  VERSION_NODE = '0000'
-  TYPE_CREATE_ASSET = '0000'
-  TYPE_SEND_TOKEN = '0001'
-  PREFIX_BYTE_AMOUNT = '0000000000000000'
+  PREFIX_SIZE = '04'.freeze
+  PREFIX = '00004b50'.freeze
+  VERSION_NODE = '0000'.freeze
+  TYPE_CREATE_ASSET = '0000'.freeze
+  TYPE_SEND_TOKEN = '0001'.freeze
+  PREFIX_BYTE_AMOUNT = '0000000000000000'.freeze
   AMOUNT_SIZE = 16
-  PREFIX_BYTE_ASSET_ID = '00000000'
+  PREFIX_BYTE_ASSET_ID = '00000000'.freeze
   ASSET_ID_SIZE = 8
 end

data/spec/keoken_spec.rb

@@ -1,11 +1,11 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Keoken do
-  it "has a version number" do
+  it 'has a version number' do
     expect(Keoken::VERSION).not_to be nil
   end
 
-  it "defines keoken constants" do
+  it 'defines keoken constants' do
     expect(Keoken::PREFIX_SIZE).not_to be nil
     expect(Keoken::PREFIX).not_to be nil
     expect(Keoken::VERSION_NODE).not_to be nil
@@ -17,33 +17,67 @@ describe Keoken do
     expect(Keoken::ASSET_ID_SIZE).not_to be nil
   end
 
-  it "creates the test-keoken token" do
-    token = Keoken::Token.new(name: "test-keoken")
+  it 'creates the test-keoken token' do
+    token = Keoken::Token.new(name: 'test-keoken')
     token.create(1_000_000)
     expect(token.hex).to(
-      eq("6a0400004b501800000000746573742d6b656f6b656e000000000001000000")
+      eq('6a0400004b501800000000746573742d6b656f6b656e000000000001000000')
     )
   end
 
-  it "raise an error when name is not provided" do
+  it 'serialize the test-keoken token' do
+    token = Keoken::Token.new
+    token.parse_script('6a0400004b501800000000746573742d6b656f6b656e000000000001000000')
+    expect(token.to_json).to(
+      eq('{"id":null,"name":"test-keoken","amount":1000000,"transaction_type":"create"}')
+    )
+  end
+
+  it 'deserialize the test-keoken token' do
+    token = Keoken::Token.new
+    token.parse_script('6a0400004b501800000000746573742d6b656f6b656e000000000001000000')
+    expect(token.to_hash).to(
+      eq(
+        amount: 1_000_000,
+        name: 'test-keoken',
+        id: nil,
+        transaction_type: :create
+      )
+    )
+  end
+
+  it 'deserialize the token with id' do
+    token = Keoken::Token.new
+    token.parse_script('6a0400004b501000000001000000340000000001000000')
+    expect(token.to_hash).to(
+      eq(
+        amount: 1_000_000,
+        name: nil,
+        id: '34',
+        transaction_type: :send
+      )
+    )
+  end
+
+  it 'raise an error when name is not provided' do
     token = Keoken::Token.new
     expect { token.create(1_000_000) }.to raise_error(Keoken::NameNotFound)
   end
 
-  it "raise an error when id is not provided" do
+  it 'raise an error when id is not provided' do
     token = Keoken::Token.new
     expect { token.send_amount(1_000_000) }.to raise_error(Keoken::IdNotFound)
   end
 
-  it "send 1_000_000 to token with 34 id" do
+  it 'send 1_000_000 to token with 34 id' do
     token = Keoken::Token.new(id: 34)
     token.send_amount(1_000_000)
     expect(token.hex).to(
-      eq("6a0400004b501000000001000000340000000001000000")
+      eq('6a0400004b501000000001000000340000000001000000')
     )
   end
 
-  describe "creates token" do
+  describe 'creates token' do
     before(:each) do
       mock_requests
       Bitcoin.network = :testnet3
@@ -51,7 +85,8 @@ describe Keoken do
       token.create(1_000_000)
       key = Bitcoin::Key.from_base58('cShKfHoHVf6iKKZym18ip1MJFQFxJwbcLxW53MQikxdDsGd2oxBU')
       script = token.hex
-      @transaction_token = Keoken::Backend::BitcoinRuby::Transaction.build_for_creation(key.addr, key, script)
+      @transaction_token = Keoken::Backend::BitcoinRuby::Transaction.new
+      @transaction_token.build_for_creation(key.addr, key, script)
     end
 
     it "format to_json" do
@@ -72,22 +107,26 @@ describe Keoken do
       )
     end
 
-    it "raw transaction" do
+    it 'raw transaction' do
       raw = @transaction_token.raw
-      expect(raw).to start_with("0100000001dae8143d5422d5e1018c43732baa74ac3114d4399a1f58a9ea7e31f656938a44010000006")
-      expect(raw).to end_with("6a0400004b501800000000746573742d6b656f6b656e00000000000100000000000000")
+      expect(raw).to start_with('0100000001dae8143d5422d5e1018c43732baa74ac3114d4399a1f58a9ea7e31f656938a44010000006')
+      expect(raw).to end_with('6a0400004b501800000000746573742d6b656f6b656e00000000000100000000000000')
     end
 
-    it "broadcast transaction" do
-      stub_request(:post, "https://tbch.blockdozer.com/insight-api/tx/send")
-        .with(:body => {"rawtx" => /0100000001dae8143d5422d5e1018c43732baa74ac3114d4399a1f58a9ea7e31f656938a44010000006/},
-              headers: {
-                "Accept" => "*/*",
-                "Accept-Encoding" => "gzip;q=1.0,deflate;q=0.6,identity;q=0.3",
-                "Content-Type" => "application/x-www-form-urlencoded",
-                "Host" => "tbch.blockdozer.com",
-                "User-Agent" => "Ruby",
-              })
+    it 'broadcast transaction' do
+      stub_request(:post, 'https://tbch.blockdozer.com/insight-api/tx/send')
+        .with(
+          body:
+           {
+             'rawtx' => /0100000001dae8143d5422d5e1018c43732baa74ac3114d4399a1f58a9ea7e31f656938a44010000006/ 
+           },
+          headers: {
+            "Accept" => "*/*",
+            "Accept-Encoding" => "gzip;q=1.0,deflate;q=0.6,identity;q=0.3",
+            "Content-Type" => "application/x-www-form-urlencoded",
+            "Host" => "tbch.blockdozer.com",
+            "User-Agent" => "Ruby",
+          })
         .to_return(status: 200, body: "{\"txid\":\"f410c773d079327b8283c175b08a84faa6ffcfbde40b5939b85f07f0dfde2eb8\"}", headers: {})
       transaction = Keoken::Bitprim::Transaction.new
       expect(transaction.send_tx(@transaction_token.raw)).to eq({"txid" => "f410c773d079327b8283c175b08a84faa6ffcfbde40b5939b85f07f0dfde2eb8"})
@@ -104,7 +143,8 @@ describe Keoken do
       token.send_amount(500_000)
       key = Bitcoin::Key.from_base58('cShKfHoHVf6iKKZym18ip1MJFQFxJwbcLxW53MQikxdDsGd2oxBU')
       script = token.hex
-      @transaction_token = Keoken::Backend::BitcoinRuby::Transaction.build_for_send_amount(key.addr, 'mnTd41YZ1e1YqsaPNJh3wkeSUrFvp1guzi', key, script)
+      @transaction_token = Keoken::Backend::BitcoinRuby::Transaction.new
+      @transaction_token.build_for_send_amount(key.addr, 'mnTd41YZ1e1YqsaPNJh3wkeSUrFvp1guzi', key, script)
     end
 
     it "format to_json" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: keoken
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Bitex
@@ -116,6 +116,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".rubocop.yml"
 - ".travis.yml"
 - ".yardoc/checksums"
 - ".yardoc/complete"
@@ -153,13 +154,17 @@ files:
 - doc/top-level-namespace.html
 - keoken.gemspec
 - lib/keoken.rb
+- lib/keoken/backend/base.rb
 - lib/keoken/backend/bitcoin_ruby/transaction.rb
+- lib/keoken/backend/trezor/transaction.rb
 - lib/keoken/bitprim/config.yaml
 - lib/keoken/bitprim/transaction.rb
+- lib/keoken/errors/data_not_parsed.rb
 - lib/keoken/errors/id_not_found.rb
 - lib/keoken/errors/name_not_found.rb
 - lib/keoken/errors/output_not_found.rb
 - lib/keoken/extensions/bitcoin/script.rb
+- lib/keoken/parser.rb
 - lib/keoken/token.rb
 - lib/keoken/version.rb
 - spec/keoken_spec.rb