mixin_bot 1.2.5 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d8959688a23470a6e5b519296e308303f4472b70a1e745a2ea96848dcca5637
-  data.tar.gz: a6a156066efc6e22c2ff114fb3b576e4812c4d7d742571797df63f62a90f62a4
+  metadata.gz: 436b9a0d785744f840ab00dbb6643a372fcba52a1a2091c8c86f9fd1e0c08b30
+  data.tar.gz: 895cd928e05c763ef9452ab564ceb357a1c512f52ce7b57ca69b7067380d7233
 SHA512:
-  metadata.gz: dda145b430e0b48e62bec64c7089a0d379ae3ab455665065ab0241b9a9b1d64a3b54e8c5e2e8ffd5876a59fdf476b8ea2839715e0b1a1b6925cfe8f2b619e496
-  data.tar.gz: 04a814af13e12a4a9d5655ec2c8e118c1447c4c5fda7293f0b9bf2a04ca317da1795a65ce4e32bd8c25c81e70ce8b249255b43a20328844a9f6109a699bbb944
+  metadata.gz: c9d2183496bde43efaed75052508ad9791bcf5c3842709a764bac499815d817a8b3222a602ba0f6140b624855aaf3c88f08e945cb19e6ede0f290b2c308edb57
+  data.tar.gz: c085749d2fc91b1aa9104d48e46eb1cfd4a765b18c8c7095e71f11b714d8572dff05f03e69f51e5a67d3f196ca6cc8b0c49ee63db76452940a2d1f9ccd9f4c0c

data/lib/mixin_bot/address.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module MixinBot
+  MAIN_ADDRESS_PREFIX = 'XIN'
+  MIX_ADDRESS_PREFIX = 'MIX'
+  MIX_ADDRESS_VERSION = 2
+  UUID_ADDRESS_LENGTH = 16
+  MAIN_ADDRESS_LENGTH = 64
+
+  class MixAddress
+    attr_accessor :version, :uuid_members, :xin_members, :threshold, :address, :payload
+
+    def initialize(**args)
+      args = args.with_indifferent_access
+
+      if args[:address]
+        @address = args[:address]
+        decode
+      elsif args[:payload]
+        @payload = args[:payload]
+        decode
+      else
+        @version = args[:version] || MIX_ADDRESS_VERSION
+
+        if args[:members].present?
+          @uuid_members = args[:members].reject { |member| member.start_with?(MAIN_ADDRESS_PREFIX) }
+          @xin_members = args[:members].select { |member| member.start_with? MAIN_ADDRESS_PREFIX }
+        else
+          @uuid_members = args[:uuid_members] || []
+          @xin_members = args[:xin_members] || []
+        end
+
+        @uuid_members = @uuid_members.sort
+        @xin_members = @xin_members.sort
+
+        @threshold = args[:threshold]
+        encode
+      end
+
+      raise ArgumentError, 'invalid address' unless valid?
+    end
+
+    def valid?
+      address.present? && (uuid_members.present? || xin_members.present?) && threshold.present?
+    end
+
+    def to_safe_recipient
+      {
+        members: uuid_members + xin_members,
+        threshold:,
+        amount:,
+        mix_address: address
+      }
+    end
+
+    def encode
+      raise ArgumentError, 'members should be an array' unless uuid_members.is_a?(Array) || xin_members.is_a?(Array)
+      raise ArgumentError, 'members should not be empty' if uuid_members.empty? && xin_members.empty?
+      raise ArgumentError, 'members length should less than 256' if uuid_members.length + xin_members.length > 255
+      raise ArgumentError, "invalid threshold: #{threshold}" if threshold > (uuid_members.length + xin_members.length)
+
+      prefix =
+        [version].pack('C*') +
+        [threshold].pack('C*') +
+        [uuid_members.length + xin_members.length].pack('C*')
+      msg =
+        uuid_members&.map(&->(member) { MixinBot::UUID.new(hex: member).packed })&.join.to_s +
+        xin_members&.map(&->(member) { MainAddress.new(address: member).public_key })&.join.to_s
+
+      self.payload = prefix + msg
+
+      checksum = SHA3::Digest::SHA256.digest(MIX_ADDRESS_PREFIX + payload)
+      data = payload + checksum[0...4]
+      data = Base58.binary_to_base58 data, :bitcoin
+      self.address = "#{MIX_ADDRESS_PREFIX}#{data}"
+
+      address
+    end
+
+    def decode
+      if address.present?
+        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
+
+        self.payload = data[...-4]
+        checksum = SHA3::Digest::SHA256.digest(MIX_ADDRESS_PREFIX + payload)[0...4]
+        raise ArgumentError, 'invalid address, checksum invalid' unless checksum == data[-4..]
+      else
+        checksum = SHA3::Digest::SHA256.digest(MIX_ADDRESS_PREFIX + payload)[0...4]
+        data = payload + checksum
+        data = Base58.binary_to_base58 data, :bitcoin
+        self.address = "#{MIX_ADDRESS_PREFIX}#{data}"
+      end
+
+      self.version = payload[0].ord
+      raise ArgumentError, 'invalid address, version invalid' unless version.is_a?(Integer)
+
+      self.threshold = payload[1].ord
+      raise ArgumentError, 'invalid address, threshold invalid' unless threshold.is_a?(Integer)
+
+      members_count = payload[2].ord
+      raise ArgumentError, 'invalid address, members count invalid' unless members_count.is_a?(Integer)
+
+      if payload[3...].length == members_count * UUID_ADDRESS_LENGTH
+        uuid_members = payload[3...].chars.each_slice(UUID_ADDRESS_LENGTH).map(&:join)
+        self.uuid_members = uuid_members.map(&->(member) { MixinBot::UUID.new(raw: member).unpacked })
+        self.xin_members = []
+      else
+        xin_members = payload[3...].chars.each_slice(MAIN_ADDRESS_LENGTH).map(&:join)
+        self.xin_members = xin_members.map(&->(member) { MainAddress.new(public_key: member).address })
+        self.uuid_members = []
+      end
+    end
+  end
+
+  class MainAddress
+    attr_accessor :public_key, :address
+
+    def initialize(**args)
+      if args[:address]
+        @address = args[:address]
+        decode
+      else
+        @public_key = args[:public_key]
+        encode
+      end
+    end
+
+    def encode
+      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
+      self.address = "#{MAIN_ADDRESS_PREFIX}#{base58}"
+
+      address
+    end
+
+    def decode
+      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..]
+
+      self.public_key = payload
+
+      public_key
+    end
+
+    def self.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.new(public_key: spend_key + view_key)
+    end
+  end
+end

data/lib/mixin_bot/api/message.rb

@@ -95,7 +95,10 @@ module MixinBot
 
       # read the gzipped message form websocket
       def ws_message(data)
-        io = StringIO.new(data.pack('c*'), 'rb')
+        data = data.pack('c*') if data.is_a?(Array)
+        raise MixinBot::ArgumentError, 'data should be String or Array of integer' unless data.is_a?(String)
+
+        io = StringIO.new(data, 'rb')
         gzip = Zlib::GzipReader.new io
         msg = gzip.read
         gzip.close

data/lib/mixin_bot/invoice.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class Invoice
+    INVOICE_PREFIX = 'MIN'
+    INVOICE_VERSION = 0x00
+
+    attr_accessor :version, :recipient, :entries, :address
+
+    def initialize(**args)
+      args = args.with_indifferent_access
+
+      if args[:address]
+        @address = args[:address]
+        decode
+      else
+        @version = args[:version] || INVOICE_VERSION
+        @recipient = args[:recipient]
+        @entries = args[:entries] || []
+        encode
+      end
+    end
+
+    def to_hash
+      {
+        version:,
+        address:,
+        recipient: recipient.address,
+        entries: entries.map(&:to_hash)
+      }
+    end
+
+    def encode
+      # Start with empty payload
+      payload = []
+
+      # Add version
+      payload += MixinBot.utils.encode_int(version)
+
+      # Add recipient - ensure we're using the raw payload bytes
+      recipient_payload = recipient.payload
+      recipient_bytes = recipient_payload.is_a?(String) ? recipient_payload.bytes : recipient_payload
+      payload += MixinBot.utils.encode_uint16(recipient_bytes.size)
+
+      payload += recipient_bytes
+
+      # Add entries
+      payload += MixinBot.utils.encode_int(entries.size)
+      entries.each do |entry|
+        payload += entry.encode
+      end
+
+      # Convert payload to binary string
+      payload = payload.pack('C*')
+
+      # Calculate checksum
+      checksum = SHA3::Digest::SHA256.digest(INVOICE_PREFIX + payload)[0...4]
+
+      # Combine everything and encode to base64
+      self.address = INVOICE_PREFIX + Base64.urlsafe_encode64(payload + checksum, padding: false)
+    end
+
+    def decode
+      prefix = address[0..2]
+      raise MixinBot::InvalidInvoiceFormatError, 'invalid invoice prefix' unless prefix == INVOICE_PREFIX
+
+      data = Base64.urlsafe_decode64(address[3..])
+      raise MixinBot::InvalidInvoiceFormatError, 'invalid invoice payload size' if data.size < 3 + 23 + 1
+
+      payload = data[...-4]
+      checksum = SHA3::Digest::SHA256.digest(INVOICE_PREFIX + payload)[0...4]
+      raise MixinBot::InvalidInvoiceFormatError, 'invalid invoice checksum' unless checksum == data[-4..]
+
+      payload = payload.bytes
+
+      # Read version
+      self.version = MixinBot.utils.decode_int payload.shift(1)
+      raise MixinBot::InvalidInvoiceFormatError, 'invalid invoice version' unless version == INVOICE_VERSION
+
+      # Read recipient with proper size handling
+      recipient_size = MixinBot.utils.decode_uint16 payload.shift(2)
+      recipient_bytes = payload.shift(recipient_size)
+      self.recipient = MixinBot::MixAddress.new(payload: recipient_bytes.pack('C*'))
+
+      # decode entries
+      entries_size = MixinBot.utils.decode_int payload.shift(1)
+      entries = []
+      entries_size.times do
+        next if payload.empty?
+
+        trace_id_bytes = payload.shift(16)
+        trace_id = MixinBot::UUID.new(raw: trace_id_bytes.pack('C*')).unpacked
+
+        asset_id_bytes = payload.shift(16)
+        asset_id = MixinBot::UUID.new(raw: asset_id_bytes.pack('C*')).unpacked
+
+        amount_size = MixinBot.utils.decode_int payload.shift(1)
+        amount_bytes = payload.shift(amount_size)
+        amount = amount_bytes.pack('C*').to_d
+
+        extra_size = MixinBot.utils.decode_int payload.shift(2)
+        extra = payload.shift(extra_size).pack('C*')
+
+        references_count = MixinBot.utils.decode_int payload.shift(1)
+        hash_references = []
+        index_references = []
+
+        references_count.times do
+          rv = MixinBot.utils.decode_int payload.shift(1)
+          case rv
+          when 0
+            hash_references << payload.shift(32).pack('C*').unpack1('H*')
+          when 1
+            index_references << MixinBot.utils.decode_int(payload.shift(1))
+          else
+            raise MixinBot::InvalidInvoiceFormatError, "invalid invoice reference type: #{rv}"
+          end
+        end
+
+        entries << InvoiceEntry.new(trace_id:, asset_id:, amount:, extra:, index_references:, hash_references:)
+      end
+
+      self.entries = entries
+    end
+  end
+
+  class InvoiceEntry
+    attr_accessor :trace_id, :asset_id, :amount, :extra, :index_references, :hash_references
+
+    def initialize(**args)
+      args = args.with_indifferent_access
+
+      @trace_id = args[:trace_id]
+      @asset_id = args[:asset_id]
+      @amount = args[:amount].to_d
+      @extra = args[:extra]
+      @index_references = args[:index_references]
+      @hash_references = args[:hash_references]
+    end
+
+    def encode
+      bytes = []
+
+      bytes += MixinBot::UUID.new(hex: trace_id).packed.bytes
+      bytes += MixinBot::UUID.new(hex: asset_id).packed.bytes
+
+      amount_string = amount.to_d.to_s('F')
+      amount_bytes = amount_string.bytes
+      bytes += MixinBot.utils.encode_int(amount_bytes.size)
+      bytes += amount_bytes
+
+      extra_bytes = extra.bytes
+      bytes += MixinBot.utils.encode_uint16(extra_bytes.size)
+      bytes += extra_bytes
+
+      references_count = (index_references || []).size + (hash_references || []).size
+      bytes += MixinBot.utils.encode_int(references_count)
+
+      index_references&.each do |index|
+        bytes += MixinBot.utils.encode_int(1)
+        bytes += MixinBot.utils.encode_int(index)
+      end
+
+      hash_references&.each do |hash|
+        bytes += MixinBot.utils.encode_int(0)
+        bytes += [hash].pack('H*').bytes
+      end
+
+      bytes
+    end
+
+    def to_hash
+      {
+        trace_id:,
+        asset_id:,
+        amount:,
+        extra:,
+        index_references:,
+        hash_references:
+      }
+    end
+  end
+end

data/lib/mixin_bot/utils/decoder.rb

@@ -40,12 +40,9 @@ module MixinBot
       end
 
       def decode_int(bytes)
-        int = 0
-        bytes.each do |byte|
-          int = (int * (2**8)) + byte
-        end
+        raise ArgumentError, "only support bytes #{bytes}" unless bytes.is_a?(Array)
 
-        int
+        bytes.reduce(0) { |sum, byte| (sum << 8) + byte }
       end
 
       def hex_to_uuid(hex)

data/lib/mixin_bot/utils/encoder.rb

@@ -41,11 +41,15 @@ module MixinBot
         raise ArgumentError, 'not integer' unless int.is_a?(Integer)
 
         bytes = []
-        loop do
-          break if int.zero?
+        if int.zero?
+          bytes.push(0)
+        else
+          loop do
+            break if int.zero?
 
-          bytes.push int & 255
-          int = (int / (2**8)) | 0
+            bytes.push int & 255
+            int = (int / (2**8)) | 0
+          end
         end
 
         bytes.reverse

data/lib/mixin_bot/uuid.rb

@@ -5,6 +5,8 @@ module MixinBot
     attr_accessor :hex, :raw
 
     def initialize(**args)
+      args = args.with_indifferent_access
+
       @hex = args[:hex]
       @raw = args[:raw]
 

data/lib/mixin_bot/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MixinBot
-  VERSION = '1.2.5'
+  VERSION = '1.3.1'
 end

data/lib/mixin_bot.rb

@@ -20,8 +20,10 @@ require 'openssl'
 require 'rbnacl'
 require 'sha3'
 
+require_relative 'mixin_bot/address'
 require_relative 'mixin_bot/api'
 require_relative 'mixin_bot/cli'
+require_relative 'mixin_bot/invoice'
 require_relative 'mixin_bot/utils'
 require_relative 'mixin_bot/nfo'
 require_relative 'mixin_bot/uuid'
@@ -70,4 +72,5 @@ module MixinBot
   class InvalidUuidFormatError < Error; end
   class InvalidTransactionFormatError < Error; end
   class ConfigurationNotValidError < Error; end
+  class InvalidInvoiceFormatError < Error; end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: mixin_bot
 version: !ruby/object:Gem::Version
-  version: 1.2.5
+  version: 1.3.1
 platform: ruby
 authors:
 - an-lee
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-21 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -245,6 +244,7 @@ files:
 - MIT-LICENSE
 - bin/mixinbot
 - lib/mixin_bot.rb
+- lib/mixin_bot/address.rb
 - lib/mixin_bot/api.rb
 - lib/mixin_bot/api/address.rb
 - lib/mixin_bot/api/app.rb
@@ -281,6 +281,7 @@ files:
 - lib/mixin_bot/cli/utils.rb
 - lib/mixin_bot/client.rb
 - lib/mixin_bot/configuration.rb
+- lib/mixin_bot/invoice.rb
 - lib/mixin_bot/nfo.rb
 - lib/mixin_bot/transaction.rb
 - lib/mixin_bot/utils.rb
@@ -306,7 +307,6 @@ licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -321,8 +321,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.20
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A Ruby SDK for Mixin Nexwork
 test_files: []