btcruby 0.0.0 → 1.0.0

data/lib/btcruby/opcode.rb

@@ -0,0 +1,197 @@
+# Bitcoin script consists of opcodes ("operation codes") and raw binary data.
+# Opcodes define how the data is added, removed and modified on the stack.
+module BTC
+  module Opcode
+    extend self
+
+    # Returns a human-readable name for a given opcode byte value.
+    def name_for_opcode(opcode)
+      OPCODE_VALUE_TO_NAME[opcode] || "OP_UNKNOWN"
+    end
+
+    # Returns an opcode byte value for a given name ("OP_...").
+    def opcode_for_name(name)
+      OPCODE_NAME_TO_VALUE[name] || OP_INVALIDOPCODE
+    end
+
+    # Returns OP_1NEGATE, OP_0 .. OP_16 for ints from -1 to 16.
+    # Returns OP_INVALIDOPCODE for other ints.
+    def opcode_for_small_integer(small_int)
+      raise ArgumentError, "small_int must not be nil" if !small_int
+      return OP_0       if small_int == 0
+      return OP_1NEGATE if small_int == -1
+      if small_int >= 1 && small_int <= 16
+        return OP_1 + (small_int - 1)
+      end
+      return OP_INVALIDOPCODE
+    end
+
+    # Converts opcode OP_<N> or OP_1NEGATE to an integer value.
+    # If incorrect opcode is given, nil is returned.
+    def small_integer_from_opcode(opcode)
+      return 0  if opcode == "".b # OP_O
+      return 0  if opcode == OP_0
+      return -1 if opcode == OP_1NEGATE
+      if opcode >= OP_1 && opcode <= OP_16
+        return opcode - (OP_1 - 1)
+      end
+      return nil
+    end
+  end
+
+  # 1. Operators pushing data on stack.
+
+  # Push 1 byte 0x00 on the stack
+  OP_FALSE = 0x00
+  OP_0     = 0x00
+
+  # Any opcode with value < PUSHDATA1 is a length of the string to be pushed on the stack.
+  # So opcode 0x01 is followed by 1 byte of data, 0x09 by 9 bytes and so on up to 0x4b (75 bytes)
+
+  # PUSHDATA<N> opcode is followed by N-byte length of the string that follows.
+  OP_PUSHDATA1 = 0x4c # followed by a 1-byte length of the string to push (allows pushing 0..255 bytes).
+  OP_PUSHDATA2 = 0x4d # followed by a 2-byte length of the string to push (allows pushing 0..65535 bytes).
+  OP_PUSHDATA4 = 0x4e # followed by a 4-byte length of the string to push (allows pushing 0..4294967295 bytes).
+  OP_1NEGATE   = 0x4f # pushes -1 number on the stack
+  OP_RESERVED  = 0x50 # Not assigned. If executed, transaction is invalid.
+
+  # OP_<N> pushes number <N> on the stack
+  OP_TRUE = 0x51
+  OP_1    = 0x51
+  OP_2    = 0x52
+  OP_3    = 0x53
+  OP_4    = 0x54
+  OP_5    = 0x55
+  OP_6    = 0x56
+  OP_7    = 0x57
+  OP_8    = 0x58
+  OP_9    = 0x59
+  OP_10   = 0x5a
+  OP_11   = 0x5b
+  OP_12   = 0x5c
+  OP_13   = 0x5d
+  OP_14   = 0x5e
+  OP_15   = 0x5f
+  OP_16   = 0x60
+
+  # 2. Control flow operators
+
+  OP_NOP      = 0x61 # Does nothing
+  OP_VER      = 0x62 # Not assigned. If executed, transaction is invalid.
+
+  # BitcoinQT executes all operators from OP_IF to OP_ENDIF even inside "non-executed" branch (to keep track of nesting).
+  # Since OP_VERIF and OP_VERNOTIF are not assigned, even inside a non-executed branch they will fall in "default:" switch case
+  # and cause the script to fail. Some other ops like OP_VER can be present inside non-executed branch because they'll be skipped.
+  OP_IF       = 0x63 # If the top stack value is not 0, the statements are executed. The top stack value is removed.
+  OP_NOTIF    = 0x64 # If the top stack value is 0, the statements are executed. The top stack value is removed.
+  OP_VERIF    = 0x65 # Not assigned. Script is invalid with that opcode (even if inside non-executed branch).
+  OP_VERNOTIF = 0x66 # Not assigned. Script is invalid with that opcode (even if inside non-executed branch).
+  OP_ELSE     = 0x67 # Executes code if the previous OP_IF or OP_NOTIF was not executed.
+  OP_ENDIF    = 0x68 # Finishes if/else block
+
+  OP_VERIFY   = 0x69 # Removes item from the stack if it's not 0x00 or 0x80 (negative zero). Otherwise, marks script as invalid.
+  OP_RETURN   = 0x6a # Marks transaction as invalid.
+
+  # Stack ops
+  OP_TOALTSTACK   = 0x6b # Moves item from the stack to altstack
+  OP_FROMALTSTACK = 0x6c # Moves item from the altstack to stack
+  OP_2DROP = 0x6d
+  OP_2DUP  = 0x6e
+  OP_3DUP  = 0x6f
+  OP_2OVER = 0x70
+  OP_2ROT  = 0x71
+  OP_2SWAP = 0x72
+  OP_IFDUP = 0x73
+  OP_DEPTH = 0x74
+  OP_DROP  = 0x75
+  OP_DUP   = 0x76
+  OP_NIP   = 0x77
+  OP_OVER  = 0x78
+  OP_PICK  = 0x79
+  OP_ROLL  = 0x7a
+  OP_ROT   = 0x7b
+  OP_SWAP  = 0x7c
+  OP_TUCK  = 0x7d
+
+  # Splice ops
+  OP_CAT    = 0x7e # Disabled opcode. If executed, transaction is invalid.
+  OP_SUBSTR = 0x7f # Disabled opcode. If executed, transaction is invalid.
+  OP_LEFT   = 0x80 # Disabled opcode. If executed, transaction is invalid.
+  OP_RIGHT  = 0x81 # Disabled opcode. If executed, transaction is invalid.
+  OP_SIZE   = 0x82
+
+  # Bit logic
+  OP_INVERT = 0x83 # Disabled opcode. If executed, transaction is invalid.
+  OP_AND    = 0x84 # Disabled opcode. If executed, transaction is invalid.
+  OP_OR     = 0x85 # Disabled opcode. If executed, transaction is invalid.
+  OP_XOR    = 0x86 # Disabled opcode. If executed, transaction is invalid.
+
+  OP_EQUAL = 0x87        # Last two items are removed from the stack and compared. Result (true or false) is pushed to the stack.
+  OP_EQUALVERIFY = 0x88  # Same as OP_EQUAL, but removes the result from the stack if it's true or marks script as invalid.
+
+  OP_RESERVED1 = 0x89 # Disabled opcode. If executed, transaction is invalid.
+  OP_RESERVED2 = 0x8a # Disabled opcode. If executed, transaction is invalid.
+
+  # Numeric
+  OP_1ADD      = 0x8b  # adds 1 to last item, pops it from stack and pushes result.
+  OP_1SUB      = 0x8c  # substracts 1 to last item, pops it from stack and pushes result.
+  OP_2MUL      = 0x8d  # Disabled opcode. If executed, transaction is invalid.
+  OP_2DIV      = 0x8e  # Disabled opcode. If executed, transaction is invalid.
+  OP_NEGATE    = 0x8f  # negates the number, pops it from stack and pushes result.
+  OP_ABS       = 0x90  # replaces number with its absolute value
+  OP_NOT       = 0x91  # replaces number with True if it's zero, False otherwise.
+  OP_0NOTEQUAL = 0x92  # replaces number with True if it's not zero, False otherwise.
+
+  OP_ADD    = 0x93  # (x y -- x+y)
+  OP_SUB    = 0x94  # (x y -- x-y)
+  OP_MUL    = 0x95  # Disabled opcode. If executed, transaction is invalid.
+  OP_DIV    = 0x96  # Disabled opcode. If executed, transaction is invalid.
+  OP_MOD    = 0x97  # Disabled opcode. If executed, transaction is invalid.
+  OP_LSHIFT = 0x98  # Disabled opcode. If executed, transaction is invalid.
+  OP_RSHIFT = 0x99  # Disabled opcode. If executed, transaction is invalid.
+
+  OP_BOOLAND            = 0x9a
+  OP_BOOLOR             = 0x9b
+  OP_NUMEQUAL           = 0x9c
+  OP_NUMEQUALVERIFY     = 0x9d
+  OP_NUMNOTEQUAL        = 0x9e
+  OP_LESSTHAN           = 0x9f
+  OP_GREATERTHAN        = 0xa0
+  OP_LESSTHANOREQUAL    = 0xa1
+  OP_GREATERTHANOREQUAL = 0xa2
+  OP_MIN                = 0xa3
+  OP_MAX                = 0xa4
+
+  OP_WITHIN = 0xa5
+
+  # Crypto
+  OP_RIPEMD160      = 0xa6
+  OP_SHA1           = 0xa7
+  OP_SHA256         = 0xa8
+  OP_HASH160        = 0xa9
+  OP_HASH256        = 0xaa
+  OP_CODESEPARATOR  = 0xab # This opcode is rarely used because it's useless, but we need to support it anyway.
+  OP_CHECKSIG       = 0xac
+  OP_CHECKSIGVERIFY = 0xad
+  OP_CHECKMULTISIG  = 0xae
+  OP_CHECKMULTISIGVERIFY = 0xaf
+
+  # Expansion
+  OP_NOP1  = 0xb0
+  OP_NOP2  = 0xb1
+  OP_NOP3  = 0xb2
+  OP_NOP4  = 0xb3
+  OP_NOP5  = 0xb4
+  OP_NOP6  = 0xb5
+  OP_NOP7  = 0xb6
+  OP_NOP8  = 0xb7
+  OP_NOP9  = 0xb8
+  OP_NOP10 = 0xb9
+
+  OP_INVALIDOPCODE = 0xff
+
+  OPCODE_NAME_TO_VALUE = Hash[*constants.grep(/^OP_/).map{|c| [c.to_s, const_get(c)] }.flatten]
+  OPCODE_VALUE_TO_NAME = Hash[*constants.grep(/^OP_/).map{|c| [const_get(c), c.to_s] }.flatten]
+
+end
+

data/lib/btcruby/open_assets/asset.rb

@@ -0,0 +1,35 @@
+module BTC
+  # Implementation of OpenAssets protocol.
+  # https://github.com/OpenAssets/open-assets-protocol/blob/master/specification.mediawiki
+  class Asset
+        
+    # BTC::AssetID instance identifying this asset.
+    attr_accessor :asset_id
+    
+    # Binary 160-bit identifier of the asset (same as `asset_id.hash`)
+    attr_accessor :identifier_binary
+    
+    # Optional attributes, set either by initializer when possible, or externally.
+    attr_accessor :script
+    attr_accessor :output
+    
+    # Initializes assets with one of the following:
+    # * script - a BTC::Script instance.
+    # * output - a BTC::TransactionOutput instance that issues the asset.
+    # * asset_id - a Base58 identifier of the asset or BTC::AssetID instance.
+    def initialize(asset_id: nil, script: nil, output: nil, network: nil)
+      if script || output
+        script ||= output.script
+        @output = output
+        @script = script
+        @identifier_binary = BTC::Data.hash160(script.data)
+        @asset_id = AssetID.new(hash: @identifier_binary, network: network)
+      elsif asset_id
+        @asset_id = Address.parse(asset_id)
+        @identifier_binary = @asset_id.hash
+      else
+        raise ArgumentError, "Either asset_id, script or output must be specified."
+      end
+    end
+  end
+end

data/lib/btcruby/open_assets/asset_address.rb

@@ -0,0 +1,49 @@
+module BTC
+  # Represents an Asset Address, where the assets can be sent.
+  class AssetAddress < BTC::Address
+    NAMESPACE = 0x13
+    
+    def self.mainnet_version
+      NAMESPACE
+    end
+
+    def self.testnet_version
+      NAMESPACE
+    end
+
+    attr_reader :bitcoin_address
+    
+    def initialize(string: nil, bitcoin_address: nil, _raw_data: nil)
+      if string
+        _raw_data ||= Base58.data_from_base58check(string)
+        raise FormatError, "Too short AssetAddress" if _raw_data.bytesize < 2
+        raise FormatError, "Invalid namespace for AssetAddress" if _raw_data.bytes[0] != NAMESPACE
+        @bitcoin_address = Address.parse_raw_data(_raw_data[1..-1])
+        @base58check_string = string
+      elsif bitcoin_address
+        @base58check_string = nil
+        @bitcoin_address = BTC::Address.parse(bitcoin_address)
+      else
+        raise ArgumentError, "Either data or string must be provided"
+      end
+      # If someone accidentally supplied AssetAddress as a bitcoin address, 
+      # simply unwrap the bitcoin address from it.
+      while @bitcoin_address.is_a?(self.class)
+        @bitcoin_address = @bitcoin_address.bitcoin_address
+        @base58check_string = nil
+      end
+    end
+
+    def network
+      @bitcoin_address.network
+    end
+
+    def script
+      @bitcoin_address.script
+    end
+
+    def data_for_base58check_encoding
+      BTC::Data.data_from_bytes([NAMESPACE]) + @bitcoin_address.data_for_base58check_encoding
+    end
+  end
+end

data/lib/btcruby/open_assets/asset_definition.rb

@@ -0,0 +1,75 @@
+# Implementation of OpenAssets Asset Definition Format
+# https://github.com/OpenAssets/open-assets-protocol/blob/master/asset-definition-protocol.mediawiki
+require 'json' # in Ruby 2 stdlib
+module BTC
+  class AssetDefinition
+    
+    DEFAULT_VERSION = "1.0".freeze
+    
+    attr_accessor :asset_ids
+    attr_accessor :name_short
+    attr_accessor :name
+    attr_accessor :contract_url
+    attr_accessor :issuer
+    attr_accessor :description
+    attr_accessor :description_mime
+    attr_accessor :type
+    attr_accessor :divisibility
+    attr_accessor :link_to_website
+    attr_accessor :icon_url
+    attr_accessor :image_url
+    attr_accessor :version
+
+    def initialize(dictionary: nil,
+                   json: nil,
+                   asset_ids: [],
+                   name: nil,
+                   name_short: nil,
+                   issuer: nil,
+                   type: nil,
+                   divisibility: 0)
+
+      @json = json
+      dictionary ||= (json ? JSON.parse(json) : nil)
+      if dictionary
+        @asset_ids = dictionary["asset_ids"].map{|aid| AssetID.parse(aid) }
+      else
+        @asset_ids = asset_ids
+        @name = name
+        @name_short = name_short
+        @issuer = issuer
+        @type = type
+        @divisibility = divisibility
+      end
+      @version ||= DEFAULT_VERSION
+      @asset_ids ||= []
+      @divisibility ||= 0
+    end
+
+    def dictionary
+      dict = {}
+      dict["asset_ids"]  = self.asset_ids.map{|aid| aid.to_s}
+      dict["name_short"] = self.name_short || ""
+      dict["name"]       = self.name || ""
+      dict["contract_url"] =       self.contract_url     if self.contract_url
+      dict["issuer"] =             self.issuer           if self.issuer
+      dict["description"] =        self.description      if self.description
+      dict["description_mime"] =   self.description_mime if self.description_mime
+      dict["type"] =               self.type             if self.type
+      dict["divisibility"] =       self.divisibility     if self.divisibility
+      dict["link_to_website"] =    self.link_to_website  if self.link_to_website
+      dict["icon_url"] =           self.icon_url         if self.icon_url
+      dict["image_url"] =          self.image_url        if self.image_url
+      dict["version"] =            self.version          if self.version
+      dict
+    end
+
+    def json
+      @json ||= JSON.generate(dictionary)
+    end
+    
+    def sha256
+      BTC::Data.hex_from_data(BTC.sha256(json))
+    end
+  end
+end

data/lib/btcruby/open_assets/asset_id.rb

@@ -0,0 +1,24 @@
+module BTC
+  # Represents an Asset ID.
+  class AssetID < BTC::Hash160Address
+    
+    def self.mainnet_version
+      23 # "A" prefix
+    end
+
+    def self.testnet_version
+      115
+    end
+
+    # Instantiates AssetID with output, output script or raw hash.
+    # To compute an Asset ID for the Asset Definition file, use `trim_script_prefix: true`.
+    def initialize(string: nil, hash: nil, network: nil, _raw_data: nil, script: nil, trim_script_prefix: false)
+      if script
+        script = script.without_dropped_prefix_data if trim_script_prefix
+        super(hash: BTC.hash160(script.data), network: network)
+      else
+        super(string: string, hash: hash, network: network, _raw_data: _raw_data)
+      end
+    end
+  end
+end

data/lib/btcruby/open_assets/asset_marker.rb

@@ -0,0 +1,94 @@
+module BTC
+  class AssetMarker
+    
+    MAGIC = "\x4f\x41".freeze
+    VERSION1 = "\x01\x00".freeze
+    PREFIX_V1 = MAGIC + VERSION1
+
+    attr_accessor :quantities
+    attr_accessor :metadata
+
+    attr_reader :data
+    attr_reader :output
+    attr_reader :script
+    
+    def initialize(output: nil, script: nil, data: nil, quantities: nil, metadata: nil)
+      if output || script
+        script ||= output.script
+        raise ArgumentError, "Script is not an OP_RETURN script" if !script.op_return_script?
+        data = script.op_return_data
+        raise ArgumentError, "No pushdata found in script" if !data || data.bytesize == 0
+        @output = output
+        @script = script
+      end
+      if data
+        data = BTC::Data.ensure_binary_encoding(data)
+        
+        raise ArgumentError, "Data must be at least 6 bytes long (4 bytes prefix and 2 bytes for varints)" if data.bytesize < 6
+        raise ArgumentError, "Prefix is invalid. Expected #{BTC::Data.hex_from_data(PREFIX_V1)}" if data[0, PREFIX_V1.bytesize] != PREFIX_V1
+
+        offset = PREFIX_V1.bytesize
+        count, bytesread = WireFormat.read_varint(data: data, offset: offset)
+        raise ArgumentError, "Cannot read Asset Quantity Count varint" if !count
+        offset = bytesread
+        @quantities = []
+        count.times do
+          qty, bytesread = WireFormat.read_uleb128(data: data, offset: offset)
+          raise ArgumentError, "Cannot read Asset Quantity LEB128 unsigned integer" if !qty
+          raise ArgumentError, "Open Assets limit LEB128 encoding for quantities to 9 bytes" if (bytesread - offset) > 9
+          @quantities << qty
+          offset = bytesread
+        end
+        metadata, bytesread = WireFormat.read_string(data: data, offset: offset)
+        raise ArgumentError, "Cannot read Asset Metadata" if !metadata
+        @metadata = metadata
+        @data = data[0, bytesread]
+      else
+        # Initialize with optional attributes
+        @quantities = quantities
+        @metadata = metadata
+      end
+    end
+    
+    def quantities
+      @quantities ||= []
+    end
+
+    def quantities=(qs)
+      @quantities = qs
+      @data = nil
+      @script = nil
+      @output = nil
+    end
+    
+    def metadata
+      @metadata ||= "".b
+    end
+    
+    def metadata=(md)
+      @metadata = md
+      @data = nil
+      @script = nil
+      @output = nil
+    end
+    
+    def data
+      @data ||= begin
+        PREFIX_V1 + 
+        WireFormat.encode_varint(self.quantities.size) + 
+        self.quantities.inject("".b){|buf, qty| buf << WireFormat.encode_uleb128(qty) } +
+        WireFormat.encode_string(self.metadata)
+      end
+    end
+
+    def script
+      @script ||= begin
+        Script.new << OP_RETURN << self.data
+      end
+    end
+
+    def output
+      @output ||= TransactionOutput.new(value: 0, script: self.script)
+    end
+  end
+end