mixin_bot 0.12.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf2e7ef08c38a52d5d31ce1be5a0531f13680e31cb5e7f11cd6e1582436d8711
-  data.tar.gz: '08cfa89514d3f102cdd064cfb3c3367cf2166292a3abc854481320a2fb610d15'
+  metadata.gz: 4257bfdffc20e27ffab5ce9da23080be113a552623f5022775f3cc8a6cc6db0c
+  data.tar.gz: 7f29a034845b45715e33b3b51e28be996408fcff145538025a243fb74d42b482
 SHA512:
-  metadata.gz: a5f7af8574ea545b899bd2081923dd75e0b2ef2288346fb8e8d842b642ef596c626370d9a5140a695c267db4281e4c51239cce2d55f5edb87ed33127c76c379b
-  data.tar.gz: b2393b4a392ff025b0e6d58c545018bd4cafb26e9fb130bba8938e42d4850a6f2b5d0244d887f6dae8d8f53fcb000819737ea71d999add7e175637c7e2d591d1
+  metadata.gz: 18e9d94005f235f827ce4e7598a2b2ddf13f48b296d9af46e4d6b2550e795c30f805c40b815352c159f7f2aa7b35c0a4e93ea0787889175c373e931720b5dc17
+  data.tar.gz: 56e0c4651199912fd4ed4bef7eb96cc22de1cd30842b7d8e767811ece926e880984a0f2734db19d4f1c48464c037e3b3d9c22b61be204c8a83ffd0f926203e37

data/lib/mixin_bot/api/address.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    module Address
+      def safe_deposit_entries(**kwargs)
+        path = '/safe/deposit/entries'
+
+        members = [kwargs[:members]] if kwargs[:members].is_a? String
+
+        payload = {
+          members:,
+          threshold: kwargs[:threshold] || 1,
+          chain_id: kwargs[:chain_id]
+        }
+
+        client.post path, **payload, access_token: kwargs[:access_token]
+      end
+    end
+  end
+end

data/lib/mixin_bot/api/app.rb

@@ -6,25 +6,19 @@ module MixinBot
       def add_favorite_app(app_id, access_token: nil)
         path = format('/apps/%<id>s/favorite', id: app_id)
 
-        access_token ||= access_token('POST', path)
-        authorization = format('Bearer %<access_token>s', access_token: access_token)
-        client.post(path, headers: { 'Authorization': authorization })
+        client.post path, access_token:
       end
 
       def remove_favorite_app(app_id, access_token: nil)
         path = format('/apps/%<id>s/unfavorite', id: app_id)
 
-        access_token ||= access_token('POST', path)
-        authorization = format('Bearer %<access_token>s', access_token: access_token)
-        client.post(path, headers: { 'Authorization': authorization })
+        client.post path, access_token:
       end
 
-      def favorite_apps(user_id, access_token: nil)
-        path = format('/users/%<id>s/apps/favorite', id: user_id)
+      def favorite_apps(user_id = nil, access_token: nil)
+        path = format('/users/%<id>s/apps/favorite', id: user_id || config.app_id)
 
-        access_token ||= access_token('GET', path, '')
-        authorization = format('Bearer %<access_token>s', access_token: access_token)
-        client.get(path, headers: { 'Authorization': authorization })
+        client.get path, access_token:
       end
     end
   end

data/lib/mixin_bot/api/asset.rb

@@ -6,31 +6,24 @@ module MixinBot
       # https://developers.mixin.one/api/alpha-mixin-network/read-assets/
       def assets(access_token: nil)
         path = '/assets'
-        access_token ||= access_token('GET', path, '')
-        authorization = format('Bearer %<access_token>s', access_token: access_token)
-        client.get(path, headers: { 'Authorization': authorization })
+        client.get path, access_token:
       end
-      alias read_assets assets
 
       # https://developers.mixin.one/api/alpha-mixin-network/read-asset/
       def asset(asset_id, access_token: nil)
-        path = format('/assets/%<asset_id>s', asset_id: asset_id)
-        access_token ||= access_token('GET', path, '')
-        authorization = format('Bearer %<access_token>s', access_token: access_token)
-        client.get(path, headers: { 'Authorization': authorization })
+        path = format('/assets/%<asset_id>s', asset_id:)
+        client.get path, access_token:
       end
-      alias read_asset asset
 
       # https://developers.mixin.one/document/wallet/api/ticker
-      def ticker(asset_id, offset, access_token: nil)
-        offset = DateTime.rfc3339 offset if offset.is_a? String
+      def ticker(asset_id, **kwargs)
+        offset = kwargs[:offset]
+        offset = DateTime.rfc3339(offset) if offset.is_a? String
         offset = offset.rfc3339 if offset.is_a?(DateTime) || offset.is_a?(Time)
-        path = format('/ticker?asset=%<asset_id>s&offset=%<offset>s', asset_id: asset_id, offset: offset)
-        access_token ||= access_token('GET', path, '')
-        authorization = format('Bearer %<access_token>s', access_token: access_token)
-        client.get(path, headers: { 'Authorization': authorization })
+
+        path = '/ticker'
+        client.get path, asset_id:, offset:, access_token: kwargs[:access_token]
       end
-      alias read_ticker ticker
     end
   end
 end

data/lib/mixin_bot/api/attachment.rb

@@ -3,7 +3,6 @@
 module MixinBot
   class API
     module Attachment
-      # https://developers.mixin.one/api/beta-mixin-message/create-attachment/
       # Sample Response
       # {
       #   "data":{
@@ -14,38 +13,44 @@ module MixinBot
       #   }
       # }
       # Once get the upload_url, use it to upload the your file via PUT request
-      def create_attachment
+      def create_attachment(access_token: nil)
         path = '/attachments'
-        access_token ||= access_token('POST', path, {}.to_json)
-        authorization = format('Bearer %<access_token>s', access_token: access_token)
-        client.post(path, headers: { 'Authorization': authorization }, json: {})
+        client.post path, access_token:
       end
 
       def upload_attachment(file)
         attachment = create_attachment['data']
 
-        HTTP
-          .timeout(connect: 5, write: 5, read: 5)
-          .request(
-            :put,
-            attachment.delete('upload_url'),
-            {
-              body: file,
-              headers: {
-                'x-amz-acl': 'public-read',
-                'Content-Type': 'application/octet-stream'
-              }
-            }
-          )
+        url = attachment.delete('upload_url')
+        conn = Faraday.new(url:) do |f|
+          f.adapter :net_http
+
+          f.request :multipart
+          f.request :retry
+          f.response :raise_error
+          f.response :logger if config.debug
+        end
+
+        conn.put(url) do |req|
+          req.headers = {
+            'x-amz-acl': 'public-read',
+            'Content-Type': 'application/octet-stream'
+          }
+          req.body = Faraday::UploadIO.new(file, 'octet/stream')
+
+          if file.respond_to?(:length)
+            req.headers['Content-Length'] = file.length.to_s
+          elsif file.respond_to?(:stat)
+            req.headers['Content-Length'] = file.stat.size.to_s
+          end
+        end
 
         attachment
       end
 
-      def read_attachment(attachment_id)
+      def attachment(attachment_id, access_token: nil)
         path = format('/attachments/%<id>s', id: attachment_id)
-        access_token ||= access_token('GET', path, '')
-        authorization = format('Bearer %<access_token>s', access_token: access_token)
-        client.get(path, headers: { 'Authorization': authorization })
+        client.get path, access_token:
       end
     end
   end

data/lib/mixin_bot/api/auth.rb

@@ -3,85 +3,60 @@
 module MixinBot
   class API
     module Auth
-      def access_token(method, uri, body = '', exp_in: 600, scp: 'FULL')
-        sig = Digest::SHA256.hexdigest(method + uri + body.to_s)
-        iat = Time.now.utc.to_i
-        exp = (Time.now.utc + exp_in).to_i
-        jti = SecureRandom.uuid
-        payload = {
-          uid: client_id,
-          sid: session_id,
-          iat: iat,
-          exp: exp,
-          jti: jti,
-          sig: sig,
-          scp: scp
-        }
-        case key_type
-        when :ed25519
-          jwk = JOSE::JWK.from_okp [:Ed25519, private_key]
-          jws = JOSE::JWS.from({ 'alg' => 'EdDSA' })
-        when :rsa
-          jwk = JOSE::JWK.from_pem private_key
-          jws = JOSE::JWS.from({ 'alg' => 'RS512' })
-        end
-
-        jwt = JOSE::JWT.from payload
-        JOSE::JWT.sign(jwk, jws, jwt).compact
-      end
-
       def oauth_token(code)
         path = 'oauth/token'
         payload = {
-          client_id: client_id,
-          client_secret: client_secret,
-          code: code
+          client_id: config.app_id,
+          client_secret: config.client_secret,
+          code:
         }
-        r = client.post(path, json: payload)
-
-        raise r.inspect if r['error'].present?
-
-        r['data']&.[]('access_token')
+        client.post path, **payload
       end
 
       def request_oauth(scope = nil)
-        scope ||= (MixinBot.scope || 'PROFILE:READ')
+        scope ||= 'PROFILE:READ'
         format(
-          'https://mixin.one/oauth/authorize?client_id=%<client_id>s&scope=%<scope>s',
-          client_id: client_id,
-          scope: scope
+          'https://mixin.one/oauth/authorize?client_id=%<app_id>s&scope=%<scope>s',
+          app_id: config.app_id,
+          scope:
         )
       end
 
       def authorize_code(**kwargs)
-        path = '/oauth/authorize'
         data = authorization_data(
-          kwargs[:user_id],
+          kwargs[:app_id],
           kwargs[:scope] || ['PROFILE:READ']
         )
 
+        path = '/oauth/authorize'
+        pin = kwargs[:pin] || config.pin
         payload = {
           authorization_id: data['authorization_id'],
           scopes: data['scopes'],
           pin_base64: encrypt_pin(kwargs[:pin])
         }
 
-        access_token = kwargs[:access_token]
-        access_token ||= access_token('POST', path, payload.to_json)
-        authorization = format('Bearer %<access_token>s', access_token: access_token)
-        client.post(path, headers: { 'Authorization': authorization }, json: payload)
+        raise ArgumentError, 'pin is required' if pin.blank?
+
+        payload[:pin_base64] = if pin.size > 6
+                                 encrypt_tip_pin(pin, 'TIP:OAUTH:APPROVE:', data['scopes'], data['authorization_id'])
+                               else
+                                 encrypt_pin(pin)
+                               end
+
+        client.post path, **payload, access_token: kwargs[:access_token]
       end
 
-      def authorization_data(user_id, scope = ['PROFILE:READ'])
-        @_client_id = user_id
+      def authorization_data(app_id, scope = ['PROFILE:READ'])
+        @_app_id = app_id
         @_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: @_client_id,
+                  client_id: @_app_id,
                   scope: @_scope,
                   authorization_id: '',
                   code_challenge: ''
@@ -89,18 +64,21 @@ module MixinBot
               )
             end
 
-            def on_message(ws, event)
-              raw = JSON.parse read_ws_message(event.data)
-              @_data = raw['data']
-              ws.close
+            def on_message(websocket, event) # rubocop:disable Lint/NestedMethodDefinition
+              raw = JSON.parse ws_message(event.data)
+              @_data = raw
+              websocket.close
             end
 
-            def on_close(_ws, _event)
+            def on_close(_websocket, _event) # rubocop:disable Lint/NestedMethodDefinition
               EM.stop_event_loop
             end
           end
         end
-        @_data
+
+        raise MixinBot::RequestError, @_data if @_data['error'].present?
+
+        @_data['data']
       end
     end
   end

data/lib/mixin_bot/api/blaze.rb

@@ -5,9 +5,10 @@ module MixinBot
     module Blaze
       def blaze
         access_token = access_token('GET', '/', '')
-        authorization = format('Bearer %<access_token>s', access_token: access_token)
+
+        authorization = format('Bearer %<access_token>s', access_token:)
         Faye::WebSocket::Client.new(
-          format('wss://%<host>s/', host: blaze_host),
+          format('wss://%<host>s/', host: config.blaze_host),
           ['Mixin-Blaze-1'],
           headers: { 'Authorization' => authorization },
           ping: 60
@@ -31,7 +32,7 @@ module MixinBot
           if defined? on_message
             on_message ws, event
           else
-            raw = JSON.parse read_ws_message(event.data)
+            raw = JSON.parse ws_message(event.data)
             p [Time.now.to_s, :message, raw&.[]('action')]
 
             ws.send acknowledge_message_receipt(raw['data']['message_id']) unless raw&.[]('data')&.[]('message_id').nil?

data/lib/mixin_bot/api/conversation.rb

@@ -3,77 +3,67 @@
 module MixinBot
   class API
     module Conversation
-      def conversation(conversation_id)
-        path = format('/conversations/%<conversation_id>s', conversation_id: conversation_id)
-        access_token ||= access_token('GET', path, '')
-        authorization = format('Bearer %<access_token>s', access_token: access_token)
-        client.get(path, headers: { 'Authorization': authorization })
+      def conversation(conversation_id, access_token: nil)
+        path = format('/conversations/%<conversation_id>s', conversation_id:)
+        client.get path, access_token:
       end
-      alias read_conversation conversation
 
       def conversation_by_user_id(user_id)
-        conversation_id = unique_conversation_id(user_id)
-        read_conversation(conversation_id)
+        conversation_id = unique_uuid user_id
+        conversation conversation_id
       end
-      alias read_conversation_by_user_id conversation_by_user_id
 
-      def create_conversation(category:, conversation_id:, participants:, name: nil, access_token: nil)
+      def create_conversation(**kwargs)
         path = '/conversations'
         payload = {
-          category: category,
-          conversation_id: conversation_id || SecureRandom.uuid,
-          name: name,
-          participants: participants
-        }
+          category: kwargs[:category],
+          conversation_id: kwargs[:conversation_id] || SecureRandom.uuid,
+          name: kwargs[:name],
+          participants: kwargs[:participants]
+        }.compact_blank
 
-        access_token ||= access_token('POST', path, payload.to_json)
-        authorization = format('Bearer %<access_token>s', access_token: access_token)
-        client.post(path, headers: { 'Authorization': authorization }, json: payload)
+        client.post path, **payload, access_token: kwargs[:access_token]
       end
 
       def create_group_conversation(user_ids:, name:, conversation_id: nil, access_token: nil)
         create_conversation(
           category: 'GROUP',
-          conversation_id: conversation_id,
-          name: name,
+          conversation_id:,
+          name:,
           participants: user_ids.map(&->(participant) { { user_id: participant } }),
-          access_token: access_token
+          access_token:
         )
       end
 
       def create_contact_conversation(user_id, access_token: nil)
         create_conversation(
           category: 'CONTACT',
-          conversation_id: unique_conversation_id(user_id),
+          conversation_id: unique_uuid(user_id),
           participants: [
             {
-              user_id: user_id
+              user_id:
             }
           ],
-          access_token: access_token
+          access_token:
         )
       end
 
       def update_group_conversation_name(name:, conversation_id:, access_token: nil)
         path = format('/conversations/%<id>s', id: conversation_id)
         payload = {
-          name: name
+          name:
         }
 
-        access_token ||= access_token('POST', path, payload.to_json)
-        authorization = format('Bearer %<access_token>s', access_token: access_token)
-        client.post(path, headers: { 'Authorization': authorization }, json: payload)
+        client.post path, **payload, access_token:
       end
 
       def update_group_conversation_announcement(announcement:, conversation_id:, access_token: nil)
         path = format('/conversations/%<id>s', id: conversation_id)
         payload = {
-          announcement: announcement
+          announcement:
         }
 
-        access_token ||= access_token('POST', path, payload.to_json)
-        authorization = format('Bearer %<access_token>s', access_token: access_token)
-        client.post(path, headers: { 'Authorization': authorization }, json: payload)
+        client.post path, **payload, access_token:
       end
 
       # participants = [{ user_id: "" }]
@@ -81,9 +71,7 @@ module MixinBot
         path = format('/conversations/%<id>s/participants/ADD', id: conversation_id)
         payload = user_ids.map(&->(participant) { { user_id: participant } })
 
-        access_token ||= access_token('POST', path, payload.to_json)
-        authorization = format('Bearer %<access_token>s', access_token: access_token)
-        client.post(path, headers: { 'Authorization': authorization }, json: payload)
+        client.post path, *payload, access_token:
       end
 
       # participants = [{ user_id: "" }]
@@ -91,25 +79,19 @@ module MixinBot
         path = format('/conversations/%<id>s/participants/REMOVE', id: conversation_id)
         payload = user_ids.map(&->(participant) { { user_id: participant } })
 
-        access_token ||= access_token('POST', path, payload.to_json)
-        authorization = format('Bearer %<access_token>s', access_token: access_token)
-        client.post(path, headers: { 'Authorization': authorization }, json: payload)
+        client.post path, *payload, access_token:
       end
 
       def exit_conversation(conversation_id, access_token: nil)
         path = format('/conversations/%<id>s/exit', id: conversation_id)
 
-        access_token ||= access_token('POST', path)
-        authorization = format('Bearer %<access_token>s', access_token: access_token)
-        client.post(path, headers: { 'Authorization': authorization })
+        client.post path, access_token:
       end
 
       def rotate_conversation(conversation_id, access_token: nil)
         path = format('/conversations/%<id>s/rotate', id: conversation_id)
 
-        access_token ||= access_token('POST', path)
-        authorization = format('Bearer %<access_token>s', access_token: access_token)
-        client.post(path, headers: { 'Authorization': authorization })
+        client.post path, access_token:
       end
 
       # participants = [{ user_id: "", role: "ADMIN" }]
@@ -117,14 +99,12 @@ module MixinBot
         path = format('/conversations/%<id>s/participants/ROLE', id: conversation_id)
         payload = participants
 
-        access_token ||= access_token('POST', path, payload.to_json)
-        authorization = format('Bearer %<access_token>s', access_token: access_token)
-        client.post(path, headers: { 'Authorization': authorization }, json: payload)
+        client.post path, *payload, access_token:
       end
 
       def unique_uuid(user_id, opponent_id = nil)
-        opponent_id ||= client_id
-        MixinBot::Utils.unique_uuid user_id, opponent_id
+        opponent_id ||= config.app_id
+        MixinBot.utils.unique_uuid user_id, opponent_id
       end
       alias unique_conversation_id unique_uuid
     end

data/lib/mixin_bot/api/encrypted_message.rb

@@ -90,11 +90,11 @@ module MixinBot
           category: options[:category],
           quote_message_id: options[:quote_message_id],
           message_id: options[:message_id] || SecureRandom.uuid,
-          data_base64: data_base64,
-          checksum: checksum,
+          data_base64:,
+          checksum:,
           recipient_sessions: session_ids.map(&->(s) { { session_id: s } }),
           silent: false
-        }
+        }.compact
       end
 
       def send_encrypted_messages(messages)
@@ -104,19 +104,19 @@ module MixinBot
       # http post request
       def send_encrypted_message(payload)
         path = '/encrypted_messages'
-        payload = [payload] unless payload.is_a?(Array)
-        access_token ||= access_token('POST', path, payload.to_json)
-        authorization = format('Bearer %<access_token>s', access_token: access_token)
-        client.post(path, headers: { 'Authorization': authorization }, json: payload)
+        payload = [payload] if payload.is_a? Hash
+        raise ArgumentError, 'Wrong payload format!' unless payload.is_a? Array
+
+        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 = private_key[0...32]
-        pk ||= private_key[32...]
+        sk ||= config.session_private_key[0...32]
+        pk ||= config.session_private_key[32...]
 
-        checksum = Digest::MD5.hexdigest sessions.map(&->(s) { s['session_id'] }).sort.join
+        Digest::MD5.hexdigest sessions.map(&->(s) { s['session_id'] }).sort.join
         encrypter = OpenSSL::Cipher.new('AES-128-GCM').encrypt
         key = encrypter.random_key
         nounce = encrypter.random_iv
@@ -128,14 +128,14 @@ module MixinBot
         bytes = [1]
         bytes += [sessions.size].pack('v*').bytes
         bytes += JOSE::JWA::Ed25519.pk_to_curve25519(pk).bytes
-        
+
         sessions.each do |session|
           aes_key = JOSE::JWA::X25519.shared_secret(
             Base64.urlsafe_decode64(session['public_key']),
             JOSE::JWA::Ed25519.secret_to_curve25519(sk)
           )
 
-          padding = 16 - key.size % 16
+          padding = 16 - (key.size % 16)
           padtext = ([padding] * padding).pack('C*')
 
           encrypter = OpenSSL::Cipher.new('AES-256-CBC').encrypt
@@ -143,7 +143,7 @@ module MixinBot
           iv = encrypter.random_iv
           encrypter.iv = iv
 
-          bytes += (MixinBot::Utils::UUID.new(hex: session['session_id']).packed + iv).bytes
+          bytes += (MixinBot::UUID.new(hex: session['session_id']).packed + iv).bytes
           bytes += encrypter.update(key + padtext).bytes
         end
 
@@ -153,22 +153,22 @@ 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 ||= session_id
-        sk ||= private_key[0...32]
+        si ||= config.session_id
+        sk ||= config.session_private_key[0...32]
 
         size = 16 + 48
         return '' if bytes.size < 1 + 2 + 32 + size + 12
 
         session_length = bytes[1...3].pack('v*').unpack1('C*')
-        prefix_size = 35 + session_length * size
+        prefix_size = 35 + (session_length * size)
 
         i = 35
         key = ''
         while i < prefix_size
-          uuid = MixinBot::Utils::UUID.new(raw: bytes[i...(i + 16)].pack('C*')).unpacked
+          uuid = MixinBot::UUID.new(raw: bytes[i...(i + 16)].pack('C*')).unpacked
           if uuid == si
             pub = bytes[3...35]
             aes_key = JOSE::JWA::X25519.shared_secret(