tierion 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c55375f17cd7d97c88eb2121cae9b144d061a48d
-  data.tar.gz: bb6d9e026c6efb40e5d41c801cc8d9a9bbafff81
+  metadata.gz: 7a6c61dbd6130591ba0ae23a7fa8845a8b2a4c8f
+  data.tar.gz: d7023dcf234d38ae0b383eb51ab5480d69427c41
 SHA512:
-  metadata.gz: 938e14d5a7fb6e19fbc2edeeab3933dc85ea7c67b1718263134fd3767085ae8e221fccceed4cb39ad62cb40dca85ff8e702b97e3cb3f61a28c4f0876440406e1
-  data.tar.gz: 36fd4e48acc7e5efa0cfec1535380ba93e82fc052b391940ac9ea6cad90a8b9a81cfd50a7a02b6114119cf67c0ec605f36ba37545f88fcf7d5a08b03a774e738
+  metadata.gz: 39443a1eca9208226af6a56587ba863df0428a94f647c6d82dac1cdd122109c8a192fc7fa1034e6fb11f3c72780b8d0e9bc5a0e58774ffd8447516fa3b7d3b29
+  data.tar.gz: 1060b935d65af04add356b0679f327cf6ce1175fc6d61cf18f93d4b3c073d4c63fbbd5e97811a81f8e366e97e6c63df8fe418fcc380dfb2bfae5bc28c02a2e30

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # CHANGELOG
 
+## v1.0.0 (8/5/2016)
+
+- Refactor Ruby API to better match the Client, HashItem, Receipt, Confirmation hierarchy.
+- Support newly release Chainpoint 2.0 Blockchain receipts
+- Drop support for Chainpoint 1.0
+
 ## v0.1.0 (8/1/2016)
 
 This is the initial ALPHA quality release.

data/README.md

@@ -25,19 +25,21 @@ Shell commands start with a `$`, Ruby console commands start with `>`.
 Instantiate a new API client
 
 ```
-> t = Tierion::Hashitem.new('me@example.com', 'mypassword')
+> t = Tierion::HashApi::Client.new('me@example.com', 'mypassword')
 ```
 
 You can also set the username and password in environment
-variables.
+variables...
 
 ```
 $ export TIERION_USERNAME=me@example.com
 $ export TIERION_PASSWORD=my_pass
 ```
 
+... and call it without hardcoding your credentials.
+
 ```
-> t = Tierion::Hashitem.new
+> t = Tierion::HashApi::Client.new
 ```
 
 Create the hash you want to record on the blockchain
@@ -48,93 +50,159 @@ and send it.
 => "2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae">
 
 > t.send(my_hash)
-=> Tierion::HashitemReceipt ...
+=> Tierion::HashApi::HashItem ...
 ```
 
-Examine the array of `HashitemReceipt` objects stored in the
-client. This is the only place to find the hash item
-ID's. You probably want to store these somewhere in your DB
-since this client is ephemeral and there is no way to
-retrieve these ID's later.
+Now you can take a look at the Array of `HashItem`s.
 
 ```
-> t.receipts
-=> [Tierion::HashitemReceipt..., Tierion::HashitemReceipt ...]
+> t.hash_items
+=> [Tierion::HashApi::HashItem ..., Tierion::HashApi::HashItem ...]
 ```
 
-Get one HashitemReceipt to work on
+Within the `Tierion::HashApi::HashItem` objects is the only place you
+can find the hash item ID's for hashes you've sent. You will probably want
+to store these somewhere in your DB since this client instance is ephemeral
+and there is no way to retrieve these ID's later.
+
+Let's grab a single `Tierion::HashApi::HashItem` to work on:
 
 ```
-> h = t.receipts.first
+> h = t.hash_items.first
 ```
 
-For convenience you can use `Hashitem#time` to get
-the timestamp as a `Time` object (UTC time)
+By default the `HashItem#timestamp` value is an Integer representing
+the seconds since the UNIX epoch. For convenience you can use `HashItem#time` to get the `timestamp` as a Ruby `Time` object (UTC time).
 
 ```
+> h.timestamp
+=> 1470448435
 > h.time
-=> 2016-08-01 17:56:11 UTC
+=> 2016-08-06 01:53:55 UTC
 ```
 
-You can retrieve an individual `BlockchainReceipt` by
-passing a `HashitemReceipt` as the arg to `Hashitem#blockchain_receipt`
+You can retrieve an individual `Tierion::HashApi::Receipt`
+for this `HashItem` by passing the `Hashitem` instance as
+an arg to `Client#receipt`
 
 ```
-> t.blockchain_receipt(h)
-=> Tierion::BlockchainReceipt ...
+> t.receipt(h)
+=> Tierion::HashApi::Receipt ...
 ```
 
-Or, call `Hashitem#blockchain_receipts` to loop through
-each `HashitemReceipt` submitted in this session
-and collect `BlockchainReceipts` for each from the
-API.
+Or, call `Client#receipts` to loop through each `Hashitem`
+submitted in this session and collect and cache `Receipts`
+for each from the API.
 
-Remember that these are not available until
-processed and sent to the blockchain so you may need to
-call this again later to populate this Array fully.
+Remember that `Receipt`s are not available until
+processed and sent to the blockchain so you may need
+to call this again to get the `Reciept` for every `HashItem`.
 
 ```
-> t.blockchain_receipts
-=> [Tierion::BlockchainReceipt..., Tierion::BlockchainReceipt ...]
+> t.receipts
+=> [Tierion::HashApi::Receipt ..., Tierion::HashApi::Receipt ...]
 ```
 
-Get one `BlockchainReceipt` to work on
+Get one `Tierion::HashApi::Receipt` to work on
 
 ```
-> b = t.blockchain_receipts.first
-=> Tierion::BlockchainReceipt ...
+> r = t.receipts.first
+=> Tierion::HashApi::Receipt ...
 ```
 
-A `BlockchainReceipt` object has a number of properties
-which are populated from the API.
+A `Tierion::HashApi::Receipt` object has a number of properties
+which are populated from the API. Here is an example:
 
 ```
-> b.header
-> b.target
-> b.extra
-
-# The URL's that are generated for confirming this txn on the blockchain.
-> b.confirmation_url
-> b.confirmation_url_json
+> r = t.receipts.first
+=> {
+  "@context"=>"https://w3id.org/chainpoint/v2",
+  "type"=>"ChainpointSHA256v2",
+  "targetHash"=>"2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae",
+  "merkleRoot"=>"326c0c924a162c8637b8fa392add7c8c98f64f5194f3d2591caf88d7b0b956bd",
+  "proof"=>[
+    {
+      "left"=>"c108bfba805d899faa0ef53b0c064fad650249f6a648fec2bc79fd563106b1f8"
+    }
+  ],
+  "anchors"=>[
+    {
+      "type"=>"BTCOpReturn",
+      "sourceId"=>"579dce214fe0242e3397c9a988622f35b5ee91cef5068b0895a0bbe2c7797b9a"
+    }
+  ]
+}
 ```
 
-You can also query whether the transaction associated
-with a `BlockchainReceipt` has actually been confirmed on the
-blockchain. Once confirmed a data structure from the
-third-party `blockchain.info` API will also be populated
-with the full transaction data.
+The `Receipt` returns `anchors` which represent one or more trust
+anchors where your hash has been stored. Currently, the only `anchor`
+returned is `BTCOpReturn` which also gives you a `sourceId`
+attribute. This represents the Bitcoin blockchain's OP_RETURN anchor,
+with the `sourceId` representing the BTC transaction ID.
 
-`BlockchainReceipt`s can take quite a while to be confirmed.
+You can also query whether the transaction associated with a `Receipt`
+has actually been confirmed on a trust anchor with a call to
+`Receipt#confirmations`. This will query each supported trust anchor
+to determine whether or not the expected hash can be found. This depends
+on an API call to a different third-party site for each anchor. This call
+will return a hash with the supported trust anchors as the key and a `Boolean` to indicate if the confirmation was successful for that anchor.
 
+`Receipt`s can take quite a while to be confirmed. Possibly several hours.
+So, be patient.
+
+```
+> r.confirmations
+=> {"BTCOpReturn"=>true}
 ```
-> b.confirmed?
-=> true
 
-# A hash of data from the blockchain.info API
-> b.blockchain_info_confirmation
-=> { ... }
+You can of course also manually confirm that a hash is
+visible at the Transaction ID (`sourceId`) appropriate
+for your trust anchor. For example, for Bitcoin you can
+search for the `sourceId` at a URL like:
+
+[https://blockchain.info/tx/579dce214fe0242e3397c9a988622f35b5ee91cef5068b0895a0bbe2c7797b9a](https://blockchain.info/tx/579dce214fe0242e3397c9a988622f35b5ee91cef5068b0895a0bbe2c7797b9a)
+
+Or just paste the transaction ID into the search field at [https://blockchain.info](https://blockchain.info).
+
+Once you are looking at the transaction info page, you want to
+look for the `OP_RETURN` part of the page, and your hash should be
+there, with a `326c` prefix followed by the 32 byte (64 hex characters)
+hash value you originally submitted. The prefix represents the hex values
+`0x32` and `0x6c` which are the OP_RETURN special code, and the byte length in hex of the OP_RETURN value (your hash).
+
+You can get a pretty JSON representation of the `Receipt` by calling
+the `Receipt#to_pretty_json` method.
+
+```
+> r.to_pretty_json
+{
+  "@context": "https://w3id.org/chainpoint/v2",
+  "type": "ChainpointSHA256v2",
+  "targetHash": "2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae",
+  "merkleRoot": "326c0c924a162c8637b8fa392add7c8c98f64f5194f3d2591caf88d7b0b956bd",
+  "proof": [
+    {
+      "left": "c108bfba805d899faa0ef53b0c064fad650249f6a648fec2bc79fd563106b1f8"
+    }
+  ],
+  "anchors": [
+    {
+      "type": "BTCOpReturn",
+      "sourceId": "579dce214fe0242e3397c9a988622f35b5ee91cef5068b0895a0bbe2c7797b9a"
+    }
+  ]
+}
 ```
 
+You can validate this JSON representation of the receipt by
+submitting it to the [Tierion validation](https://tierion.com/validate)
+web page.
+
+## TODO
+
+- Add blockchain receipt subscription functionality.
+
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then,

data/Rakefile

@@ -5,6 +5,8 @@ Rake::TestTask.new(:test) do |t|
   t.libs << 'test'
   t.libs << 'lib'
   t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = false
+  t.warning = false
 end
 
 task default: :test

data/lib/tierion.rb

@@ -7,8 +7,4 @@ require 'httparty'
 require 'hashie'
 
 require 'tierion/version'
-require 'tierion/hashitem'
-require 'tierion/hashitem_receipt'
-require 'tierion/blockchain_receipt'
-require 'tierion/blockchain_receipt_header'
-require 'tierion/blockchain_receipt_target'
+require 'tierion/hash_api'

data/lib/tierion/hash_api.rb

@@ -0,0 +1,3 @@
+require 'tierion/hash_api/client'
+require 'tierion/hash_api/hash_item'
+require 'tierion/hash_api/receipt'

data/lib/tierion/hash_api/client.rb

@@ -0,0 +1,145 @@
+module Tierion
+  module HashApi
+    class Client
+      include ::HTTParty
+      base_uri 'https://hashapi.tierion.com/v1'
+
+      default_timeout 5
+      open_timeout 5
+      # debug_output $stdout
+
+      attr_accessor :hash_items
+
+      def initialize(uname = ENV['TIERION_USERNAME'], pwd = ENV['TIERION_PASSWORD'])
+        @auth = { username: uname, password: pwd }
+        @access_token = nil
+        @expires_at = Time.now.utc - 1
+        @refresh_token = nil
+        @hash_items = []
+        auth
+      end
+
+      def auth
+        options = { body: @auth }
+        response = self.class.post('/auth/token', options)
+
+        if response.success?
+          extract_auth_tokens(response)
+        else
+          raise_error(response)
+        end
+      end
+
+      def auth_refresh
+        if expired_auth?
+          options = { body: { 'refreshToken' => @refresh_token } }
+          response = self.class.post('/auth/refresh', options)
+
+          if response.success?
+            extract_auth_tokens(response)
+          else
+            raise_error(response)
+          end
+        else
+          auth
+        end
+      end
+
+      def send(hash)
+        unless hash =~ /^[a-f0-9]{64}$/
+          raise ArgumentError, 'is not a valid SHA256 hex hash string'
+        end
+
+        auth_refresh unless logged_in?
+        options = {
+          body: { 'hash' => hash },
+          headers: { 'Authorization' => "Bearer #{@access_token}" }
+        }
+        response = self.class.post('/hashitems', options)
+
+        if response.success?
+          parsed = response.parsed_response
+          Hashie.symbolize_keys!(parsed)
+          parsed.merge!({hash: hash})
+          h = Tierion::HashApi::HashItem.new(parsed)
+          @hash_items << h
+          return h
+        else
+          raise_error(response)
+        end
+      end
+
+      # Get a Receipt for each HashItem that doesn't have one
+      # and return the collection of Receipts.
+      def receipts
+        @hash_items.each do |h|
+          next if h.receipt.present?
+          h.receipt = receipt(h)
+        end
+
+        @hash_items.collect(&:receipt).compact
+      end
+
+      # Retrieve the receipt for a specific HashItem
+      def receipt(h)
+        unless h.is_a?(Tierion::HashApi::HashItem)
+          raise ArgumentError, 'is not a Tierion::HashApi::HashItem object'
+        end
+
+        auth_refresh unless logged_in?
+        options = { headers: { 'Authorization' => "Bearer #{@access_token}" } }
+        response = self.class.get("/receipts/#{h.id}", options)
+
+        if response.success? && response.parsed_response['receipt'].present?
+          receipt = JSON.parse(response.parsed_response['receipt'])
+          Hashie.symbolize_keys!(receipt)
+
+          if receipt.key?(:type) || receipt.key?('@type')
+            Tierion::HashApi::Receipt.new(receipt)
+          else
+            raise 'Invalid Receipt found'
+          end
+        else
+          return nil
+        end
+      end
+
+      def logged_in?
+        @access_token.present? &&
+          @refresh_token.present? &&
+          @expires_at >= Time.now.utc
+      end
+
+      private
+
+      def raise_error(response)
+        if response['error'].present?
+          raise response['error']
+        else
+          raise 'Unknown Fatal Error'
+        end
+      end
+
+
+      def expired_auth?
+        @access_token.present? &&
+          @refresh_token.present? &&
+          @expires_at < Time.now.utc
+      end
+
+      def extract_auth_tokens(resp)
+        if resp &&
+           resp.parsed_response &&
+           resp.parsed_response.is_a?(Hash) &&
+           resp.parsed_response.key?('access_token') &&
+           resp.parsed_response.key?('refresh_token') &&
+           resp.parsed_response.key?('expires_in')
+          @access_token = resp.parsed_response['access_token']
+          @refresh_token = resp.parsed_response['refresh_token']
+          @expires_at = Time.now.utc + resp.parsed_response['expires_in']
+          return true
+        end
+      end
+    end
+  end
+end

data/lib/tierion/hash_api/hash_item.rb

@@ -0,0 +1,16 @@
+module Tierion
+  module HashApi
+    class HashItem < Hashie::Dash
+      include Hashie::Extensions::Dash::PropertyTranslation
+
+      property :hash, required: true
+      property :id, from: :receiptId, required: true
+      property :timestamp, required: true
+      property :receipt, required: false, default: nil
+
+      def time
+        timestamp.is_a?(Integer) ? Time.at(timestamp).utc : nil
+      end
+    end
+  end
+end

data/lib/tierion/hash_api/receipt.rb

@@ -0,0 +1,62 @@
+module Tierion
+  module HashApi
+    class Receipt < Hash
+      include Hashie::Extensions::MergeInitializer
+      include Hashie::Extensions::MethodAccess
+      include Hashie::Extensions::IndifferentAccess
+
+      def to_pretty_json
+        puts JSON.pretty_generate(self)
+      end
+
+      def confirmations
+        get_confirmations
+        @confs
+      end
+
+      private
+
+      def get_confirmations
+        @confs = {} if @confs.blank?
+
+        return {} if anchors.blank?
+
+        anchors.each do |a|
+          # allready confirmed this anchor
+          next if @confs[a['type']].is_a?(TrueClass)
+
+          case a['type']
+          when 'BTCOpReturn'
+            # txn_id
+            if a['sourceId'].present?
+              @confs[a['type']] = btc_op_return_confirmed?(a['sourceId'])
+            end
+          end
+        end
+
+        @confs
+      end
+
+      # Confirm Bitcoin OP_RETURN anchor
+      def btc_op_return_confirmed?(source_id)
+        url = "https://blockchain.info/tx-index/#{source_id}?format=json"
+
+        # op_return values begin with 0x6a (op_return code) &
+        # 0x20 (length in hex : 32 bytes)
+        op_return = ['6a20', merkleRoot].join('')
+
+        response = HTTParty.get(url)
+
+        if response.success? && response['out'].present?
+          has_op_return = response['out'].any? do |o|
+            o['script'].present? && o['script'] == op_return
+          end
+
+          return has_op_return
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/tierion/version.rb

@@ -1,3 +1,3 @@
 module Tierion
-  VERSION = '0.1.0'
+  VERSION = '1.0.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tierion
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Glenn Rempe
@@ -30,7 +30,7 @@ cert_chain:
   zieXiXZSAojfFx9g91fKdIrlPbInHU/BaCxXSLBwvOM0drE+c2ue9X8gB55XAhzX
   37oBiw==
   -----END CERTIFICATE-----
-date: 2016-08-02 00:00:00.000000000 Z
+date: 2016-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -154,11 +154,10 @@ files:
 - certs/gem-public_cert_grempe.pem
 - exe/tierion
 - lib/tierion.rb
-- lib/tierion/blockchain_receipt.rb
-- lib/tierion/blockchain_receipt_header.rb
-- lib/tierion/blockchain_receipt_target.rb
-- lib/tierion/hashitem.rb
-- lib/tierion/hashitem_receipt.rb
+- lib/tierion/hash_api.rb
+- lib/tierion/hash_api/client.rb
+- lib/tierion/hash_api/hash_item.rb
+- lib/tierion/hash_api/receipt.rb
 - lib/tierion/version.rb
 - tierion.gemspec
 homepage: https://github.com/grempe/tierion

data/lib/tierion/blockchain_receipt.rb

@@ -1,62 +0,0 @@
-module Tierion
-  class BlockchainReceipt < Hashie::Dash
-    include Hashie::Extensions::Dash::PropertyTranslation
-
-    property :header, required: true, transform_with: ->(v) {
-      BlockchainReceiptHeader.new(v)
-    }
-
-    property :target, required: true, transform_with: ->(v) {
-      BlockchainReceiptTarget.new(v)
-    }
-
-    property :extra, required: false, default: []
-
-    property :blockchain_info_confirmation, required: false, default: nil
-
-    # Output clean JSON in a format that works with the Blockchain
-    # Receipt validator at https://tierion.com/validate
-    def to_pretty_json
-      puts JSON.pretty_generate(self)
-    end
-
-    # Recalculate the merkle tree to ensure the receipt is valid
-    def valid?
-      # TODO
-    end
-
-    # Make an API call to check if the tx_id is a confirmed Transaction
-    # on the Blockchain and contains the expected OP_RETURN value with
-    # the merkle_root from this receipt.
-    def confirmed?
-      return false if header.blank? || header.tx_id.blank?
-      return false if header.merkle_root.blank?
-      response = HTTParty.get(confirmation_url_json)
-
-      if response.success? && response['out'].present?
-        # op_return values begin with 0x6a (op_return code) &
-        # 0x20 (hex length in bytes of string)
-        expected_op_return_value = ['6a20', header.merkle_root].join('')
-        confirmed = response['out'].any? do |o|
-          o['script'].present? && o['script'] == expected_op_return_value
-        end
-
-        # store the parsed output from blockchain.info
-        self.blockchain_info_confirmation = response.parsed_response if confirmed
-        return confirmed
-      else
-        false
-      end
-    end
-
-    def confirmation_url
-      return nil if header.blank? || header.tx_id.blank?
-      "https://blockchain.info/tx-index/#{header.tx_id}"
-    end
-
-    def confirmation_url_json
-      return nil if header.blank? || header.tx_id.blank?
-      "#{confirmation_url}?format=json"
-    end
-  end
-end

data/lib/tierion/blockchain_receipt_header.rb

@@ -1,11 +0,0 @@
-module Tierion
-  class BlockchainReceiptHeader < Hashie::Dash
-    include Hashie::Extensions::Dash::PropertyTranslation
-
-    property :chainpoint_version, required: true
-    property :hash_type, required: true
-    property :merkle_root, required: true
-    property :tx_id, required: true
-    property :timestamp, required: true
-  end
-end

data/lib/tierion/blockchain_receipt_target.rb

@@ -1,9 +0,0 @@
-module Tierion
-  class BlockchainReceiptTarget < Hashie::Dash
-    include Hashie::Extensions::Dash::PropertyTranslation
-
-    property :target_hash, required: true
-    property :target_proof, required: true
-    property :target_uri, required: false
-  end
-end

data/lib/tierion/hashitem.rb

@@ -1,138 +0,0 @@
-module Tierion
-  class Hashitem
-    include ::HTTParty
-    base_uri 'https://hashapi.tierion.com/v1'
-
-    default_timeout 5
-    open_timeout 5
-    # debug_output $stdout
-
-    attr_reader :receipts
-    attr_accessor :debug
-
-    def initialize(uname = ENV['TIERION_USERNAME'], pwd = ENV['TIERION_PASSWORD'])
-      @auth = { username: uname, password: pwd }
-      @access_token = nil
-      @expires_at = Time.now.utc - 1
-      @refresh_token = nil
-      @receipts = []
-      auth
-    end
-
-    def auth
-      options = { body: @auth }
-      response = self.class.post('/auth/token', options)
-
-      if response.success?
-        extract_auth_tokens(response)
-      else
-        raise_error(response)
-      end
-    end
-
-    def auth_refresh
-      if expired_auth?
-        options = { body: { 'refreshToken' => @refresh_token } }
-        response = self.class.post('/auth/refresh', options)
-
-        if response.success?
-          extract_auth_tokens(response)
-        else
-          raise_error(response)
-        end
-      else
-        auth
-      end
-    end
-
-    def send(hash)
-      unless hash =~ /^[a-f0-9]{64}$/
-        raise ArgumentError, 'is not a valid SHA256 hex hash string'
-      end
-
-      auth_refresh unless logged_in?
-      options = {
-        body: { 'hash' => hash },
-        headers: { 'Authorization' => "Bearer #{@access_token}" }
-      }
-      response = self.class.post('/hashitems', options)
-
-      if response.success?
-        parsed = response.parsed_response
-        Hashie.symbolize_keys!(parsed)
-        hir = HashitemReceipt.new(parsed)
-        @receipts << hir
-        return hir
-      else
-        raise_error(response)
-      end
-    end
-
-    # Retrieve and store the BlockchainReceipt from the API for each
-    # HashitemReceipt that does not have one.
-    def blockchain_receipts
-      @receipts.each do |hir|
-        next if hir.blockchain_receipt.is_a?(Tierion::BlockchainReceipt)
-        bcr = blockchain_receipt(hir)
-        hir.blockchain_receipt = bcr
-      end
-
-      @receipts.collect(&:blockchain_receipt).compact
-    end
-
-    # Retrieve the blockchain receipt for a specific HashitemReceipt ID
-    def blockchain_receipt(hir)
-      unless hir.is_a?(Tierion::HashitemReceipt)
-        raise ArgumentError, 'is not a HashitemReceipt object'
-      end
-
-      auth_refresh unless logged_in?
-      options = { headers: { 'Authorization' => "Bearer #{@access_token}" } }
-      response = self.class.get("/receipts/#{hir.id}", options)
-
-      if response.success? && response.parsed_response['receipt'].present?
-        receipt = JSON.parse(response.parsed_response['receipt'])
-        Hashie.symbolize_keys!(receipt)
-        BlockchainReceipt.new(receipt)
-      else
-        return nil
-      end
-    end
-
-    private
-
-    def raise_error(response)
-      if response['error'].present?
-        raise response['error']
-      else
-        raise 'Unknown Fatal Error'
-      end
-    end
-
-    def logged_in?
-      @access_token.present? &&
-        @refresh_token.present? &&
-        @expires_at >= Time.now.utc
-    end
-
-    def expired_auth?
-      @access_token.present? &&
-        @refresh_token.present? &&
-        @expires_at < Time.now.utc
-    end
-
-    def extract_auth_tokens(resp)
-      if resp &&
-         resp.parsed_response &&
-         resp.parsed_response.is_a?(Hash) &&
-         resp.parsed_response.key?('access_token') &&
-         resp.parsed_response.key?('refresh_token') &&
-         resp.parsed_response.key?('expires_in')
-        @access_token = resp.parsed_response['access_token']
-        @refresh_token = resp.parsed_response['refresh_token']
-        @expires_at = Time.now.utc + resp.parsed_response['expires_in']
-        return true
-      end
-    end
-  end
-end

data/lib/tierion/hashitem_receipt.rb

@@ -1,13 +0,0 @@
-module Tierion
-  class HashitemReceipt < Hashie::Dash
-    include Hashie::Extensions::Dash::PropertyTranslation
-
-    property :id, from: :receiptId, required: true
-    property :timestamp, required: true
-    property :blockchain_receipt, required: false, default: nil
-
-    def time
-      timestamp.is_a?(Integer) ? Time.at(timestamp).utc : nil
-    end
-  end
-end