mixin_bot 0.12.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf2e7ef08c38a52d5d31ce1be5a0531f13680e31cb5e7f11cd6e1582436d8711
-  data.tar.gz: '08cfa89514d3f102cdd064cfb3c3367cf2166292a3abc854481320a2fb610d15'
+  metadata.gz: 2ebb5e10a678c90007560b0f84676d0545ea510de1cefc5534091e0b1338c13b
+  data.tar.gz: afe4ffc00de92429959bc310a6082112f3dc54d8c48e687165a08e0499a3b1a5
 SHA512:
-  metadata.gz: a5f7af8574ea545b899bd2081923dd75e0b2ef2288346fb8e8d842b642ef596c626370d9a5140a695c267db4281e4c51239cce2d55f5edb87ed33127c76c379b
-  data.tar.gz: b2393b4a392ff025b0e6d58c545018bd4cafb26e9fb130bba8938e42d4850a6f2b5d0244d887f6dae8d8f53fcb000819737ea71d999add7e175637c7e2d591d1
+  metadata.gz: 334913613e7a88d94e3783fbf028545ecfa0cecdb0a46c7189a63563be17830d33a1de098714e7c38da97094e041f16805cb5782b1101587629dde8d91d4abe6
+  data.tar.gz: b2ae3479345b421c7e96983c32c0e85c42a028022f74428c90467407eeea93f323b52126d5ab305ee317ae44db69a8e284ec024fdd738fbe095c6a7cbe11e1f4

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,77 +3,52 @@
 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
@@ -81,7 +56,7 @@ module MixinBot
               ws.send write_ws_message(
                 action: 'REFRESH_OAUTH_CODE',
                 params: {
-                  client_id: @_client_id,
+                  client_id: @_app_id,
                   scope: @_scope,
                   authorization_id: '',
                   code_challenge: ''
@@ -90,8 +65,8 @@ module MixinBot
             end
 
             def on_message(ws, event)
-              raw = JSON.parse read_ws_message(event.data)
-              @_data = raw['data']
+              raw = JSON.parse ws_message(event.data)
+              @_data = raw
               ws.close
             end
 
@@ -100,7 +75,10 @@ module MixinBot
             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/collectible.rb

@@ -7,40 +7,37 @@ module MixinBot
 
       def collectible(id, access_token: nil)
         path = "/collectibles/tokens/#{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
 
       def collection(id, access_token: nil)
         path = "/collectibles/collections/#{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
 
-      def collectible_outputs(**kwargs)
+      def collectibles(**kwargs)
         limit = kwargs[:limit] || 100
         offset = kwargs[:offset] || ''
         state = kwargs[:state] || ''
-        members = kwargs[:members] || [client_id]
-        threshold = kwargs[:threshold] || 1
-        access_token = kwargs[:access_token]
+
+        members = kwargs[:members] || [config.app_id]
+        threshold = kwargs[:threshold] || members.length
+
         members = SHA3::Digest::SHA256.hexdigest(members&.sort&.join)
 
-        path = format(
-          '/collectibles/outputs?limit=%<limit>s&offset=%<offset>s&state=%<state>s&members=%<members>s&threshold=%<threshold>s',
-          limit: limit,
-          offset: offset,
-          state: state,
-          members: members,
-          threshold: threshold
-        )
-        access_token ||= access_token('GET', path, '')
-        authorization = format('Bearer %<access_token>s', access_token: access_token)
-        client.get(path, headers: { 'Authorization': authorization })
+        access_token = kwargs[:access_token]
+
+        path = '/collectibles/outputs'
+        params = {
+          limit:,
+          offset:,
+          state:,
+          members:,
+          threshold:
+        }
+
+        client.get path, **params, access_token:
       end
-      alias collectibles collectible_outputs
 
       COLLECTABLE_REQUEST_ACTIONS = %i[sign unlock].freeze
       def create_collectible_request(action, raw, access_token: nil)
@@ -48,50 +45,56 @@ module MixinBot
 
         path = '/collectibles/requests'
         payload = {
-          action: action,
-          raw: raw
+          action:,
+          raw:
         }
-        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 create_sign_collectible_request(raw, access_token: nil)
-        create_collectible_request 'sign', raw, access_token: access_token
+        create_collectible_request 'sign', raw, access_token:
       end
 
       def create_unlock_collectible_request(raw, access_token: nil)
-        create_collectible_request 'unlock', raw, access_token: access_token
+        create_collectible_request 'unlock', raw, access_token:
       end
 
-      def sign_collectible_request(request_id, pin)
-        path = format('/collectibles/requests/%<request_id>s/sign', request_id: request_id)
-        payload = {
-          pin: encrypt_pin(pin)
-        }
-        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)
+      def sign_collectible_request(request_id, pin = nil)
+        pin ||= config.pin
+        raise ArgumentError, 'pin is needed for sign collectible request' if pin.blank?
+
+        path = format('/collectibles/requests/%<request_id>s/sign', request_id:)
+        payload =
+          if pin.length > 6
+            pin_base64 =  encrypt_tip_pin(pin, 'TIP:COLLECTIBLE:REQUEST:SIGN:', request_id)
+            {
+              pin_base64:
+            }
+          else
+            {
+              pin: encrypt_pin(pin)
+            }
+          end
+        client.post path, **payload
       end
 
-      def unlock_collectible_request(request_id, pin)
-        path = format('/collectibles/requests/%<request_id>s/unlock', request_id: request_id)
-        payload = {
-          pin: encrypt_pin(pin)
-        }
-        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)
-      end
-
-      def cancel_collectible_request(request_id, pin)
-        path = format('/collectibles/requests/%<request_id>s/cancel', request_id: request_id)
-        payload = {
-          pin: encrypt_pin(pin)
-        }
-        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)
+      def unlock_collectible_request(request_id, pin = nil)
+        pin ||= config.pin
+        raise ArgumentError, 'pin is needed for sign collectible request' if pin.blank?
+
+        path = format('/collectibles/requests/%<request_id>s/unlock', request_id:)
+        payload =
+          if pin.length > 6
+            {
+              pin_base64: encrypt_tip_pin(pin, 'TIP:COLLECTIBLE:REQUEST:UNLOCK:', request_id)
+            }
+          else
+            {
+              pin: encrypt_pin(pin)
+            }
+          end
+
+        client.post path, **payload
       end
     end
 
@@ -123,16 +126,15 @@ module MixinBot
         senders_threshold: collectible['receivers_threshold'],
         receivers: kwargs['receivers'],
         receivers_threshold: kwargs['receivers_threshold'],
-        extra: kwargs['nfo'],
+        extra: [kwargs['nfo']].pack('H*'),
         amount: 1,
         asset_mixin_id: NFT_ASSET_MIXIN_ID,
-        access_token: kwargs['access_token'],
         hint: kwargs['hint']
       )
     end
 
     def nft_memo(collection, token_id, meta)
-      MixinBot::Utils.nft_memo collection, token_id, meta
+      MixinBot.utils.nft_memo collection, token_id, meta
     end
   end
 end

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