mixin_bot 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ebb5e10a678c90007560b0f84676d0545ea510de1cefc5534091e0b1338c13b
-  data.tar.gz: afe4ffc00de92429959bc310a6082112f3dc54d8c48e687165a08e0499a3b1a5
+  metadata.gz: 4257bfdffc20e27ffab5ce9da23080be113a552623f5022775f3cc8a6cc6db0c
+  data.tar.gz: 7f29a034845b45715e33b3b51e28be996408fcff145538025a243fb74d42b482
 SHA512:
-  metadata.gz: 334913613e7a88d94e3783fbf028545ecfa0cecdb0a46c7189a63563be17830d33a1de098714e7c38da97094e041f16805cb5782b1101587629dde8d91d4abe6
-  data.tar.gz: b2ae3479345b421c7e96983c32c0e85c42a028022f74428c90467407eeea93f323b52126d5ab305ee317ae44db69a8e284ec024fdd738fbe095c6a7cbe11e1f4
+  metadata.gz: 18e9d94005f235f827ce4e7598a2b2ddf13f48b296d9af46e4d6b2550e795c30f805c40b815352c159f7f2aa7b35c0a4e93ea0787889175c373e931720b5dc17
+  data.tar.gz: 56e0c4651199912fd4ed4bef7eb96cc22de1cd30842b7d8e767811ece926e880984a0f2734db19d4f1c48464c037e3b3d9c22b61be204c8a83ffd0f926203e37

data/lib/mixin_bot/api/auth.rb

@@ -52,8 +52,8 @@ module MixinBot
         @_scope = scope.join(' ')
         EM.run do
           start_blaze_connect do
-            def on_open(ws, _event)
-              ws.send write_ws_message(
+            def on_open(websocket, _event) # rubocop:disable Lint/NestedMethodDefinition
+              websocket.send write_ws_message(
                 action: 'REFRESH_OAUTH_CODE',
                 params: {
                   client_id: @_app_id,
@@ -64,13 +64,13 @@ module MixinBot
               )
             end
 
-            def on_message(ws, event)
+            def on_message(websocket, event) # rubocop:disable Lint/NestedMethodDefinition
               raw = JSON.parse ws_message(event.data)
               @_data = raw
-              ws.close
+              websocket.close
             end
 
-            def on_close(_ws, _event)
+            def on_close(_websocket, _event) # rubocop:disable Lint/NestedMethodDefinition
               EM.stop_event_loop
             end
           end

data/lib/mixin_bot/api/encrypted_message.rb

@@ -110,7 +110,7 @@ module MixinBot
         client.post path, *payload
       end
 
-      def encrypt_message(data, sessions = [], sk: nil, pk: nil)
+      def encrypt_message(data, sessions = [], sk: nil, pk: nil) # rubocop:disable Naming/MethodParameterName
         raise ArgumentError, 'Wrong sessions format!' unless sessions.all?(&->(s) { s.key?('session_id') && s.key?('public_key') })
 
         sk ||= config.session_private_key[0...32]
@@ -153,7 +153,7 @@ module MixinBot
         Base64.urlsafe_encode64 bytes.pack('C*'), padding: false
       end
 
-      def decrypt_message(data, sk: nil, si: nil)
+      def decrypt_message(data, sk: nil, si: nil) # rubocop:disable Naming/MethodParameterName
         bytes = Base64.urlsafe_decode64(data).bytes
 
         si ||= config.session_id

data/lib/mixin_bot/api/inscription.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    module Inscription
+      def collection(hash)
+        path = "/safe/inscriptions/collections/#{hash}"
+
+        client.get path
+      end
+
+      def collectible(hash)
+        path = "/safe/inscriptions/items/#{hash}"
+
+        client.get path
+      end
+
+      def collectibles(members: [], access_token: nil)
+        unspent_outputs = safe_outputs(state: :unspent, members:, access_token:)['data']
+        unspent_outputs.select { |output| output['inscription_hash'].present? }
+      end
+
+      def create_collectible_transfer(utxo, **kwargs)
+        # verify collectible
+        utxo = utxo.with_indifferent_access
+        raise MixinBot::ArgumentError, 'not a valid collectible' unless utxo['inscription_hash'].present?
+
+        # verify members
+        members = [kwargs[:members]].flatten.compact
+        raise ArgumentError, 'members required' if members.blank?
+
+        threshold = kwargs[:threshold] || members.length
+        request_id = kwargs[:request_id] || kwargs[:trace_id] || SecureRandom.uuid
+
+        memo = kwargs[:memo] || ''
+
+        # build transaction
+        tx = build_safe_transaction(
+          utxos: [utxo],
+          receivers: [{
+            members:,
+            threshold:,
+            amount: utxo['amount']
+          }],
+          extra: memo
+        )
+
+        # encode transaction
+        raw = MixinBot.utils.encode_raw_transaction tx
+
+        # verify transaction
+        request = create_safe_transaction_request(request_id, raw)['data']
+
+        # sign transaction
+        spend_key = MixinBot.utils.decode_key(kwargs[:spend_key]) || config.spend_key
+        signed_raw = MixinBot.api.sign_safe_transaction(
+          raw:,
+          utxos: [utxo],
+          request: request[0],
+          spend_key:
+        )
+
+        # submit transaction
+        send_safe_transaction(
+          request_id,
+          signed_raw
+        )
+      end
+    end
+  end
+end

data/lib/mixin_bot/api/{collectible.rb → legacy_collectible.rb}

@@ -2,20 +2,20 @@
 
 module MixinBot
   class API
-    module Collectible
+    module LegacyCollectible
       NFT_ASSET_MIXIN_ID = '1700941284a95f31b25ec8c546008f208f88eee4419ccdcdbe6e3195e60128ca'
 
-      def collectible(id, access_token: nil)
+      def legacy_collectible(id, access_token: nil)
         path = "/collectibles/tokens/#{id}"
         client.get path, access_token:
       end
 
-      def collection(id, access_token: nil)
+      def legacy_collection(id, access_token: nil)
         path = "/collectibles/collections/#{id}"
         client.get path, access_token:
       end
 
-      def collectibles(**kwargs)
+      def legacy_collectibles(**kwargs)
         limit = kwargs[:limit] || 100
         offset = kwargs[:offset] || ''
         state = kwargs[:state] || ''

data/lib/mixin_bot/api/legacy_multisig.rb

@@ -40,7 +40,7 @@ module MixinBot
             }
           end
 
-        client.post path, **payload, access_token:
+        client.post path, **payload
       end
 
       def unlock_multisig_request(request_id, pin = nil)

data/lib/mixin_bot/api/legacy_output.rb

@@ -3,7 +3,7 @@
 module MixinBot
   class API
     module LegacyOutput
-      def outputs(**kwargs)
+      def legacy_outputs(**kwargs)
         limit = kwargs[:limit] || 100
         offset = kwargs[:offset] || ''
         state = kwargs[:state] || ''
@@ -23,8 +23,8 @@ module MixinBot
 
         client.get path, **params, access_token:
       end
-      alias multisigs outputs
-      alias multisig_outputs outputs
+      alias multisigs legacy_outputs
+      alias multisig_outputs legacy_outputs
 
       def create_output(receivers:, index:, hint: nil, access_token: nil)
         path = '/outputs'

data/lib/mixin_bot/api/multisig.rb

@@ -6,11 +6,11 @@ module MixinBot
       def create_safe_multisig_request(request_id, raw, access_token: nil)
         path = '/safe/multisigs'
         payload = [{
-          request_id: request_id,
-          raw: raw
+          request_id:,
+          raw:
         }]
 
-        client.post path, *payload
+        client.post path, *payload, access_token:
       end
 
       def sign_safe_multisig_request(request_id, raw, access_token: nil)
@@ -20,13 +20,13 @@ module MixinBot
           raw:
         }
 
-        client.post path, **payload
+        client.post path, **payload, access_token:
       end
 
       def unlock_safe_multisig_request(request_id, access_token: nil)
         path = format('/safe/multisigs/%<request_id>s/unlock', request_id:)
 
-        client.post path, access_token: access_token
+        client.post path, access_token:
       end
 
       def safe_multisig_request(request_id, access_token: nil)

data/lib/mixin_bot/api/output.rb

@@ -18,7 +18,7 @@ module MixinBot
         state = kwargs[:state] || ''
         access_token = kwargs[:access_token]
         order = kwargs[:order] || 'ASC'
-        members = kwargs[:members] || [config.app_id]
+        members = kwargs[:members].presence || [config.app_id]
         threshold = kwargs[:threshold] || members.length
 
         members_hash = SHA3::Digest::SHA256.hexdigest(members&.sort&.join)
@@ -36,11 +36,13 @@ module MixinBot
 
         client.get path, **params, access_token:
       end
+      alias outputs safe_outputs
 
       def safe_output(id, access_token: nil)
         path = format('/safe/outputs/%<id>s', id:)
         client.get path, access_token:
       end
+      alias output safe_output
     end
   end
 end

data/lib/mixin_bot/api/pin.rb

@@ -49,7 +49,7 @@ module MixinBot
         ed25519_key = JOSE::JWA::Ed25519.keypair
 
         private_key = ed25519_key[1].unpack1('H*')
-        public_key = (ed25519_key[0].bytes + MixinBot::Utils.encode_uint_64(counter + 1)).pack('c*').unpack1('H*')
+        public_key = (ed25519_key[0].bytes + MixinBot::Utils.encode_uint64(counter + 1)).pack('c*').unpack1('H*')
 
         {
           private_key:,

data/lib/mixin_bot/api/rpc.rb

@@ -19,7 +19,7 @@ module MixinBot
       end
 
       def get_transaction(hash, access_token: nil)
-        rpc_proxy('gettransaction', [hash], access_token: nil)
+        rpc_proxy('gettransaction', [hash], access_token:)
       end
 
       def get_utxo(hash, index = 0, access_token: nil)
@@ -30,16 +30,16 @@ module MixinBot
         rpc_proxy 'getsnapshot', [hash], access_token:
       end
 
-      def list_snapshots(offset = 0, count = 10, sig = false, tx = false, access_token: nil)
-        rpc_proxy 'listsnapshots', [offset, count, sig, tx], access_token:
+      def list_snapshots(offset = 0, count = 10, sig: false, txn: false, access_token: nil)
+        rpc_proxy 'listsnapshots', [offset, count, sig, txn], access_token:
       end
 
       def list_mint_works(offset = 0, access_token: nil)
         rpc_proxy 'listmintworks', [offset], access_token:
       end
 
-      def list_mint_distributions(offset = 0, count = 10, tx = false, access_token: nil)
-        rpc_proxy 'listmintdistributions', [offset, count, tx], access_token:
+      def list_mint_distributions(offset = 0, count = 10, txn: false, access_token: nil)
+        rpc_proxy 'listmintdistributions', [offset, count, txn], access_token:
       end
     end
   end

data/lib/mixin_bot/api/transaction.rb

@@ -6,8 +6,10 @@ module MixinBot
       SAFE_TX_VERSION = 0x05
       OUTPUT_TYPE_SCRIPT = 0x00
       OUTPUT_TYPE_WITHDRAW_SUBMIT = 0xa1
+      XIN_ASSET_ID = 'c94ac88f-4671-3976-b60a-09064f1811e8'
+      EXTRA_SIZE_STORAGE_CAPACITY = 1024 * 1024 * 4
+      EXTRA_STORAGE_PRICE_STEP = 0.0001
 
-      # ghost keys
       def create_safe_keys(*payload, access_token: nil)
         raise ArgumentError, 'payload should be an array' unless payload.is_a? Array
         raise ArgumentError, 'payload should not be empty' unless payload.size.positive?
@@ -21,10 +23,58 @@ module MixinBot
 
         path = '/safe/keys'
 
-        client.post path, *payload
+        client.post path, *payload, access_token:
       end
       alias create_ghost_keys create_safe_keys
 
+      def generate_safe_keys(recipients)
+        raise ArgumentError, 'recipients should be an array' unless recipients.is_a? Array
+
+        ghost_keys = []
+        uuid_recipients = []
+
+        recipients.each_with_index do |recipient, index|
+          next if recipient[:mix_address].blank?
+
+          if recipient[:members].all?(&->(m) { m.start_with? MixinBot::Utils::Address::MAIN_ADDRESS_PREFIX })
+            key = JOSE::JWA::Ed25519.keypair
+            gk = {
+              mask: key[0].unpack1('H*'),
+              keys: []
+            }
+            recipient[:members].each do |member|
+              payload = MixinBot.utils.parse_main_address member
+              spend_key = payload[0...32]
+              view_key = payload[-32..]
+
+              ghost_public_key = MixinBot.utils.derive_ghost_public_key(key[1], view_key, spend_key, index)
+
+              gk[:keys] << ghost_public_key.unpack1('H*')
+            end
+
+            ghost_keys[index] = gk.with_indifferent_access
+
+          elsif recipient[:members].none?(&->(m) { m.start_with? MixinBot::Utils::Address::MAIN_ADDRESS_PREFIX })
+            uuid_recipients.push(
+              {
+                receivers: recipient[:members],
+                index:,
+                hint: SecureRandom.uuid
+              }.with_indifferent_access
+            )
+          end
+        end
+
+        if uuid_recipients.present?
+          keys = create_safe_keys(*uuid_recipients)['data']
+          keys.each_with_index do |key, index|
+            ghost_keys[uuid_recipients[index][:index]] = key
+          end
+        end
+
+        ghost_keys
+      end
+
       # kwargs:
       # {
       #  utxos: [ utxo ],
@@ -39,6 +89,8 @@ module MixinBot
       SAFE_RAW_TRANSACTION_ARGUMENTS = %i[utxos receivers].freeze
       def build_safe_transaction(**kwargs)
         raise ArgumentError, "#{SAFE_RAW_TRANSACTION_ARGUMENTS.join(', ')} are needed for build safe transaction" unless SAFE_RAW_TRANSACTION_ARGUMENTS.all? { |param| kwargs.keys.include? param }
+        raise ArgumentError, 'receivers should be an array' unless kwargs[:receivers].is_a? Array
+        raise ArgumentError, 'utxos should be an array' unless kwargs[:utxos].is_a? Array
 
         utxos = kwargs[:utxos].map(&:with_indifferent_access)
         receivers = kwargs[:receivers].map(&:with_indifferent_access)
@@ -63,12 +115,12 @@ module MixinBot
         inputs_sum = utxos.sum(&->(utxo) { utxo['amount'].to_d })
         outputs_sum = recipients.sum(&->(recipient) { recipient['amount'].to_d })
         change = inputs_sum - outputs_sum
-        raise InsufficientBalanceError, "inputs sum: #{inputs_sum}" if change.negative?
+        raise InsufficientBalanceError, "inputs sum #{inputs_sum} < outputs sum #{outputs_sum}" if change.negative?
 
         if change.positive?
           recipients << MixinBot.utils.build_safe_recipient(
-            members: utxos[0]['receivers'],
-            threshold: utxos[0]['receivers_threshold'],
+            members: utxos.first['receivers'],
+            threshold: utxos.first['receivers_threshold'],
             amount: change
           ).with_indifferent_access
         end
@@ -85,14 +137,7 @@ module MixinBot
           }
         end
 
-        ghost_payload = recipients.map.with_index do |r, index|
-          {
-            receivers: r[:members],
-            index:,
-            hint: SecureRandom.uuid
-          }
-        end
-        ghosts = create_safe_keys(*ghost_payload)['data']
+        ghosts = generate_safe_keys(recipients)
 
         outputs = []
         recipients.each_with_index do |recipient, index|
@@ -121,7 +166,8 @@ module MixinBot
           asset:,
           inputs:,
           outputs:,
-          extra: kwargs[:extra] || ''
+          extra: kwargs[:extra] || '',
+          references: kwargs[:references] || []
         }
       end
 
@@ -164,7 +210,7 @@ module MixinBot
 
         msg = [raw].pack('H*')
 
-        y_point = JOSE::JWA::FieldElement.new(
+        y_scalar = JOSE::JWA::FieldElement.new(
           JOSE::JWA::X25519.clamp_scalar(spend_key[...32]).x,
           JOSE::JWA::Edwards25519Point::L
         )
@@ -175,16 +221,12 @@ module MixinBot
           raise ArgumentError, 'utxo not match' unless input['hash'] == utxo['transaction_hash'] && input['index'] == utxo['output_index']
 
           view = [request['views'][index]].pack('H*')
-          x_point = JOSE::JWA::FieldElement.new(
-            # https://github.com/potatosalad/ruby-jose/blob/e1be589b889f1e59ac233a5d19a3fa13f1e4b8a0/lib/jose/jwa/x25519.rb#L122C14-L122C48
-            OpenSSL::BN.new(view.reverse, 2),
-            JOSE::JWA::Edwards25519Point::L
-          )
+          x_scalar = MixinBot.utils.scalar_from_bytes(view)
 
-          t_point = x_point + y_point
-          key = t_point.to_bytes(JOSE::JWA::Edwards25519Point::B)
+          t_scalar = x_scalar + y_scalar
+          key = t_scalar.to_bytes(JOSE::JWA::Edwards25519Point::B)
 
-          pub = MixinBot.utils.generate_public_key key
+          pub = MixinBot.utils.shared_public_key key
           key_index = utxo['keys'].index pub.unpack1('H*')
           raise ArgumentError, 'cannot find valid key' unless key_index.is_a? Integer
 
@@ -197,6 +239,75 @@ module MixinBot
 
         MixinBot.utils.encode_raw_transaction tx
       end
+
+      def build_object_transaction(extra, **)
+        extra = extra.to_s
+        raise ArgumentError, 'Extra too large' if extra.bytesize > EXTRA_SIZE_STORAGE_CAPACITY
+
+        # calculate fee base on extra length
+        amount = EXTRA_STORAGE_PRICE_STEP * ((extra.bytesize / 1024) + 1)
+
+        # burning address
+        receivers = [
+          {
+            members: [MixinBot.utils.burning_address],
+            threshold: 64,
+            amount:
+          }
+        ]
+
+        # find XIN utxos
+        utxos = build_utxos(asset_id: XIN_ASSET_ID, amount:)
+
+        # build transaction
+        build_safe_transaction utxos:, receivers:, extra:, **
+      end
+
+      INSCRIBE_TRANSACTION_ARGUMENTS = %i[content collection_hash].freeze
+      def build_inscribe_transaction(**kwargs)
+        raise ArgumentError, "#{INSCRIBE_TRANSACTION_ARGUMENTS.join(', ')} are needed for inscribe transaction" unless INSCRIBE_TRANSACTION_ARGUMENTS.all? { |param| kwargs.keys.include? param }
+
+        receivers = kwargs[:receivers].presence || [config.app_id]
+        receivers_threshold = kwargs[:receivers_threshold] || receivers.length
+        recipient = MixinBot.utils.build_mix_address(receivers, receivers_threshold)
+
+        content = kwargs[:content]
+        collection_hash = kwargs[:collection_hash]
+
+        data = {
+          operation: 'inscribe',
+          recipient:,
+          content:
+        }
+
+        MixinBot.api.build_object_transaction data.to_json, references: [collection_hash]
+      end
+
+      OCCUPY_INSCRIPTION_TRANSACTION_ARGUMENTS = %i[amount inscription_hash utxos].freeze
+      def build_occupy_transaction(**kwargs)
+        raise ArgumentError, "#{OCCUPY_INSCRIPTION_TRANSACTION_ARGUMENTS.join(', ')} are needed for occupy NFT transaction" unless OCCUPY_INSCRIPTION_TRANSACTION_ARGUMENTS.all? { |param| kwargs.keys.include? param }
+
+        members = kwargs[:members].presence || [config.app_id]
+        threshold = kwargs[:threshold] || members.length
+        amount = kwargs[:amount]
+        inscription_hash = kwargs[:inscription_hash]
+
+        receivers = [
+          {
+            members:,
+            threshold:,
+            amount:
+          }
+        ]
+
+        extra = {
+          operation: 'occupy',
+          recipient:,
+          content:
+        }.to_json
+
+        MixinBot.api.build_safe_transaction(utxos:, receivers:, extra:, references: [inscription_hash])
+      end
     end
   end
 end

data/lib/mixin_bot/api/transfer.rb

@@ -29,15 +29,7 @@ module MixinBot
         memo = kwargs[:memo] || ''
 
         # step 1: select inputs
-        outputs = safe_outputs(state: 'unspent', asset: asset_id, limit: 500)['data'].sort_by { |o| o['amount'].to_d }
-
-        utxos = []
-        outputs.each do |output|
-          break if utxos.sum { |o| o['amount'].to_d } >= amount
-
-          utxos.shift if utxos.size >= 256
-          utxos << output
-        end
+        utxos = build_utxos(asset_id:, amount:)
 
         # step 2: build transaction
         tx = build_safe_transaction(
@@ -56,7 +48,7 @@ module MixinBot
 
         # step 4: sign transaction
         spend_key = MixinBot.utils.decode_key(kwargs[:spend_key]) || config.spend_key
-        signed_raw = sign_safe_transaction(
+        signed_raw = MixinBot.api.sign_safe_transaction(
           raw:,
           utxos:,
           request: request[0],
@@ -69,6 +61,20 @@ module MixinBot
           signed_raw
         )
       end
+
+      def build_utxos(asset_id:, amount:)
+        outputs = safe_outputs(state: 'unspent', asset: asset_id, limit: 500)['data'].sort_by { |o| o['amount'].to_d }
+
+        utxos = []
+        outputs.each do |output|
+          break if utxos.sum { |o| o['amount'].to_d } >= amount
+
+          utxos.shift if utxos.size >= 256
+          utxos << output
+        end
+
+        utxos
+      end
     end
   end
 end

data/lib/mixin_bot/api/user.rb

@@ -86,19 +86,24 @@ module MixinBot
         client.post path, **payload
       end
 
-      def migrate_to_safe(spend_key:, old_pin: nil)
+      def migrate_to_safe(spend_key:, pin: nil)
         profile = me['data']
         return true if profile['has_safe']
 
         spend_keypair = JOSE::JWA::Ed25519.keypair spend_key
         spend_key = spend_keypair[1].unpack1('H*')
 
-        update_pin pin: MixinBot.utils.tip_public_key(spend_keypair[0], counter: profile['tip_counter']) if profile['tip_key_base64'].blank?
+        if profile['tip_key_base64'].blank?
+          new_pin = MixinBot.utils.tip_public_key(spend_keypair[0], counter: profile['tip_counter'])
+          update_pin(pin: new_pin, old_pin: pin)
+
+          pin = new_pin
+        end
 
         # wait for tip pin update in server
         sleep 1
 
-        safe_register spend_key
+        safe_register pin, spend_key
 
         {
           spend_key:

data/lib/mixin_bot/api.rb

@@ -8,9 +8,10 @@ require_relative 'api/asset'
 require_relative 'api/attachment'
 require_relative 'api/auth'
 require_relative 'api/blaze'
-require_relative 'api/collectible'
 require_relative 'api/conversation'
 require_relative 'api/encrypted_message'
+require_relative 'api/inscription'
+require_relative 'api/legacy_collectible'
 require_relative 'api/legacy_multisig'
 require_relative 'api/legacy_output'
 require_relative 'api/legacy_payment'
@@ -67,8 +68,8 @@ module MixinBot
       )
     end
 
-    def encode_raw_transaction(tx)
-      utils.encode_raw_transaction tx
+    def encode_raw_transaction(txn)
+      utils.encode_raw_transaction txn
     end
 
     def decode_raw_transaction(raw)
@@ -107,9 +108,10 @@ module MixinBot
     include MixinBot::API::Attachment
     include MixinBot::API::Auth
     include MixinBot::API::Blaze
-    include MixinBot::API::Collectible
     include MixinBot::API::Conversation
     include MixinBot::API::EncryptedMessage
+    include MixinBot::API::Inscription
+    include MixinBot::API::LegacyCollectible
     include MixinBot::API::LegacyMultisig
     include MixinBot::API::LegacyOutput
     include MixinBot::API::LegacyPayment

data/lib/mixin_bot/client.rb

@@ -78,7 +78,7 @@ module MixinBot
         return result
       end
 
-      errmsg = "#{verb.upcase}|#{path}|#{body}, errcode: #{result['error']['code']}, errmsg: #{result['error']['description']}, request_id: #{response&.[]('X-Request-Id')}, server_time: #{response&.[]('X-Server-Time')}'"
+      errmsg = "#{verb.upcase} | #{path} | #{body}, errcode: #{result['error']['code']}, errmsg: #{result['error']['description']}, request_id: #{response&.[]('X-Request-Id')}, server_time: #{response&.[]('X-Server-Time')}'"
 
       case result['error']['code']
       when 401, 20121
@@ -87,8 +87,6 @@ module MixinBot
         raise ForbiddenError, errmsg
       when 404
         raise NotFoundError, errmsg
-      when 400, 10006, 20133, 500, 7000, 7001
-        raise ResponseError, errmsg
       when 20117
         raise InsufficientBalanceError, errmsg
       when 20118, 20119

data/lib/mixin_bot/nfo.rb

@@ -74,7 +74,7 @@ module MixinBot
         bytes += [0]
       else
         bytes += [1]
-        bytes += MixinBot.utils.encode_uint_64 mask
+        bytes += MixinBot.utils.encode_uint64 mask
         bytes += MixinBot::UUID.new(hex: chain).packed.bytes
 
         class_bytes = [nm_class].pack('H*').bytes