mixin_bot 1.0.0 → 1.1.0

data/lib/mixin_bot/transaction.rb

@@ -51,13 +51,13 @@ module MixinBot
       bytes += encode_outputs
 
       # placeholder for `references`
-      bytes += NULL_BYTES if version >= REFERENCES_TX_VERSION
+      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_uint_32 extra_bytes.size
+      bytes += MixinBot.utils.encode_uint32 extra_bytes.size
       bytes += extra_bytes
 
       # aggregated
@@ -93,24 +93,20 @@ module MixinBot
       # read outputs
       decode_outputs
 
-      # TODO:
       # read references
-      if version >= REFERENCES_TX_VERSION
-        references_size = @bytes.shift 2
-        raise ArgumentError, 'Not support references yet' unless references_size == NULL_BYTES
-      end
+      decode_references if version >= REFERENCES_TX_VERSION
 
       # read extra
       # unsigned 32 endian for extra size
-      extra_size = MixinBot.utils.decode_uint_32 @bytes.shift(4)
+      extra_size = MixinBot.utils.decode_uint32 @bytes.shift(4)
       @extra = @bytes.shift(extra_size).pack('C*')
 
-      num = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+      num = MixinBot.utils.decode_uint16 @bytes.shift(2)
       if num == MAX_ENCODE_INT
         # aggregated
         @aggregated = {}
 
-        raise ArgumentError, 'invalid aggregated' unless MixinBot.utils.decode_uint_16(@bytes.shift(2)) == AGGREGATED_SIGNATURE_PREFIX
+        raise ArgumentError, 'invalid aggregated' unless MixinBot.utils.decode_uint16(@bytes.shift(2)) == AGGREGATED_SIGNATURE_PREFIX
 
         @aggregated['signature'] = @bytes.shift(64).pack('C*').unpack1('H*')
 
@@ -118,7 +114,7 @@ module MixinBot
         case byte
         when AGGREGATED_SIGNATURE_ORDINAY_MASK.first
           @aggregated['signers'] = []
-          masks_size = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+          masks_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
           masks = @bytes.shift(masks_size)
           masks = Array(masks)
 
@@ -129,12 +125,12 @@ module MixinBot
             end
           end
         when AGGREGATED_SIGNATURE_SPARSE_MASK.first
-          signers_size = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+          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_uint_16(@bytes.shift(2))
+            aggregated['signers'].push MixinBot.utils.decode_uint16(@bytes.shift(2))
           end
         end
       elsif num.present? && num.positive? && @bytes.size.positive?
@@ -142,10 +138,10 @@ module MixinBot
         num.times do
           signature = {}
 
-          keys_size = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+          keys_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
 
           keys_size.times do
-            index = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+            index = MixinBot.utils.decode_uint16 @bytes.shift(2)
             signature[index] = @bytes.shift(64).pack('C*').unpack1('H*')
           end
 
@@ -175,11 +171,11 @@ module MixinBot
     def encode_inputs
       bytes = []
 
-      bytes += MixinBot.utils.encode_uint_16(inputs.size)
+      bytes += MixinBot.utils.encode_uint16(inputs.size)
 
       inputs.each do |input|
         bytes += [input['hash']].pack('H*').bytes
-        bytes += MixinBot.utils.encode_uint_16(input['index'])
+        bytes += MixinBot.utils.encode_uint16(input['index'])
 
         # genesis
         genesis = input['genesis'] || ''
@@ -187,7 +183,7 @@ module MixinBot
           bytes += NULL_BYTES
         else
           genesis_bytes = [genesis].pack('H*').bytes
-          bytes += MixinBot.utils.encode_uint_16 genesis_bytes.size
+          bytes += MixinBot.utils.encode_uint16 genesis_bytes.size
           bytes += genesis_bytes
         end
 
@@ -200,17 +196,17 @@ module MixinBot
           bytes += [deposit['chain']].pack('H*').bytes
 
           asset_bytes = [deposit['asset']].pack('H*')
-          bytes += MixinBot.utils.encode_uint_16 asset_bytes.size
+          bytes += MixinBot.utils.encode_uint16 asset_bytes.size
           bytes += asset_bytes
 
           transaction_bytes = [deposit['transaction']].pack('H*')
-          bytes += MixinBot.utils.encode_uint_16 transaction_bytes.size
+          bytes += MixinBot.utils.encode_uint16 transaction_bytes.size
           bytes += transaction_bytes
 
-          bytes += MixinBot.utils.encode_uint_64 deposit['index']
+          bytes += MixinBot.utils.encode_uint64 deposit['index']
 
           amount_bytes = MixinBot.utils.bytes_of deposit['amount']
-          bytes +=  MixinBot.utils.encode_uint_16 amount_bytes.size
+          bytes +=  MixinBot.utils.encode_uint16 amount_bytes.size
           bytes +=  amount_bytes
         end
 
@@ -224,17 +220,17 @@ module MixinBot
           # group
           group = mint['group'] || ''
           if group.empty?
-            bytes += MixinBot.utils.encode_uint_16 NULL_BYTES
+            bytes += MixinBot.utils.encode_uint16 NULL_BYTES
           else
             group_bytes = [group].pack('H*')
-            bytes += MixinBot.utils.encode_uint_16 group_bytes.size
+            bytes += MixinBot.utils.encode_uint16 group_bytes.size
             bytes += group_bytes
           end
 
-          bytes += MixinBot.utils.encode_uint_64 mint['batch']
+          bytes += MixinBot.utils.encode_uint64 mint['batch']
 
           amount_bytes = MixinBot.utils.encode_int mint['amount']
-          bytes +=  MixinBot.utils.encode_uint_16 amount_bytes.size
+          bytes +=  MixinBot.utils.encode_uint16 amount_bytes.size
           bytes +=  amount_bytes
         end
       end
@@ -245,7 +241,7 @@ module MixinBot
     def encode_outputs
       bytes = []
 
-      bytes += MixinBot.utils.encode_uint_16 outputs.size
+      bytes += MixinBot.utils.encode_uint16 outputs.size
 
       outputs.each do |output|
         type = output['type'] || 0
@@ -253,11 +249,11 @@ module MixinBot
 
         # amount
         amount_bytes = MixinBot.utils.encode_int (output['amount'].to_d * 1e8).round
-        bytes +=  MixinBot.utils.encode_uint_16 amount_bytes.size
+        bytes +=  MixinBot.utils.encode_uint16 amount_bytes.size
         bytes +=  amount_bytes
 
         # keys
-        bytes +=  MixinBot.utils.encode_uint_16 output['keys'].size
+        bytes +=  MixinBot.utils.encode_uint16 output['keys'].size
         output['keys'].each do |key|
           bytes += [key].pack('H*').bytes
         end
@@ -267,7 +263,7 @@ module MixinBot
 
         # script
         script_bytes = [output['script']].pack('H*').bytes
-        bytes += MixinBot.utils.encode_uint_16 script_bytes.size
+        bytes += MixinBot.utils.encode_uint16 script_bytes.size
         bytes += script_bytes
 
         # withdrawal
@@ -282,7 +278,7 @@ module MixinBot
 
           # asset
           @asset_bytes = [withdrawal['asset']].pack('H*')
-          bytes += MixinBot.utils.encode_uint_16 asset_bytes.size
+          bytes += MixinBot.utils.encode_uint16 asset_bytes.size
           bytes += asset_bytes
 
           # address
@@ -291,7 +287,7 @@ module MixinBot
             bytes += NULL_BYTES
           else
             address_bytes = [address].pack('H*').bytes
-            bytes += MixinBot.utils.encode_uint_16 address.size
+            bytes += MixinBot.utils.encode_uint16 address.size
             bytes += address_bytes
           end
 
@@ -301,7 +297,7 @@ module MixinBot
             bytes += NULL_BYTES
           else
             address_bytes = [tag].pack('H*').bytes
-            bytes += MixinBot.utils.encode_uint_16 tag.size
+            bytes += MixinBot.utils.encode_uint16 tag.size
             bytes += address_bytes
           end
         end
@@ -310,11 +306,23 @@ module MixinBot
       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_uint_16 MAX_ENCODE_INT
-      bytes += MixinBot.utils.encode_uint_16 AGGREGATED_SIGNATURE_PREFIX
+      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']
@@ -330,8 +338,8 @@ module MixinBot
         max = signers.last
         if ((((max / 8) | 0) + 1) | 0) > aggregated['signature'].size * 2
           bytes += AGGREGATED_SIGNATURE_SPARSE_MASK
-          bytes += MixinBot.utils.encode_uint_16 aggregated['signers'].size
-          signers.map(&->(signer) { bytes += MixinBot.utils.encode_uint_16(signer) })
+          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)
@@ -339,7 +347,7 @@ module MixinBot
           masks[signer / 8] = masks[signer / 8] ^ (1 << (signer % 8))
         end
         bytes += AGGREGATED_SIGNATURE_ORDINAY_MASK
-        bytes += MixinBot.utils.encode_uint_16 masks_bytes.size
+        bytes += MixinBot.utils.encode_uint16 masks_bytes.size
         bytes += masks_bytes
       end
 
@@ -358,15 +366,15 @@ module MixinBot
 
       raise ArgumentError, 'signatures overflow' if sl == MAX_ENCODE_INT
 
-      bytes += MixinBot.utils.encode_uint_16 sl
+      bytes += MixinBot.utils.encode_uint16 sl
 
       if sl.positive?
         signatures.each do |signature|
-          bytes += MixinBot.utils.encode_uint_16 signature.keys.size
+          bytes += MixinBot.utils.encode_uint16 signature.keys.size
 
           signature.keys.sort.each do |key|
             signature_bytes = [signature[key]].pack('H*').bytes
-            bytes += MixinBot.utils.encode_uint_16 key
+            bytes += MixinBot.utils.encode_uint16 key
             bytes += signature_bytes
           end
         end
@@ -376,7 +384,7 @@ module MixinBot
     end
 
     def decode_inputs
-      inputs_size = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+      inputs_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
       @inputs = []
       inputs_size.times do
         input = {}
@@ -384,12 +392,12 @@ module MixinBot
         input['hash'] = hash.pack('C*').unpack1('H*')
 
         index = @bytes.shift(2)
-        input['index'] = MixinBot.utils.decode_uint_16 index
+        input['index'] = MixinBot.utils.decode_uint16 index
 
         if @bytes[...2] == NULL_BYTES
           @bytes.shift 2
         else
-          genesis_size = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+          genesis_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
           genesis = @bytes.shift genesis_size
           input['genesis'] = genesis.pack('C*').unpack1('H*')
         end
@@ -403,15 +411,15 @@ module MixinBot
           deposit = {}
           deposit['chain'] = @bytes.shift(32).pack('C*').unpack1('H*')
 
-          asset_size = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+          asset_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
           deposit['asset'] = @bytes.shift(asset_size).unpack1('H*')
 
-          transaction_size = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+          transaction_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
           deposit['transaction'] = @bytes.shift(transaction_size).unpack1('H*')
 
-          deposit['index'] = MixinBot.utils.decode_uint_64 @bytes.shift(8)
+          deposit['index'] = MixinBot.utils.decode_uint64 @bytes.shift(8)
 
-          amount_size = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+          amount_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
           deposit['amount'] = MixinBot.utils.decode_int @bytes.shift(amount_size)
 
           input['deposit'] = deposit
@@ -427,12 +435,12 @@ module MixinBot
           if bytes[...2] == NULL_BYTES
             @bytes.shift 2
           else
-            group_size = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+            group_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
             mint['group'] = @bytes.shift(group_size).unpack1('H*')
           end
 
-          mint['batch'] = MixinBot.utils.decode_uint_64 @bytes.shift(8)
-          _amount_size = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+          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
@@ -445,7 +453,7 @@ module MixinBot
     end
 
     def decode_outputs
-      outputs_size = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+      outputs_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
       @outputs = []
       outputs_size.times do
         output = {}
@@ -454,18 +462,18 @@ module MixinBot
         type = @bytes.shift
         output['type'] = type
 
-        amount_size = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+        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_uint_16 @bytes.shift(2)
+        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_uint_16 @bytes.shift(2)
+        script_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
         output['script'] = @bytes.shift(script_size).pack('C*').unpack1('H*')
 
         if @bytes[...2] == NULL_BYTES
@@ -476,14 +484,14 @@ module MixinBot
 
           output['chain'] = @bytes.shift(32).pack('C*').unpack1('H*')
 
-          asset_size = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+          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_uint_16 @bytes.shift(2)
+            adderss_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
             output['adderss'] = @bytes.shift(adderss_size).pack('C*').unpack1('H*')
           end
 
@@ -491,7 +499,7 @@ module MixinBot
             @bytes.shift 2
           else
 
-            tag_size = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+            tag_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
             output['tag'] = @bytes.shift(tag_size).pack('C*').unpack1('H*')
           end
         end
@@ -501,5 +509,16 @@ module MixinBot
 
       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

data/lib/mixin_bot/utils/address.rb

@@ -20,7 +20,6 @@ module MixinBot
 
         data = address[MAIN_ADDRESS_PREFIX.length..]
         data = Base58.base58_to_binary data, :bitcoin
-        raise ArgumentError, 'invalid address' unless data.length == 68
 
         payload = data[...-4]
 
@@ -36,7 +35,8 @@ module MixinBot
         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
+
+        # raise ArgumentError, "invalid threshold: #{threshold}" if threshold > members.length
 
         prefix = [MIX_ADDRESS_VERSION].pack('C*') + [threshold].pack('C*') + [members.length].pack('C*')
 
@@ -103,6 +103,19 @@ module MixinBot
           mix_address: build_mix_address(members, threshold)
         }
       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)
+
+        MixinBot::Utils.build_main_address spend_key + view_key
+      end
     end
   end
 end

data/lib/mixin_bot/utils/crypto.rb

@@ -53,49 +53,45 @@ module MixinBot
         }
       end
 
-      def generate_public_key(key)
-        point = JOSE::JWA::FieldElement.new(
-          OpenSSL::BN.new(key.reverse, 2),
+      def shared_public_key(key)
+        (JOSE::JWA::Edwards25519Point.stdbase * scalar_from_bytes(key[...64]).x.to_i).encode
+      end
+
+      def scalar_from_bytes(raw)
+        JOSE::JWA::FieldElement.new(
+          # https://github.com/potatosalad/ruby-jose/blob/e1be589b889f1e59ac233a5d19a3fa13f1e4b8a0/lib/jose/jwa/x25519.rb#L122C14-L122C48
+          OpenSSL::BN.new(raw.reverse, 2),
           JOSE::JWA::Edwards25519Point::L
         )
-
-        (JOSE::JWA::Edwards25519Point.stdbase * point.x.to_i).encode
       end
 
       def sign(msg, key:)
         msg = Digest::Blake3.digest msg
 
-        pub = generate_public_key key
+        pub = shared_public_key key
 
-        y_point = JOSE::JWA::FieldElement.new(
-          OpenSSL::BN.new(key.reverse, 2),
-          JOSE::JWA::Edwards25519Point::L
-        )
+        y_scalar = scalar_from_bytes key
 
         key_digest = Digest::SHA512.digest key
         msg_digest = Digest::SHA512.digest(key_digest[-32...] + msg)
 
-        z_point = JOSE::JWA::FieldElement.new(
-          OpenSSL::BN.new(msg_digest[...64].reverse, 2),
-          JOSE::JWA::Edwards25519Point::L
-        )
+        z_scalar = scalar_from_bytes msg_digest[...64]
+
+        r_point = JOSE::JWA::Edwards25519Point.stdbase * z_scalar.x.to_i
 
-        r_point = JOSE::JWA::Edwards25519Point.stdbase * z_point.x.to_i
         hram_digest = Digest::SHA512.digest(r_point.encode + pub + msg)
 
-        x_point = JOSE::JWA::FieldElement.new(
-          OpenSSL::BN.new(hram_digest[...64].reverse, 2),
-          JOSE::JWA::Edwards25519Point::L
-        )
-        s_point = (x_point * y_point) + z_point
+        x_scalar = scalar_from_bytes hram_digest[...64]
+
+        s_scalar = (x_scalar * y_scalar) + z_scalar
 
-        r_point.encode + s_point.to_bytes(36)
+        r_point.encode + s_scalar.to_bytes(36)
       end
 
-      def generate_unique_uuid(uuid_1, uuid_2)
+      def generate_unique_uuid(uuid1, uuid2)
         md5 = Digest::MD5.new
-        md5 << [uuid_1, uuid_2].min
-        md5 << [uuid_1, uuid_2].max
+        md5 << [uuid1, uuid2].min
+        md5 << [uuid1, uuid2].max
         digest = md5.digest
         digest6 = ((digest[6].ord & 0x0f) | 0x30).chr
         digest8 = ((digest[8].ord & 0x3f) | 0x80).chr
@@ -175,7 +171,47 @@ module MixinBot
       def tip_public_key(key, counter: 0)
         raise ArgumentError, 'invalid key' if key.size < 32
 
-        (key[0...32].bytes + MixinBot::Utils.encode_uint_64(counter + 1)).pack('c*').unpack1('H*')
+        (key[0...32].bytes + MixinBot::Utils.encode_uint64(counter + 1)).pack('c*').unpack1('H*')
+      end
+
+      def hash_scalar(pkey, output_index)
+        tmp = [output_index].pack('Q<').reverse
+
+        hash1 = Digest::Blake3.digest(pkey + tmp)
+        hash2 = Digest::Blake3.digest hash1
+
+        hash3 = Digest::Blake3.digest(hash1 + hash2)
+        hash4 = Digest::Blake3.digest hash3
+
+        hash3 + hash4
+      end
+
+      def multiply_keys(public_key:, private_key:)
+        public_point = JOSE::JWA::Edwards25519Point.stdbase.decode public_key
+        private_scalar = scalar_from_bytes private_key
+        (public_point * private_scalar.x.to_i).encode
+      end
+
+      def derive_ghost_public_key(private_key, view_key, spend_key, index)
+        mult_value = multiply_keys(public_key: view_key, private_key:)
+
+        x = hash_scalar mult_value, index
+
+        p1 = JOSE::JWA::Edwards25519Point.stdbase.decode spend_key
+        p2 = JOSE::JWA::Edwards25519Point.stdbase * scalar_from_bytes(x).x.to_i
+
+        (p1 + p2).encode
+      end
+
+      def derive_ghost_private_key(public_key, view_key, spend_key, index)
+        mult_value = multiply_keys(public_key:, private_key: view_key)
+
+        x = hash_scalar mult_value, index
+
+        x_scalar = scalar_from_bytes x
+        y_scalar = scalar_from_bytes spend_key
+
+        (x_scalar + y_scalar).to_bytes(36)
       end
     end
   end

data/lib/mixin_bot/utils/decoder.rb

@@ -8,14 +8,12 @@ module MixinBot
 
         if key.match?(/\A[\h]{64,}\z/i)
           [key].pack('H*')
-        elsif key.match?(/\A[a-zA-Z0-9\-\_=]{43,}\z/)
-          Base64.urlsafe_decode64 key
         elsif key.match?(/^-----BEGIN RSA PRIVATE KEY-----/)
           key.gsub('\\r\\n', "\n").gsub("\r\n", "\n")
         elsif key.match?(/\d{6}/) || (key.size % 32).zero?
           key
         else
-          raise ArgumentError, "Invalid key #{key}"
+          Base64.urlsafe_decode64 key
         end
       end
 
@@ -23,19 +21,19 @@ module MixinBot
         MixinBot::Transaction.new(hex:).decode.to_h
       end
 
-      def decode_uint_16(bytes)
+      def decode_uint16(bytes)
         raise ArgumentError, "only support bytes #{bytes}" unless bytes.is_a?(Array)
 
         bytes.reverse.pack('C*').unpack1('S*')
       end
 
-      def decode_uint_32(bytes)
+      def decode_uint32(bytes)
         raise ArgumentError, "only support bytes #{bytes}" unless bytes.is_a?(Array)
 
         bytes.reverse.pack('C*').unpack1('L*')
       end
 
-      def decode_uint_64(bytes)
+      def decode_uint64(bytes)
         raise ArgumentError, "only support bytes #{bytes}" unless bytes.is_a?(Array)
 
         bytes.reverse.pack('C*').unpack1('Q*')

data/lib/mixin_bot/utils/encoder.rb

@@ -3,35 +3,35 @@
 module MixinBot
   module Utils
     module Encoder
-      def encode_raw_transaction(tx)
-        if tx.is_a? String
+      def encode_raw_transaction(txn)
+        if txn.is_a? String
           begin
-            tx = JSON.parse tx
+            txn = JSON.parse txn
           rescue JSON::ParserError
-            tx
+            txn
           end
         end
 
-        raise ArgumentError, "#{tx} is not a valid json" unless tx.is_a? Hash
+        raise ArgumentError, "#{txn} is not a valid json" unless txn.is_a? Hash
 
-        tx = tx.with_indifferent_access
+        txn = txn.with_indifferent_access
 
-        MixinBot::Transaction.new(**tx).encode.hex
+        MixinBot::Transaction.new(**txn).encode.hex
       end
 
-      def encode_uint_16(int)
+      def encode_uint16(int)
         raise ArgumentError, "only support int #{int}" unless int.is_a?(Integer)
 
         [int].pack('S*').bytes.reverse
       end
 
-      def encode_uint_32(int)
+      def encode_uint32(int)
         raise ArgumentError, "only support int #{int}" unless int.is_a?(Integer)
 
         [int].pack('L*').bytes.reverse
       end
 
-      def encode_uint_64(int)
+      def encode_uint64(int)
         raise ArgumentError, "only support int #{int}" unless int.is_a?(Integer)
 
         [int].pack('Q*').bytes.reverse
@@ -42,7 +42,7 @@ module MixinBot
 
         bytes = []
         loop do
-          break if int === 0
+          break if int.zero?
 
           bytes.push int & 255
           int = (int / (2**8)) | 0

data/lib/mixin_bot/version.rb

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

data/lib/mvm/client.rb

@@ -17,12 +17,12 @@ module MVM
       end
     end
 
-    def get(path, **options)
-      @conn.get(path, **options).body
+    def get(path, **)
+      @conn.get(path, **).body
     end
 
-    def post(path, **options)
-      @conn.post(path, **options).body
+    def post(path, **)
+      @conn.post(path, **).body
     end
   end
 end