btcruby 0.0.0 → 1.0.0

data/lib/btcruby/open_assets/asset_transaction_builder.rb

@@ -0,0 +1,418 @@
+# Note: additional files are required in the bottom of the file.
+
+# High-level Transaction Builder for OpenAssets protocol.
+# https://github.com/OpenAssets/open-assets-protocol/blob/master/specification.mediawiki
+module BTC
+  # TODO:
+  # - provide Asset ID(s) as input, or raw AssetTransactionInput objects
+  # - provide raw unspents to pay mining fees
+  # - provide asset change address
+  # - provide btc change address
+  # - provide issuance API, transfer API, payment API (plain btc outputs)
+  # Use TransactionBuilder internally.
+  class AssetTransactionBuilder
+
+    # Network to validate provided addresses against.
+    # Default value is `Network.default`.
+    attr_accessor :network
+
+    # Must be a subclass of a BTC::BitcoinPaymentAddress
+    attr_accessor :bitcoin_change_address
+
+    # Must be a subclass of a BTC::AssetAddress
+    attr_accessor :asset_change_address
+
+    # Enumerable yielding BTC::TransactionOutput instances with valid `transaction_hash` and `index` properties.
+    # If not specified, `bitcoin_unspent_outputs_provider` is used if possible.
+    attr_accessor :bitcoin_unspent_outputs
+
+    # Enumerable yielding BTC::AssetTransactionOutput instances with valid `transaction_hash` and `index` properties.
+    attr_accessor :asset_unspent_outputs
+
+    # Provider of the pure bitcoin unspent outputs adopting TransactionBuilder::Provider.
+    # If not specified, `bitcoin_unspent_outputs` must be provided.
+    attr_accessor :bitcoin_provider
+
+    # Provider of the pure bitcoin unspent outputs adopting AssetTransactionBuilder::Provider.
+    # If not specified, `asset_unspent_outputs` must be provided.
+    attr_accessor :asset_provider
+
+    # TransactionBuilder::Signer for all the inputs (bitcoins and assets).
+    # If not provided, inputs will be left unsigned and `result.unsigned_input_indexes` will contain indexes of these inputs.
+    attr_accessor :signer
+
+    # Miner's fee per kilobyte (1000 bytes).
+    # Default is Transaction::DEFAULT_FEE_RATE
+    attr_accessor :fee_rate
+
+    # Metadata to embed in the marker output. Default is nil (empty string).
+    attr_accessor :metadata
+
+    def initialize
+    end
+
+    def asset_unspent_outputs=(unspents)
+      self.asset_provider = Provider.new{|atxbuilder| unspents }
+    end
+
+    # Adds an issuance of some assets.
+    # If `script` is specified, it is used to create an intermediate base transaction.
+    # If `output` is specified, it must be a valid spendable output with `transaction_id` and `index`.
+    #   It can be regular TransactionOutput or verified AssetTransactionOutput.
+    # `amount` must be > 0 - number of units to be issued
+    def issue_asset(source_script: nil, source_output: nil,
+                    amount: nil,
+                    script: nil, address: nil)
+      raise ArgumentError, "Either `source_script` or `source_output` must be specified" if !source_script && !source_output
+      raise ArgumentError, "Both `source_script` and `source_output` cannot be specified" if source_script && source_output
+      raise ArgumentError, "Either `script` or `address` must be specified" if !script && !address
+      raise ArgumentError, "Both `script` and `address` cannot be specified" if script && address
+      raise ArgumentError, "Amount must be greater than zero" if !amount || amount <= 0
+      if source_output && (!source_output.index || !source_output.transaction_hash)
+        raise ArgumentError, "If `source_output` is specified, it must have valid `transaction_hash` and `index` attributes"
+      end
+      script ||= AssetAddress.parse(address).script
+
+      # Ensure source output is a verified asset output.
+      if source_output
+        if source_output.is_a?(AssetTransactionOutput)
+          raise ArgumentError, "Must be verified asset output to spend" if !source_output.verified?
+        else
+          source_output = AssetTransactionOutput.new(transaction_output: source_output, verified: true)
+        end
+      end
+
+      # Set either the script or output only once.
+      # All the remaining issuances must use the same script or output.
+      if !self.issuing_asset_script && !self.issuing_asset_output
+        self.issuing_asset_script = source_script
+        self.issuing_asset_output = source_output
+      else
+        if self.issuing_asset_script != source_script || self.issuing_asset_output != source_output
+          raise ArgumentError, "Can't issue more assets from a different source script or source output"
+        end
+      end
+      self.issued_assets << {amount: amount, script: script}
+    end
+
+    # Adds a transfer output.
+    # May override per-builder unspents/provider/change address to allow multi-user swaps.
+    def transfer_asset(asset_id: nil,
+                       amount: nil,
+                       script: nil, address: nil,
+                       provider: nil, unspent_outputs: nil, change_address: nil)
+      raise ArgumentError, "AssetID must be provided" if !asset_id
+      raise ArgumentError, "Either `script` or `address` must be specified" if !script && !address
+      raise ArgumentError, "Both `script` and `address` cannot be specified" if script && address
+      raise ArgumentError, "Amount must be greater than zero" if !amount || amount <= 0
+
+      provider = Provider.new{|atxbuilder| unspent_outputs } if unspent_outputs
+      change_address = AssetAddress.parse(change_address) if change_address
+
+      asset_id = AssetID.parse(asset_id)
+      script ||= AssetAddress.parse(address).script
+
+      self.transferred_assets << {asset_id: asset_id, amount: amount, script: script, provider: provider, change_address: change_address}
+    end
+
+    # Adds a normal payment output. Typically used for transfer
+    def send_bitcoin(output: nil, amount: nil, script: nil, address: nil)
+      if !output
+        raise ArgumentError, "Either `script` or `address` must be specified" if !script && !address
+        raise ArgumentError, "Amount must be specified (>= 0)" if (!amount || amount < 0)
+        script ||= address.public_address.script if address
+        output = TransactionOutput.new(value: amount, script: script)
+      end
+      self.bitcoin_outputs << output
+    end
+
+    def bitcoin_change_address=(addr)
+      @bitcoin_change_address = BitcoinPaymentAddress.parse(addr)
+    end
+
+    def asset_change_address=(addr)
+      @asset_change_address = AssetAddress.parse(addr)
+    end
+
+    def build
+
+      validate_bitcoin_change_address!
+      validate_asset_change_address!
+
+      result = Result.new
+
+      # We don't count assets_cost because outputs of these txs
+      # will be consumed in the next transaction. Only add the fees.
+      if self.issuing_asset_script
+        issuing_tx, unsigned_input_indexes = make_transaction_for_issues
+        result.fee = issuing_tx.fee
+        result.transactions << issuing_tx
+        result.unsigned_input_indexes << unsigned_input_indexes
+        self.issuing_asset_output = AssetTransactionOutput.new(transaction_output: issuing_tx.outputs.first, verified: true)
+      end
+
+      # Prepare the target transaction
+      txbuilder = make_transaction_builder
+      if result.transactions.size > 0
+        txbuilder.parent_transactions = [result.transactions.last]
+      end
+      txbuilder.prepended_unspent_outputs ||= []
+      txbuilder.outputs = []
+
+      # Add issuance input and outputs first.
+
+      consumed_asset_outputs = [] # used in inputs
+      issue_outputs = []
+      transfer_outputs = []
+
+      if self.issued_assets.size > 0
+        txbuilder.prepended_unspent_outputs << self.issuing_asset_output.transaction_output
+        self.issued_assets.each do |issue|
+          atxo = make_asset_transaction_output(asset_id: issuing_asset_id, amount: issue[:amount], script: issue[:script])
+          issue_outputs << atxo
+        end
+      end
+
+      # Move all transfers of the asset ID used on the issuing output to the top of the list.
+      asset_id_on_the_issuing_input = self.issuing_asset_output ? self.issuing_asset_output.asset_id : nil
+      if asset_id_on_the_issuing_input
+        aid = asset_id_on_the_issuing_input.to_s
+        self.transferred_assets = self.transferred_assets.sort do |a,b|
+          # move the asset id used in the issue input to the top
+          if a[:asset_id].to_s == aid
+            -1
+          elsif b[:asset_id] == aid
+            1
+          else
+            0 # keep the order
+          end
+        end
+      end
+
+      consumed_outpoints = {} # "txid:index" => true
+
+      self.transferred_assets.each do |transfer| # |aid,transfers|
+        asset_id = transfer[:asset_id]
+        transfers = [transfer]
+        amount_required = 0
+        amount_provided = 0
+        if asset_id_on_the_issuing_input.to_s == asset_id.to_s
+          amount_provided = self.issuing_asset_output.value
+        end
+
+        atxo = make_asset_transaction_output(asset_id: transfer[:asset_id],
+                                             amount: transfer[:amount],
+                                             script: transfer[:script])
+        amount_required += atxo.value
+        transfer_outputs << atxo
+
+        # Fill in enough unspent assets for this asset_id.
+        # Use per-transfer provider if it's specified. Otherwise use global provider.
+        provider = transfer[:provider] || self.asset_provider
+        unspents = provider.asset_unspent_outputs(asset_id: asset_id, amount: amount_required).dup
+
+        while amount_provided < amount_required
+          autxo = unspents.shift
+          if !autxo
+            raise InsufficientFundsError, "Not enough outputs for asset #{asset_id.to_s} (#{amount_provided} available < #{amount_required} required)"
+          end
+          if !consumed_outpoints[oid = autxo.transaction_output.outpoint_id]
+            # Only apply outputs with matching asset ids.
+            if autxo.asset_id == asset_id
+              raise ArgumentError, "Must be verified asset outputs to spend" if !autxo.verified?
+              consumed_outpoints[oid] = true
+              amount_provided += autxo.value
+              consumed_asset_outputs << autxo
+              txbuilder.prepended_unspent_outputs << autxo.transaction_output
+            end
+          end
+        end
+
+        # If the difference is > 0, add a change output
+        change = amount_provided - amount_required
+        if change > 0
+          # Use per-transfer change address if it's specified. Otherwise use global change address.
+          change_addr = transfer[:change_address] || self.asset_change_address
+          atxo = make_asset_transaction_output(asset_id: asset_id,
+                                               amount: change,
+                                               script: change_addr.script)
+          transfer_outputs << atxo
+        end
+
+      end # each transfer
+
+      # If we have an asset on the issuance input and it is never used in any transfer,
+      # then we need to create a change output just for it.
+      if asset_id_on_the_issuing_input && self.issuing_asset_output.value > 0
+        if !self.transferred_assets.map{|dict| dict[:asset_id].to_s }.uniq.include?(asset_id_on_the_issuing_input.to_s)
+          atxo = make_asset_transaction_output(asset_id: self.issuing_asset_output.asset_id,
+                                               amount: self.issuing_asset_output.value,
+                                               script: self.asset_change_address.script)
+          transfer_outputs << atxo
+        end
+      end
+
+      all_asset_outputs = (issue_outputs + transfer_outputs)
+      result.assets_cost = all_asset_outputs.inject(0){|sum, atxo| sum + atxo.transaction_output.value }
+      marker = AssetMarker.new(quantities: all_asset_outputs.map{|atxo| atxo.value }, metadata: self.metadata)
+
+      # Now, add underlying issues, marker and transfer outputs
+      issue_outputs.each do |atxo|
+        txbuilder.outputs << atxo.transaction_output
+      end
+      txbuilder.outputs << marker.output
+      transfer_outputs.each do |atxo|
+        txbuilder.outputs << atxo.transaction_output
+      end
+
+      txresult = txbuilder.build
+      tx = txresult.transaction
+      atx = AssetTransaction.new(transaction: tx)
+
+      BTC::Invariant(atx.outputs.size == all_asset_outputs.size + 1 + (txresult.change_amount > 0 ? 1 : 0),
+        "Must have all asset outputs (with marker output and optional change output)");
+
+      if txresult.change_amount > 0
+        plain_change_output = atx.outputs.last
+        BTC::Invariant(!plain_change_output.verified?, "Must have plain change output not verified");
+        BTC::Invariant(!plain_change_output.asset_id, "Must have plain change output not have asset id");
+        BTC::Invariant(!plain_change_output.value, "Must have plain change output not have asset amount");
+        plain_change_output.verified = true # to match the rest of outputs.
+      end
+
+      # Provide color info for each input
+      consumed_asset_outputs.each_with_index do |atxo, i|
+        atx.inputs[i].asset_id = atxo.asset_id
+        atx.inputs[i].value = atxo.value
+        atx.inputs[i].verified = true
+      end
+      atx.inputs[consumed_asset_outputs.size..-1].each do |input|
+        input.asset_id = nil
+        input.value = nil
+        input.verified = true
+      end
+
+      # Provide color info for each output
+      issue_outputs.each_with_index do |aout1, i|
+        aout = atx.outputs[i]
+        aout.asset_id = aout1.asset_id
+        aout.value = aout1.value
+        aout.verified = true
+      end
+      atx.outputs[issue_outputs.size].verified = true # make marker verified
+      offset = 1 + issue_outputs.size # +1 for marker
+      transfer_outputs.each_with_index do |aout1, i|
+        aout = atx.outputs[i + offset]
+        aout.asset_id = aout1.asset_id
+        aout.value = aout1.value
+        aout.verified = true
+      end
+      offset = 1 + issue_outputs.size + transfer_outputs.size # +1 for marker
+      atx.outputs[offset..-1].each do |aout|
+        aout.asset_id = nil
+        aout.value = nil
+        aout.verified = true
+      end
+
+      if txresult.change_amount == 0
+        atx.outputs.each do |aout|
+          if !aout.marker?
+            BTC::Invariant(aout.verified?, "Must be verified");
+            BTC::Invariant(!!aout.asset_id, "Must have asset id");
+            BTC::Invariant(aout.value && aout.value > 0, "Must have some asset amount");
+          end
+        end
+      end
+
+      result.unsigned_input_indexes << txresult.unsigned_input_indexes
+      result.transactions << tx
+      result.asset_transaction = atx
+
+      result
+    end
+
+    # Helpers
+
+    def issuing_asset_id
+      @issuing_asset_id ||= AssetID.new(script: @issuing_asset_script || @issuing_asset_output.transaction_output.script)
+    end
+
+    def make_asset_transaction_output(asset_id: nil, amount: nil, script: nil)
+      txout = make_output_for_asset_script(script)
+      AssetTransactionOutput.new(transaction_output: txout, asset_id: asset_id, value: amount, verified: true)
+    end
+
+    def make_transaction_for_issues
+      raise "Sanity check" if !self.issuing_asset_script
+      txbuilder = make_transaction_builder
+      txbuilder.outputs = [
+        make_output_for_asset_script(self.issuing_asset_script)
+      ]
+      result = txbuilder.build
+      [result.transaction, result.unsigned_input_indexes]
+    end
+
+    def make_output_for_asset_script(script)
+      txout = BTC::TransactionOutput.new(value: MAX_MONEY, script: script)
+      txout.value = txout.dust_limit
+      raise RuntimeError, "Sanity check: txout value must not be zero" if txout.value <= 0
+      txout
+    end
+
+    def make_transaction_builder
+      txbuilder = TransactionBuilder.new
+      txbuilder.change_address = self.bitcoin_change_address
+      txbuilder.signer = self.signer
+      txbuilder.provider = self.internal_bitcoin_provider
+      txbuilder.unspent_outputs = self.bitcoin_unspent_outputs
+      txbuilder.fee_rate = self.fee_rate
+      txbuilder
+    end
+
+    def internal_bitcoin_provider
+      @internal_bitcoin_provider ||= (self.bitcoin_provider || TransactionBuilder::Provider.new{|txb| []})
+    end
+
+
+    # Validation Methods
+
+    def validate_bitcoin_change_address!
+      addr = self.bitcoin_change_address
+      raise ArgumentError, "Missing bitcoin_change_address" if !addr
+      raise ArgumentError, "bitcoin_change_address must be an instance of BTC::Address" if !addr.is_a?(Address)
+      raise ArgumentError, "bitcoin_change_address must not be an instance of BTC::AssetAddress" if addr.is_a?(AssetAddress)
+    end
+
+    def validate_asset_change_address!
+      self.transferred_assets.each do |dict|
+        addr = dict[:change_address] || self.asset_change_address
+        raise ArgumentError, "Missing asset_change_address" if !addr
+        raise ArgumentError, "asset_change_address must be an instance of BTC::AssetAddress" if !addr.is_a?(AssetAddress)
+      end
+    end
+
+    protected
+    attr_accessor :issuing_asset_script
+    attr_accessor :issuing_asset_output
+    attr_accessor :issued_assets
+    attr_accessor :transferred_assets
+    attr_accessor :bitcoin_outputs
+
+    def issued_assets
+      @issued_assets ||= []
+    end
+
+    def transferred_assets
+      @transferred_assets ||= []
+    end
+
+    def bitcoin_outputs
+      @bitcoin_outputs ||= []
+    end
+
+  end
+end
+
+require_relative 'asset_transaction_builder/errors.rb'
+require_relative 'asset_transaction_builder/result.rb'
+require_relative 'asset_transaction_builder/provider.rb'

data/lib/btcruby/open_assets/asset_transaction_input.rb

@@ -0,0 +1,64 @@
+# Implementation of OpenAssets protocol.
+# https://github.com/OpenAssets/open-assets-protocol/blob/master/specification.mediawiki
+module BTC
+  class AssetTransactionInput
+    attr_accessor :index
+    attr_accessor :transaction_input # BTC::TransactionInput
+
+    # Verified inputs with `asset_id == nil` are *uncolored*.
+    # Non-verified inputs are not known to have assets associated with them.
+    attr_accessor :asset_id
+    attr_accessor :value
+    attr_accessor :verified # true if asset_id and value are verified and can be used.
+
+    def initialize(transaction_input: nil, asset_id: nil, value: nil, verified: false)
+      raise ArgumentError, "No transaction_input provided" if !transaction_input
+      @transaction_input = transaction_input
+      @index = transaction_input ? transaction_input.index : nil
+      @asset_id = asset_id
+      @value = value
+      @verified = !!verified
+    end
+
+    # Input is verified when we know for sure if it's colored or not and if it is,
+    # what asset and how much is associated with it.
+    def verified?
+      !!@verified
+    end
+
+    # Input is colored when it has AssetID and a positive value.
+    def colored?
+      !!@asset_id && @value && @value > 0
+    end
+    
+    def index
+      @index ||= @transaction_input.index
+    end
+
+    def assets_data
+      data = "".b
+      data << WireFormat.encode_uint8(@verified ? 1 : 0)
+      data << WireFormat.encode_string(@asset_id ? @asset_id.hash : "".b)
+      data << WireFormat.encode_int64le(@value.to_i)
+      data
+    end
+    
+    # Returns total length read
+    def parse_assets_data(data, offset: 0)
+      v, len = WireFormat.read_uint8(data: data, offset: offset)
+      raise ArgumentError, "Invalid data: verified flag" if !v
+      asset_hash, len = WireFormat.read_string(data: data, offset: len) # empty or 20 bytes
+      raise ArgumentError, "Invalid data: asset hash" if !asset_hash
+      value, len = WireFormat.read_int64le(data: data, offset: len)
+      raise ArgumentError, "Invalid data: value" if !value
+      @verified = (v == 1)
+      @asset_id = asset_hash.bytesize > 0 ? AssetID.new(hash: asset_hash) : nil
+      @value = value
+      len
+    end
+
+    def ==(other)
+      super(other) || self.transaction_input == other.transaction_input
+    end
+  end
+end

data/lib/btcruby/open_assets/asset_transaction_output.rb

@@ -0,0 +1,140 @@
+# Implementation of OpenAssets protocol.
+# https://github.com/OpenAssets/open-assets-protocol/blob/master/specification.mediawiki
+module BTC
+  class AssetTransactionOutput
+    KIND_ISSUE    = :issue
+    KIND_TRANSFER = :transfer
+    KIND_MARKER   = :marker
+
+    attr_reader :index
+    attr_accessor :transaction_output # BTC::TransactionOutput
+
+    attr_accessor :kind
+    attr_accessor :issue # if true, then it's an issue output
+    attr_accessor :transfer # if true, then it's a transfer output
+    attr_accessor :marker # if true, then it's a marker output
+
+    # Verified outputs with `asset_id == nil` are *uncolored*.
+    # Non-verified outputs are not known to have assets associated with them.
+    attr_accessor :asset_id
+    attr_accessor :value
+    attr_accessor :verified # true if asset_id and value are verified and can be used.
+
+    def initialize(transaction_output: nil, asset_id: nil, value: nil, verified: false, issue: nil, transfer: nil, marker: nil)
+      raise ArgumentError, "No transaction_output provided" if !transaction_output
+      @transaction_output = transaction_output
+      @index = transaction_output ? transaction_output.index : nil
+      @asset_id = asset_id
+      @value = value
+      @verified = !!verified
+      self.issue = issue if issue
+      self.transfer = transfer if transfer
+      self.marker = marker if marker
+    end
+
+    # Output is verified when we know for sure if it's colored or not and if it is,
+    # what asset and how much is associated with it.
+    def verified?
+      !!@verified
+    end
+
+    # Output is colored when it has AssetID and a positive value.
+    def colored?
+      !!@asset_id && has_value?
+    end
+
+    def has_value?
+      !!@value && @value > 0
+    end
+
+    def issue=(issue)
+      raise ArgumentError, "Can only set `issue` to true" if !issue
+      self.kind = KIND_ISSUE
+      issue
+    end
+
+    def transfer=(transfer)
+      raise ArgumentError, "Can only set `transfer` to true" if !transfer
+      self.kind = KIND_TRANSFER
+      transfer
+    end
+
+    def marker=(marker)
+      raise ArgumentError, "Can only set `marker` to true" if !marker
+      self.kind = KIND_MARKER
+      marker
+    end
+
+    def kind=(kind)
+      @kind = kind
+      @marker = nil
+    end
+
+    # Returns `true` if this output may issue new amount of some asset.
+    def issue
+      @kind == KIND_ISSUE
+    end
+    alias :issue? :issue
+
+    # Returns `true` if this output may transfer new amount of some asset.
+    def transfer
+      @kind == KIND_TRANSFER
+    end
+    alias :transfer? :transfer
+
+    # Returns `true` if this output corresponds to a marker output (always uncolored)
+    def marker
+      @marker ||= (@kind == KIND_MARKER ? AssetMarker.new(output: @transaction_output) : nil)
+    end
+
+    def marker?
+      !!marker
+    end
+
+    def index
+      @index ||= @transaction_output.index
+    end
+
+    def transaction_hash
+      @transaction_output.transaction_hash
+    end
+
+    def transaction_id
+      @transaction_output.transaction_id
+    end
+
+    def outpoint
+      @transaction_output.outpoint
+    end
+
+    def outpoint_id
+      @transaction_output.outpoint_id
+    end
+
+    def assets_data
+      data = "".b
+      data << WireFormat.encode_uint8(@verified ? 1 : 0)
+      data << WireFormat.encode_string(@asset_id ? @asset_id.hash : "".b)
+      data << WireFormat.encode_int64le(@value.to_i)
+      data
+    end
+
+    # Returns total length read
+    def parse_assets_data(data, offset: 0)
+      v, len = WireFormat.read_uint8(data: data, offset: offset)
+      raise ArgumentError, "Invalid data: verified flag" if !v
+      asset_hash, len = WireFormat.read_string(data: data, offset: len) # empty or 20 bytes
+      raise ArgumentError, "Invalid data: asset hash" if !asset_hash
+      value, len = WireFormat.read_int64le(data: data, offset: len)
+      raise ArgumentError, "Invalid data: value" if !value
+      @verified = (v == 1)
+      @asset_id = asset_hash.bytesize > 0 ? AssetID.new(hash: asset_hash) : nil
+      @value = value
+      len
+    end
+
+    def ==(other)
+      super(other) || self.transaction_output == other.transaction_output
+    end
+  end
+end

data/lib/btcruby/open_assets.rb

@@ -0,0 +1,26 @@
+# Implementation of [OpenAssets protocol](https://github.com/OpenAssets/open-assets-protocol/blob/master/specification.mediawiki).
+# * AssetID uniquely identifies an asset and conditions of issuance.
+# * AssetAddress is an address format that allows sending and receiving assets.
+# * Asset represents an asset source (includes AssetID and output).
+# * AssetMarker represents a marker specifying asset issuance and transfer.
+# 
+# Tasks:
+# * Issuing a new asset.
+# * Issuing more units of a given asset. If the issuing address holds some assets, they must be re-created.
+# * Tracking asset origin via proofchain of transactions with block merkle paths.
+# * Transferring assets.
+# * Transferring assets with payment in the same transaction.
+# * Non-interactive decentralized order book.
+# * Supporting issue-once assets (anchored to a genesis transaction ID).
+# * Supporting stock split (AssetV2 is issued by consuming AssetV1, validating software must validate AssetV2 accordingly).
+# * Supporting key rotation (can be done using the same technique as with stock split). Maybe use metadata to link to a previous asset.
+require_relative 'open_assets/asset_id.rb'
+require_relative 'open_assets/asset_address.rb'
+require_relative 'open_assets/asset.rb'
+require_relative 'open_assets/asset_marker.rb'
+require_relative 'open_assets/asset_transaction.rb'
+require_relative 'open_assets/asset_transaction_input.rb'
+require_relative 'open_assets/asset_transaction_output.rb'
+require_relative 'open_assets/asset_processor.rb'
+require_relative 'open_assets/asset_transaction_builder.rb'
+require_relative 'open_assets/asset_definition.rb'