mixin_bot 1.4.0 → 2.0.0

data/lib/mixin_bot/transaction.rb

@@ -29,127 +29,11 @@ module MixinBot
     end
 
     def encode
-      raise InvalidTransactionFormatError, 'asset is required' if asset.blank?
-      raise InvalidTransactionFormatError, 'inputs is required' if inputs.blank?
-      raise InvalidTransactionFormatError, 'outputs is required' if outputs.blank?
-
-      bytes = []
-
-      # magic number
-      bytes += MAGIC
-
-      # version
-      bytes += [0, version]
-
-      # asset
-      bytes += [asset].pack('H*').bytes
-
-      # inputs
-      bytes += encode_inputs
-
-      # output
-      bytes += encode_outputs
-
-      # placeholder for `references`
-      bytes += encode_references if version >= REFERENCES_TX_VERSION
-
-      # extra
-      extra_bytes = extra.bytes
-      raise InvalidTransactionFormatError, 'extra is too long' if extra_bytes.size > MAX_EXTRA_SIZE
-
-      bytes += MixinBot.utils.encode_uint32 extra_bytes.size
-      bytes += extra_bytes
-
-      # aggregated
-      bytes += if aggregated.nil?
-                 # signatures
-                 encode_signatures
-               else
-                 encode_aggregated_signature
-               end
-
-      @hash = SHA3::Digest::SHA256.hexdigest bytes.pack('C*')
-      @hex = bytes.pack('C*').unpack1('H*')
-
-      self
+      Encoder.new(self).encode
     end
 
     def decode
-      @bytes = [hex].pack('H*').bytes
-      @hash = SHA3::Digest::SHA256.hexdigest @bytes.pack('C*')
-
-      magic = @bytes.shift(2)
-      raise ArgumentError, 'Not valid raw' unless magic == MAGIC
-
-      _version = @bytes.shift(2)
-      @version = MixinBot.utils.decode_int _version
-
-      asset = @bytes.shift(32)
-      @asset = asset.pack('C*').unpack1('H*')
-
-      # read inputs
-      decode_inputs
-
-      # read outputs
-      decode_outputs
-
-      # read references
-      decode_references if version >= REFERENCES_TX_VERSION
-
-      # read extra
-      # unsigned 32 endian for extra size
-      extra_size = MixinBot.utils.decode_uint32 @bytes.shift(4)
-      @extra = @bytes.shift(extra_size).pack('C*')
-
-      num = MixinBot.utils.decode_uint16 @bytes.shift(2)
-      if num == MAX_ENCODE_INT
-        # aggregated
-        @aggregated = {}
-
-        raise ArgumentError, 'invalid aggregated' unless MixinBot.utils.decode_uint16(@bytes.shift(2)) == AGGREGATED_SIGNATURE_PREFIX
-
-        @aggregated['signature'] = @bytes.shift(64).pack('C*').unpack1('H*')
-
-        byte = @bytes.shift
-        case byte
-        when AGGREGATED_SIGNATURE_ORDINAY_MASK.first
-          @aggregated['signers'] = []
-          masks_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
-          masks = @bytes.shift(masks_size)
-          masks = Array(masks)
-
-          masks.each_with_index do |mask, i|
-            8.times do |j|
-              k = 1 << j
-              aggregated['signers'].push((i * 8) + j) if mask & k == k
-            end
-          end
-        when AGGREGATED_SIGNATURE_SPARSE_MASK.first
-          signers_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
-          return if signers_size.zero?
-
-          aggregated['signers'] = []
-          signers_size.times do
-            aggregated['signers'].push MixinBot.utils.decode_uint16(@bytes.shift(2))
-          end
-        end
-      elsif num.present? && num.positive? && @bytes.size.positive?
-        @signatures = []
-        num.times do
-          signature = {}
-
-          keys_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
-
-          keys_size.times do
-            index = MixinBot.utils.decode_uint16 @bytes.shift(2)
-            signature[index] = @bytes.shift(64).pack('C*').unpack1('H*')
-          end
-
-          @signatures << signature
-        end
-      end
-
-      self
+      Decoder.new(self).decode
     end
 
     def to_h
@@ -165,362 +49,9 @@ module MixinBot
         references:
       }.compact
     end
-
-    private
-
-    def encode_inputs
-      bytes = []
-
-      bytes += MixinBot.utils.encode_uint16(inputs.size)
-
-      inputs.each do |input|
-        bytes += [input['hash']].pack('H*').bytes
-        bytes += MixinBot.utils.encode_uint16(input['index'])
-
-        # genesis
-        genesis = input['genesis'] || ''
-        if genesis.empty?
-          bytes += NULL_BYTES
-        else
-          genesis_bytes = [genesis].pack('H*').bytes
-          bytes += MixinBot.utils.encode_uint16 genesis_bytes.size
-          bytes += genesis_bytes
-        end
-
-        # deposit
-        deposit = input['deposit']
-        if deposit.nil?
-          bytes += NULL_BYTES
-        else
-          bytes += MAGIC
-          bytes += [deposit['chain']].pack('H*').bytes
-
-          asset_bytes = [deposit['asset']].pack('H*')
-          bytes += MixinBot.utils.encode_uint16 asset_bytes.size
-          bytes += asset_bytes
-
-          transaction_bytes = [deposit['transaction']].pack('H*')
-          bytes += MixinBot.utils.encode_uint16 transaction_bytes.size
-          bytes += transaction_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
-        mint = input['mint']
-        if mint.nil?
-          bytes += NULL_BYTES
-        else
-          bytes += MAGIC
-
-          # group
-          group = mint['group'] || ''
-          if group.empty?
-            bytes += MixinBot.utils.encode_uint16 NULL_BYTES
-          else
-            group_bytes = [group].pack('H*')
-            bytes += MixinBot.utils.encode_uint16 group_bytes.size
-            bytes += group_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 outputs.size
-
-      outputs.each do |output|
-        type = output['type'] || 0
-        bytes += [0x00, type]
-
-        # amount
-        amount_bytes = MixinBot.utils.encode_int (output['amount'].to_d * 1e8).round
-        bytes +=  MixinBot.utils.encode_uint16 amount_bytes.size
-        bytes +=  amount_bytes
-
-        # keys
-        bytes +=  MixinBot.utils.encode_uint16 output['keys'].size
-        output['keys'].each do |key|
-          bytes += [key].pack('H*').bytes
-        end
-
-        # mask
-        bytes += [output['mask']].pack('H*').bytes
-
-        # script
-        script_bytes = [output['script']].pack('H*').bytes
-        bytes += MixinBot.utils.encode_uint16 script_bytes.size
-        bytes += script_bytes
-
-        # withdrawal
-        withdrawal = output['withdrawal']
-        if withdrawal.nil?
-          bytes += NULL_BYTES
-        else
-          bytes += MAGIC
-
-          # chain
-          bytes += [withdrawal['chain']].pack('H*').bytes
-
-          # asset
-          @asset_bytes = [withdrawal['asset']].pack('H*')
-          bytes += MixinBot.utils.encode_uint16 asset_bytes.size
-          bytes += asset_bytes
-
-          # address
-          address = withdrawal['address'] || ''
-          if address.empty?
-            bytes += NULL_BYTES
-          else
-            address_bytes = [address].pack('H*').bytes
-            bytes += MixinBot.utils.encode_uint16 address.size
-            bytes += address_bytes
-          end
-
-          # tag
-          tag = withdrawal['tag'] || ''
-          if tag.empty?
-            bytes += NULL_BYTES
-          else
-            address_bytes = [tag].pack('H*').bytes
-            bytes += MixinBot.utils.encode_uint16 tag.size
-            bytes += address_bytes
-          end
-        end
-      end
-
-      bytes
-    end
-
-    def encode_references
-      bytes = []
-
-      bytes += MixinBot.utils.encode_uint16 references.size
-
-      references.each do |reference|
-        bytes += [reference].pack('H*').bytes
-      end
-
-      bytes
-    end
-
-    def encode_aggregated_signature
-      bytes = []
-
-      bytes += MixinBot.utils.encode_uint16 MAX_ENCODE_INT
-      bytes += MixinBot.utils.encode_uint16 AGGREGATED_SIGNATURE_PREFIX
-      bytes += [aggregated['signature']].pack('H*').bytes
-
-      signers = aggregated['signers']
-      if signers.empty?
-        bytes += AGGREGATED_SIGNATURE_ORDINAY_MASK
-        bytes += NULL_BYTES
-      else
-        signers.each do |sig, i|
-          raise ArgumentError, 'signers not sorted' if i.positive? && sig <= signers[i - 1]
-          raise ArgumentError, 'signers not sorted' if sig > MAX_ENCODE_INT
-        end
-
-        max = signers.last
-        if ((((max / 8) | 0) + 1) | 0) > aggregated['signature'].size * 2
-          bytes += AGGREGATED_SIGNATURE_SPARSE_MASK
-          bytes += MixinBot.utils.encode_uint16 aggregated['signers'].size
-          signers.map(&->(signer) { bytes += MixinBot.utils.encode_uint16(signer) })
-        end
-
-        masks_bytes = Array.new((max / 8) + 1, 0)
-        signers.each do |signer|
-          masks[signer / 8] = masks[signer / 8] ^ (1 << (signer % 8))
-        end
-        bytes += AGGREGATED_SIGNATURE_ORDINAY_MASK
-        bytes += MixinBot.utils.encode_uint16 masks_bytes.size
-        bytes += masks_bytes
-      end
-
-      bytes
-    end
-
-    def encode_signatures
-      bytes = []
-
-      sl =
-        if signatures.is_a? Array
-          signatures.size
-        else
-          0
-        end
-
-      raise ArgumentError, 'signatures overflow' if sl == MAX_ENCODE_INT
-
-      bytes += MixinBot.utils.encode_uint16 sl
-
-      if sl.positive?
-        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
-
-    def decode_inputs
-      inputs_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
-      @inputs = []
-      inputs_size.times do
-        input = {}
-        hash = @bytes.shift(32)
-        input['hash'] = hash.pack('C*').unpack1('H*')
-
-        index = @bytes.shift(2)
-        input['index'] = MixinBot.utils.decode_uint16 index
-
-        if @bytes[...2] == NULL_BYTES
-          @bytes.shift 2
-        else
-          genesis_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
-          genesis = @bytes.shift genesis_size
-          input['genesis'] = genesis.pack('C*').unpack1('H*')
-        end
-
-        if @bytes[...2] == NULL_BYTES
-          @bytes.shift 2
-        else
-          magic = @bytes.shift(2)
-          raise ArgumentError, 'Not valid input' unless magic == MAGIC
-
-          deposit = {}
-          deposit['chain'] = @bytes.shift(32).pack('C*').unpack1('H*')
-
-          asset_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
-          deposit['asset'] = @bytes.shift(asset_size).unpack1('H*')
-
-          transaction_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
-          deposit['transaction'] = @bytes.shift(transaction_size).unpack1('H*')
-
-          deposit['index'] = MixinBot.utils.decode_uint64 @bytes.shift(8)
-
-          amount_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
-          deposit['amount'] = MixinBot.utils.decode_int @bytes.shift(amount_size)
-
-          input['deposit'] = deposit
-        end
-
-        if @bytes[...2] == NULL_BYTES
-          @bytes.shift 2
-        else
-          magic = @bytes.shift(2)
-          raise ArgumentError, 'Not valid input' unless magic == MAGIC
-
-          mint = {}
-          if bytes[...2] == NULL_BYTES
-            @bytes.shift 2
-          else
-            group_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
-            mint['group'] = @bytes.shift(group_size).unpack1('H*')
-          end
-
-          mint['batch'] = MixinBot.utils.decode_uint64 @bytes.shift(8)
-          _amount_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
-          mint['amount'] = MixinBot.utils.decode_int bytes.shift(_amount_size)
-
-          input['mint'] = mint
-        end
-
-        @inputs.push input
-      end
-
-      self
-    end
-
-    def decode_outputs
-      outputs_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
-      @outputs = []
-      outputs_size.times do
-        output = {}
-
-        @bytes.shift
-        type = @bytes.shift
-        output['type'] = type
-
-        amount_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
-        output['amount'] = format('%.8f', MixinBot.utils.decode_int(@bytes.shift(amount_size)).to_f / 1e8).gsub(/\.?0+$/, '')
-
-        output['keys'] = []
-        keys_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
-        keys_size.times do
-          output['keys'].push @bytes.shift(32).pack('C*').unpack1('H*')
-        end
-
-        output['mask'] = @bytes.shift(32).pack('C*').unpack1('H*')
-
-        script_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
-        output['script'] = @bytes.shift(script_size).pack('C*').unpack1('H*')
-
-        if @bytes[...2] == NULL_BYTES
-          @bytes.shift 2
-        else
-          magic = @bytes.shift(2)
-          raise ArgumentError, 'Not valid output' unless magic == MAGIC
-
-          output['chain'] = @bytes.shift(32).pack('C*').unpack1('H*')
-
-          asset_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
-          output['asset'] = @bytes.shift(asset_size).unpack1('H*')
-
-          if @bytes[...2] == NULL_BYTES
-            @bytes.shift 2
-          else
-
-            adderss_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
-            output['adderss'] = @bytes.shift(adderss_size).pack('C*').unpack1('H*')
-          end
-
-          if @bytes[...2] == NULL_BYTES
-            @bytes.shift 2
-          else
-
-            tag_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
-            output['tag'] = @bytes.shift(tag_size).pack('C*').unpack1('H*')
-          end
-        end
-
-        @outputs.push output
-      end
-
-      self
-    end
-
-    def decode_references
-      references_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
-      @references = []
-
-      references_size.times do
-        @references.push @bytes.shift(32).pack('C*').unpack1('H*')
-      end
-
-      self
-    end
   end
 end
+
+require_relative 'transaction/buffer'
+require_relative 'transaction/encoder'
+require_relative 'transaction/decoder'

data/lib/mixin_bot/url_scheme.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module MixinBot
+  # Deep link URL schemes (parity with Go url_scheme.go).
+  module UrlScheme
+    SCHEME = 'mixin'
+
+    module_function
+
+    def scheme_users(user_id)
+      URI("#{SCHEME}://users/#{user_id}").to_s
+    end
+
+    def scheme_transfer(user_id)
+      URI("#{SCHEME}://transfer/#{user_id}").to_s
+    end
+
+    def scheme_pay(asset_id:, trace_id:, recipient_id:, memo:, amount:)
+      q = URI.encode_www_form(
+        asset: asset_id,
+        trace: trace_id,
+        amount: amount.to_s,
+        recipient: recipient_id,
+        memo: memo.to_s
+      )
+      "#{SCHEME}://pay?#{q}"
+    end
+
+    def scheme_codes(code_id)
+      URI("#{SCHEME}://codes/#{code_id}").to_s
+    end
+
+    def scheme_snapshots(snapshot_id: nil, trace_id: nil)
+      u = URI("#{SCHEME}://snapshots")
+      u.path = "/#{snapshot_id}" if snapshot_id.present?
+      u.query = URI.encode_www_form(trace: trace_id) if trace_id.present?
+      u.to_s
+    end
+
+    def scheme_conversations(conversation_id: nil, user_id: nil)
+      u = URI("#{SCHEME}://conversations")
+      u.path = "/#{conversation_id}" if conversation_id.present?
+      u.query = URI.encode_www_form(user: user_id) if user_id.present?
+      u.to_s
+    end
+
+    def scheme_apps(app_id:, action: nil, params: {})
+      u = URI("#{SCHEME}://apps/#{app_id}")
+      q = { action: action.presence || 'open' }.merge(params || {})
+      u.query = URI.encode_www_form(q)
+      u.to_s
+    end
+
+    def scheme_send(category:, data: nil, conversation_id: nil)
+      q = { category: category.to_s }
+      q[:data] = URI.encode_www_form_component(Base64.strict_encode64(data)) if data.present?
+      q[:conversation] = conversation_id if conversation_id.present?
+      "#{SCHEME}://send?#{URI.encode_www_form(q)}"
+    end
+  end
+end

data/lib/mixin_bot/utils/address.rb

@@ -3,89 +3,27 @@
 module MixinBot
   module Utils
     module Address
-      MAIN_ADDRESS_PREFIX = 'XIN'
-      MIX_ADDRESS_PREFIX = 'MIX'
-      MIX_ADDRESS_VERSION = 2
+      MAIN_ADDRESS_PREFIX = MixinBot::MAIN_ADDRESS_PREFIX
+      MIX_ADDRESS_PREFIX = MixinBot::MIX_ADDRESS_PREFIX
+      MIX_ADDRESS_VERSION = MixinBot::MIX_ADDRESS_VERSION
 
       def build_main_address(public_key)
-        msg = MAIN_ADDRESS_PREFIX + public_key
-        checksum = SHA3::Digest::SHA256.digest msg
-        data = public_key + checksum[0...4]
-        base58 = Base58.binary_to_base58 data, :bitcoin
-        "#{MAIN_ADDRESS_PREFIX}#{base58}"
+        MainAddress.new(public_key:).address
       end
 
       def parse_main_address(address)
-        raise ArgumentError, 'invalid address' unless address.start_with? MAIN_ADDRESS_PREFIX
-
-        data = address[MAIN_ADDRESS_PREFIX.length..]
-        data = Base58.base58_to_binary data, :bitcoin
-
-        payload = data[...-4]
-
-        msg = MAIN_ADDRESS_PREFIX + payload
-        checksum = SHA3::Digest::SHA256.digest msg
-
-        raise ArgumentError, 'invalid address' unless checksum[0...4] == data[-4..]
-
-        payload
+        MainAddress.new(address:).public_key
       end
 
       def build_mix_address(members:, threshold:)
-        raise ArgumentError, 'members should be an array' unless members.is_a? Array
-        raise ArgumentError, 'members should not be empty' if members.empty?
-        raise ArgumentError, 'members length should less than 256' if members.length > 255
-
-        # raise ArgumentError, "invalid threshold: #{threshold}" if threshold > members.length
-
-        prefix = [MIX_ADDRESS_VERSION].pack('C*') + [threshold].pack('C*') + [members.length].pack('C*')
-
-        members = members.sort
-        msg =
-          if members.all?(&->(member) { member.start_with? MAIN_ADDRESS_PREFIX })
-            members.map(&->(member) { parse_main_address(member) }).join
-          elsif members.none?(&->(member) { member.start_with? MAIN_ADDRESS_PREFIX })
-            members.map(&->(member) { MixinBot::UUID.new(hex: member).packed }).join
-          else
-            raise ArgumentError, 'invalid members'
-          end
-
-        checksum = SHA3::Digest::SHA256.digest(MIX_ADDRESS_PREFIX + prefix + msg)
-
-        data = prefix + msg + checksum[0...4]
-        data = Base58.binary_to_base58 data, :bitcoin
-        "#{MIX_ADDRESS_PREFIX}#{data}"
+        MixAddress.from_members(members:, threshold:).address
       end
 
       def parse_mix_address(address)
-        raise ArgumentError, 'invalid address' unless address.start_with? MIX_ADDRESS_PREFIX
-
-        data = address[MIX_ADDRESS_PREFIX.length..]
-        data = Base58.base58_to_binary data, :bitcoin
-        raise ArgumentError, 'invalid address, length invalid' if data.length < 3 + 16 + 4
-
-        msg = data[...-4]
-        checksum = SHA3::Digest::SHA256.digest((MIX_ADDRESS_PREFIX + msg))[0...4]
-
-        raise ArgumentError, 'invalid address, checksum invalid' unless checksum[0...4] == data[-4..]
-
-        version = data[0].ord
-        raise ArgumentError, 'invalid address, version invalid' unless version == MIX_ADDRESS_VERSION
-
-        threshold = data[1].ord
-        members_count = data[2].ord
-
-        if data[3...-4].length == members_count * 16
-          members = data[3...-4].chars.each_slice(16).map(&:join)
-          members = members.map(&->(member) { MixinBot::UUID.new(raw: member).unpacked })
-        else
-          members = data[3...-4].chars.each_slice(64).map(&:join)
-          members = members.map(&->(member) { build_main_address(member) })
-        end
-
+        ma = MixAddress.parse(address)
         {
-          members:,
-          threshold:
+          members: ma.uuid_members + ma.xin_members,
+          threshold: ma.threshold
         }
       end
 
@@ -106,16 +44,15 @@ module MixinBot
       end
 
       def burning_address
-        seed = "\0" * 64
-
-        digest1 = SHA3::Digest::SHA256.digest seed
-        digest2 = SHA3::Digest::SHA256.digest digest1
-        src = digest1 + digest2
-
-        spend_key = MixinBot::Utils.shared_public_key(seed)
-        view_key = MixinBot::Utils.shared_public_key(src)
+        MainAddress.burning_address.address
+      end
 
-        MixinBot::Utils.build_main_address spend_key + view_key
+      ##
+      # Sorted-member hash used by Safe outputs and legacy collectible listing (Go +HashMembers+).
+      #
+      def hash_members(ids)
+        list = Array(ids).flatten.compact.map(&:to_s).sort
+        SHA3::Digest::SHA256.hexdigest(list.join)
       end
     end
   end