mixin_bot 1.4.0 → 2.0.0

data/lib/mixin_bot/transaction/decoder.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class Transaction
+    ##
+    # Parses raw transaction bytes into a {Transaction} instance.
+    #
+    class Decoder
+      def initialize(transaction)
+        @tx = transaction
+      end
+
+      def decode
+        raw = [@tx.hex].pack('H*').bytes
+        @tx.hash = SHA3::Digest::SHA256.hexdigest(raw.pack('C*'))
+        @buf = Buffer.new(raw)
+
+        magic = @buf.shift(2)
+        raise ArgumentError, 'Not valid raw' unless magic == Transaction::MAGIC
+
+        _version = @buf.shift(2)
+        @tx.version = MixinBot.utils.decode_int _version
+
+        asset = @buf.shift(32)
+        @tx.asset = asset.pack('C*').unpack1('H*')
+
+        decode_inputs
+        decode_outputs
+        decode_references if @tx.version >= Transaction::REFERENCES_TX_VERSION && @tx.references.present?
+
+        extra_size = MixinBot.utils.decode_uint32 @buf.shift(4)
+        @tx.extra = @buf.shift(extra_size).pack('C*')
+
+        num = MixinBot.utils.decode_uint16 @buf.shift(2)
+        if num == Transaction::MAX_ENCODE_INT
+          @tx.aggregated = {}
+
+          prefix = MixinBot.utils.decode_uint16(@buf.shift(2))
+          raise ArgumentError, 'invalid aggregated' unless prefix == Transaction::AGGREGATED_SIGNATURE_PREFIX
+
+          @tx.aggregated['signature'] = @buf.shift(64).pack('C*').unpack1('H*')
+
+          byte = @buf.shift
+          case byte
+          when Transaction::AGGREGATED_SIGNATURE_ORDINAY_MASK.first
+            @tx.aggregated['signers'] = []
+            masks_size = MixinBot.utils.decode_uint16 @buf.shift(2)
+            masks = @buf.shift(masks_size)
+            masks = Array(masks)
+
+            masks.each_with_index do |mask, i|
+              8.times do |j|
+                k = 1 << j
+                @tx.aggregated['signers'].push((i * 8) + j) if mask & k == k
+              end
+            end
+          when Transaction::AGGREGATED_SIGNATURE_SPARSE_MASK.first
+            signers_size = MixinBot.utils.decode_uint16 @buf.shift(2)
+            @tx.aggregated['signers'] = []
+            unless signers_size.zero?
+              signers_size.times do
+                @tx.aggregated['signers'].push MixinBot.utils.decode_uint16(@buf.shift(2))
+              end
+            end
+          end
+        elsif num.present? && num.positive? && @buf.size.positive?
+          @tx.signatures = []
+          num.times do
+            signature = {}
+
+            keys_size = MixinBot.utils.decode_uint16 @buf.shift(2)
+
+            keys_size.times do
+              index = MixinBot.utils.decode_uint16 @buf.shift(2)
+              signature[index] = @buf.shift(64).pack('C*').unpack1('H*')
+            end
+
+            @tx.signatures << signature
+          end
+        end
+
+        @tx
+      end
+
+      private
+
+      def decode_inputs
+        inputs_size = MixinBot.utils.decode_uint16 @buf.shift(2)
+        @tx.inputs = []
+        inputs_size.times do
+          input = {}
+          hash = @buf.shift(32)
+          input['hash'] = hash.pack('C*').unpack1('H*')
+
+          index = @buf.shift(2)
+          input['index'] = MixinBot.utils.decode_uint16 index
+
+          if @buf.peek(2) == Transaction::NULL_BYTES
+            @buf.shift(2)
+          else
+            genesis_size = MixinBot.utils.decode_uint16 @buf.shift(2)
+            genesis = @buf.shift genesis_size
+            input['genesis'] = genesis.pack('C*').unpack1('H*')
+          end
+
+          if @buf.peek(2) == Transaction::NULL_BYTES
+            @buf.shift(2)
+          else
+            magic = @buf.shift(2)
+            raise ArgumentError, 'Not valid input' unless magic == Transaction::MAGIC
+
+            deposit = {}
+            deposit['chain'] = @buf.shift(32).pack('C*').unpack1('H*')
+
+            asset_size = MixinBot.utils.decode_uint16 @buf.shift(2)
+            deposit['asset'] = @buf.shift(asset_size).unpack1('H*')
+
+            transaction_size = MixinBot.utils.decode_uint16 @buf.shift(2)
+            deposit['transaction'] = @buf.shift(transaction_size).unpack1('H*')
+
+            deposit['index'] = MixinBot.utils.decode_uint64 @buf.shift(8)
+
+            amount_size = MixinBot.utils.decode_uint16 @buf.shift(2)
+            deposit['amount'] = MixinBot.utils.decode_int @buf.shift(amount_size)
+
+            input['deposit'] = deposit
+          end
+
+          if @buf.peek(2) == Transaction::NULL_BYTES
+            @buf.shift(2)
+          else
+            magic = @buf.shift(2)
+            raise ArgumentError, 'Not valid input' unless magic == Transaction::MAGIC
+
+            mint = {}
+            if @buf.peek(2) == Transaction::NULL_BYTES
+              @buf.shift(2)
+            else
+              group_size = MixinBot.utils.decode_uint16 @buf.shift(2)
+              mint['group'] = @buf.shift(group_size).unpack1('H*')
+            end
+
+            mint['batch'] = MixinBot.utils.decode_uint64 @buf.shift(8)
+            _amount_size = MixinBot.utils.decode_uint16 @buf.shift(2)
+            mint['amount'] = MixinBot.utils.decode_int @buf.shift(_amount_size)
+
+            input['mint'] = mint
+          end
+
+          @tx.inputs.push input
+        end
+
+        @tx
+      end
+
+      def decode_outputs
+        outputs_size = MixinBot.utils.decode_uint16 @buf.shift(2)
+        @tx.outputs = []
+        outputs_size.times do
+          output = {}
+
+          @buf.shift
+          type = @buf.shift
+          output['type'] = type
+
+          amount_size = MixinBot.utils.decode_uint16 @buf.shift(2)
+          output['amount'] = format('%.8f', MixinBot.utils.decode_int(@buf.shift(amount_size)).to_f / 1e8).gsub(/\.?0+$/, '')
+
+          output['keys'] = []
+          keys_size = MixinBot.utils.decode_uint16 @buf.shift(2)
+          keys_size.times do
+            output['keys'].push @buf.shift(32).pack('C*').unpack1('H*')
+          end
+
+          output['mask'] = @buf.shift(32).pack('C*').unpack1('H*')
+
+          script_size = MixinBot.utils.decode_uint16 @buf.shift(2)
+          output['script'] = @buf.shift(script_size).pack('C*').unpack1('H*')
+
+          if @buf.peek(2) == Transaction::NULL_BYTES
+            @buf.shift(2)
+          else
+            magic = @buf.shift(2)
+            raise ArgumentError, 'Not valid output' unless magic == Transaction::MAGIC
+
+            withdrawal = {}
+            withdrawal['chain'] = @buf.shift(32).pack('C*').unpack1('H*')
+
+            asset_size = MixinBot.utils.decode_uint16 @buf.shift(2)
+            withdrawal['asset'] = @buf.shift(asset_size).unpack1('H*')
+
+            if @buf.peek(2) == Transaction::NULL_BYTES
+              @buf.shift(2)
+            else
+              address_size = MixinBot.utils.decode_uint16 @buf.shift(2)
+              withdrawal['address'] = @buf.shift(address_size).pack('C*').unpack1('H*')
+            end
+
+            if @buf.peek(2) == Transaction::NULL_BYTES
+              @buf.shift(2)
+            else
+              tag_size = MixinBot.utils.decode_uint16 @buf.shift(2)
+              withdrawal['tag'] = @buf.shift(tag_size).pack('C*').unpack1('H*')
+            end
+
+            output['withdrawal'] = withdrawal
+          end
+
+          @tx.outputs.push output
+        end
+
+        @tx
+      end
+
+      def decode_references
+        references_size = MixinBot.utils.decode_uint16 @buf.shift(2)
+        @tx.references = []
+
+        references_size.times do
+          @tx.references.push @buf.shift(32).pack('C*').unpack1('H*')
+        end
+
+        @tx
+      end
+    end
+  end
+end

data/lib/mixin_bot/transaction/encoder.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class Transaction
+    ##
+    # Builds the binary encoding for a {Transaction} instance.
+    #
+    class Encoder
+      def initialize(transaction)
+        @tx = transaction
+      end
+
+      def encode
+        raise InvalidTransactionFormatError, 'asset is required' if @tx.asset.blank?
+        raise InvalidTransactionFormatError, 'inputs is required' if @tx.inputs.blank?
+        raise InvalidTransactionFormatError, 'outputs is required' if @tx.outputs.blank?
+
+        bytes = []
+
+        bytes += Transaction::MAGIC
+        bytes += [0, @tx.version]
+        bytes += [@tx.asset].pack('H*').bytes
+
+        bytes += encode_inputs
+        bytes += encode_outputs
+        bytes += encode_references if @tx.version >= Transaction::REFERENCES_TX_VERSION && @tx.references.present?
+
+        extra_bytes = @tx.extra.bytes
+        raise InvalidTransactionFormatError, 'extra is too long' if extra_bytes.size > Transaction::MAX_EXTRA_SIZE
+
+        bytes += MixinBot.utils.encode_uint32 extra_bytes.size
+        bytes += extra_bytes
+
+        bytes += if @tx.aggregated.nil?
+                   encode_signatures
+                 else
+                   encode_aggregated_signature
+                 end
+
+        @tx.hash = SHA3::Digest::SHA256.hexdigest bytes.pack('C*')
+        @tx.hex = bytes.pack('C*').unpack1('H*')
+
+        @tx
+      end
+
+      private
+
+      def encode_inputs
+        bytes = []
+
+        bytes += MixinBot.utils.encode_uint16(@tx.inputs.size)
+
+        @tx.inputs.each do |input|
+          bytes += [input['hash']].pack('H*').bytes
+          bytes += MixinBot.utils.encode_uint16(input['index'])
+
+          genesis = input['genesis'] || ''
+          if genesis.empty?
+            bytes += Transaction::NULL_BYTES
+          else
+            genesis_bytes = [genesis].pack('H*').bytes
+            bytes += MixinBot.utils.encode_uint16 genesis_bytes.size
+            bytes += genesis_bytes
+          end
+
+          deposit = input['deposit']
+          if deposit.nil?
+            bytes += Transaction::NULL_BYTES
+          else
+            bytes += Transaction::MAGIC
+            bytes += [deposit['chain']].pack('H*').bytes
+
+            asset_bytes = [deposit['asset']].pack('H*')
+            bytes += MixinBot.utils.encode_uint16 asset_bytes.size
+            bytes += asset_bytes.bytes
+
+            transaction_bytes = [deposit['transaction']].pack('H*')
+            bytes += MixinBot.utils.encode_uint16 transaction_bytes.size
+            bytes += transaction_bytes.bytes
+
+            bytes += MixinBot.utils.encode_uint64 deposit['index']
+
+            amount_bytes = MixinBot.utils.bytes_of deposit['amount']
+            bytes += MixinBot.utils.encode_uint16 amount_bytes.size
+            bytes += amount_bytes
+          end
+
+          mint = input['mint']
+          if mint.nil?
+            bytes += Transaction::NULL_BYTES
+          else
+            bytes += Transaction::MAGIC
+
+            group = mint['group'] || ''
+            if group.empty?
+              bytes += Transaction::NULL_BYTES
+            else
+              group_bytes = [group].pack('H*')
+              bytes += MixinBot.utils.encode_uint16 group_bytes.size
+              bytes += group_bytes.bytes
+            end
+
+            bytes += MixinBot.utils.encode_uint64 mint['batch']
+
+            amount_bytes = MixinBot.utils.encode_int mint['amount']
+            bytes += MixinBot.utils.encode_uint16 amount_bytes.size
+            bytes += amount_bytes
+          end
+        end
+
+        bytes
+      end
+
+      def encode_outputs
+        bytes = []
+
+        bytes += MixinBot.utils.encode_uint16 @tx.outputs.size
+
+        @tx.outputs.each do |output|
+          type = output['type'] || 0
+          bytes += [0x00, type]
+
+          amount_bytes = MixinBot.utils.encode_int((output['amount'].to_d * 1e8).round)
+          bytes += MixinBot.utils.encode_uint16 amount_bytes.size
+          bytes += amount_bytes
+
+          bytes += MixinBot.utils.encode_uint16 output['keys'].size
+          output['keys'].each do |key|
+            bytes += [key].pack('H*').bytes
+          end
+
+          bytes += [output['mask']].pack('H*').bytes
+
+          script_bytes = [output['script']].pack('H*').bytes
+          bytes += MixinBot.utils.encode_uint16 script_bytes.size
+          bytes += script_bytes
+
+          withdrawal = output['withdrawal']
+          if withdrawal.nil?
+            bytes += Transaction::NULL_BYTES
+          else
+            bytes += Transaction::MAGIC
+
+            bytes += [withdrawal['chain']].pack('H*').bytes
+
+            asset_bytes = [withdrawal['asset']].pack('H*')
+            bytes += MixinBot.utils.encode_uint16 asset_bytes.bytesize
+            bytes += asset_bytes.bytes
+
+            address = withdrawal['address'] || ''
+            if address.empty?
+              bytes += Transaction::NULL_BYTES
+            else
+              address_bytes = [address].pack('H*').bytes
+              bytes += MixinBot.utils.encode_uint16 address_bytes.size
+              bytes += address_bytes
+            end
+
+            tag = withdrawal['tag'] || ''
+            if tag.empty?
+              bytes += Transaction::NULL_BYTES
+            else
+              tag_bytes = [tag].pack('H*').bytes
+              bytes += MixinBot.utils.encode_uint16 tag_bytes.size
+              bytes += tag_bytes
+            end
+          end
+        end
+
+        bytes
+      end
+
+      def encode_references
+        bytes = []
+
+        bytes += MixinBot.utils.encode_uint16 @tx.references.size
+
+        @tx.references.each do |reference|
+          bytes += [reference].pack('H*').bytes
+        end
+
+        bytes
+      end
+
+      def encode_aggregated_signature
+        bytes = []
+
+        bytes += MixinBot.utils.encode_uint16 Transaction::MAX_ENCODE_INT
+        bytes += MixinBot.utils.encode_uint16 Transaction::AGGREGATED_SIGNATURE_PREFIX
+        bytes += [@tx.aggregated['signature']].pack('H*').bytes
+
+        signers = @tx.aggregated['signers'] || []
+        if signers.empty?
+          bytes += Transaction::AGGREGATED_SIGNATURE_ORDINAY_MASK
+          bytes += Transaction::NULL_BYTES
+          return bytes
+        end
+
+        signers.each_with_index do |sig, i|
+          raise ArgumentError, 'signers not sorted' if i.positive? && sig <= signers[i - 1]
+          raise ArgumentError, 'signers not sorted' if sig > Transaction::MAX_ENCODE_INT
+        end
+
+        max = signers.last
+        sig_byte_len = [@tx.aggregated['signature']].pack('H*').bytes.size
+        if ((max / 8) + 1) > sig_byte_len
+          bytes += Transaction::AGGREGATED_SIGNATURE_SPARSE_MASK
+          bytes += MixinBot.utils.encode_uint16 signers.size
+          signers.each { |signer| bytes += MixinBot.utils.encode_uint16(signer) }
+        else
+          masks_bytes = Array.new((max / 8) + 1, 0)
+          signers.each do |signer|
+            masks_bytes[signer / 8] ^= (1 << (signer % 8))
+          end
+          bytes += Transaction::AGGREGATED_SIGNATURE_ORDINAY_MASK
+          bytes += MixinBot.utils.encode_uint16 masks_bytes.size
+          bytes += masks_bytes
+        end
+
+        bytes
+      end
+
+      def encode_signatures
+        bytes = []
+
+        sl =
+          if @tx.signatures.is_a? Array
+            @tx.signatures.size
+          else
+            0
+          end
+
+        raise ArgumentError, 'signatures overflow' if sl == Transaction::MAX_ENCODE_INT
+
+        bytes += MixinBot.utils.encode_uint16 sl
+
+        if sl.positive?
+          @tx.signatures.each do |signature|
+            bytes += MixinBot.utils.encode_uint16 signature.keys.size
+
+            signature.keys.sort.each do |key|
+              signature_bytes = [signature[key]].pack('H*').bytes
+              raise ArgumentError, 'Signature should be 64 bytes' if signature_bytes.size != 64
+
+              bytes += MixinBot.utils.encode_uint16 key
+              bytes += signature_bytes
+            end
+          end
+        end
+
+        bytes
+      end
+    end
+  end
+end