mixin_bot 0.0.1.4 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc2618a1deab474b441b98f81845094b3178d3f5123d73a33aaefd0cc82f6e0d
-  data.tar.gz: 0da61f7a15af136541318f8af9fa107a864f5b4cdbc6c45ce17c8bea0ae8ac74
+  metadata.gz: 29930a091b973b490ea096e14f6344a0bc95f67b5023f081ac47fca36bc78adb
+  data.tar.gz: eb58283464badcf4573f417ad8108e06216811bce36e0990bf10022d8e4802c8
 SHA512:
-  metadata.gz: a474915b84c4fea0086aba993b5b4e0f43744aaa64808cd0728c966ad5f5d7c1375d6525fcedc203ec6943b1d163a8a56a0dc32e34cff15cdf3f55e0c15b7eaa
-  data.tar.gz: fcf9a02b7eb85c63e959bc47ea9054b7901d05bc68950ab8a90c99d976b424178f31db2fef693eb94c191480ebe77e27a5a21d6a8d326cc5a7c12d70f7f3d921
+  metadata.gz: 51e9e665540a634c383ee266d7b12ce67824c11a06a67fce43f66d3666a317d7c80e1ec974f7401ddb634230a73d0163702792876789c28210e91b8a43c68871
+  data.tar.gz: 7e503ad0ca5116e99cf36423049b3017109e1d4c2ced08b1625630c55448cc5fbbe4047d0fb3c4ea4bf4abdfa7b7ffc89592671116e8d4d0739bfef9b05c1f52

data/lib/mixin_bot/api/auth.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module MixinBot
   class API
     module Auth
-      def access_token(method, uri, body, exp_in=10.minutes)
-        sig = Digest::SHA256.hexdigest (method + uri + body)
+      def access_token(method, uri, body = '', exp_in = 600)
+        sig = Digest::SHA256.hexdigest(method + uri + body)
         iat = Time.now.utc.to_i
         exp = (Time.now.utc + exp_in).to_i
         jti = SecureRandom.uuid
@@ -28,12 +30,16 @@ module MixinBot
 
         raise r.inspect if r['error'].present?
 
-        return r['data']['access_token']
+        r['data']&.[]('access_token')
       end
 
-      def request_oauth(scope=nil)
+      def request_oauth(scope = nil)
         scope ||= (MixinBot.scope || 'PROFILE:READ+PHONE:READ')
-        format('https://mixin.one/oauth/authorize?client_id=%s&scope=%s', client_id, scope)
+        format(
+          'https://mixin.one/oauth/authorize?client_id=%<client_id>s&scope=%<scope>s',
+          client_id: client_id,
+          scope: scope
+        )
       end
     end
   end

data/lib/mixin_bot/api/conversation.rb

@@ -1,16 +1,18 @@
+# frozen_string_literal: true
+
 module MixinBot
   class API
     module Conversation
       def read_conversation(conversation_id)
-        path = format('/conversations/%s', conversation_id)
-        _access_token ||= self.access_token('GET', path, '')
-        authorization = format('Bearer %s', _access_token)
+        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 })
       end
 
       def read_conversation_by_user_id(user_id)
         conversation_id = unique_conversation_id(user_id)
-        return self.read_conversation(conversation_id)
+        read_conversation(conversation_id)
       end
 
       def create_contact_conversation(user_id)
@@ -26,8 +28,8 @@ module MixinBot
             }
           ]
         }
-        _access_token ||= self.access_token('POST', path, payload.to_json)
-        authorization = format('Bearer %s', _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)
       end
 
@@ -36,11 +38,19 @@ module MixinBot
         md5 << [user_id, client_id].min
         md5 << [user_id, client_id].max
         digest = md5.digest
-        digest_6 = (digest[6].ord & 0x0f | 0x30).chr
-        digest_8 = (digest[8].ord & 0x3f | 0x80).chr
-        cipher = digest[0...6] + digest_6 + digest[7] + digest_8 + digest[9..-1]
-        hex = cipher.unpack('H*').first
-        conversation_id = format('%s-%s-%s-%s-%s', hex[0..7], hex[8..11], hex[12..15], hex[16..19], hex[20..-1])
+        digest6 = (digest[6].ord & 0x0f | 0x30).chr
+        digest8 = (digest[8].ord & 0x3f | 0x80).chr
+        cipher = digest[0...6] + digest6 + digest[7] + digest8 + digest[9..-1]
+        hex = cipher.unpack1('H*')
+
+        format(
+          '%<first>s-%<second>s-%<third>s-%<forth>s-%<fifth>s',
+          first: hex[0..7],
+          second: hex[8..11],
+          third: hex[12..15],
+          forth: hex[16..19],
+          fifth: hex[20..-1]
+        )
       end
     end
   end

data/lib/mixin_bot/api/me.rb

@@ -1,42 +1,51 @@
+# frozen_string_literal: true
+
 module MixinBot
   class API
     module Me
-      def read_me(access_token=nil)
+      # https://developers.mixin.one/api/beta-mixin-message/read-profile/
+      def read_me
         path = '/me'
-        access_token ||= self.access_token('GET', path, '')
-        authorization = format('Bearer %s', access_token)
+        access_token = access_token('GET', path, '')
+        authorization = format('Bearer %<access_token>s', access_token: access_token)
         client.get(path, headers: { 'Authorization': authorization })
       end
 
-      def update_me(full_name, avatar_base64, access_token=nil)
+      # https://developers.mixin.one/api/beta-mixin-message/update-profile/
+      # avatar_base64:
+      # String: Base64 of image, supports format png, jpeg and gif, base64 image size > 1024.
+      def update_me(full_name:, avatar_base64: nil)
         path = '/me'
         payload = {
           full_name: full_name,
           avatar_base64: avatar_base64
         }
-        access_token ||= self.access_token('POST', path, payload.to_json)
-        authorization = format('Bearer %s', 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)
       end
 
-      def read_assets(access_token=nil)
+      # https://developers.mixin.one/api/alpha-mixin-network/read-assets/
+      def read_assets
         path = '/assets'
-        access_token ||= self.access_token('GET', path, '')
-        authorization = format('Bearer %s', access_token)
+        access_token = access_token('GET', path, '')
+        authorization = format('Bearer %<access_token>s', access_token: access_token)
         client.get(path, headers: { 'Authorization': authorization })
       end
 
-      def read_asset(asset_id, access_token=nil)
-        path = format('/assets/%s', asset_id)
-        access_token ||= self.access_token('GET', path, '')
-        authorization = format('Bearer %s', access_token)
+      # https://developers.mixin.one/api/alpha-mixin-network/read-asset/
+      def read_asset(asset_id)
+        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 })
       end
 
-      def read_friends(access_token=nil)
+      # https://developers.mixin.one/api/beta-mixin-message/friends/
+      def read_friends
         path = '/friends'
-        access_token ||= self.access_token('GET', path, '')
-        authorization = format('Bearer %s', access_token)
+        access_token = access_token('GET', path, '')
+        authorization = format('Bearer %<access_token>s', access_token: access_token)
         client.get(path, headers: { 'Authorization': authorization })
       end
     end

data/lib/mixin_bot/api/message.rb

@@ -1,69 +1,236 @@
+# frozen_string_literal: false
+
 module MixinBot
   class API
+    # https://developers.mixin.one/api/beta-mixin-message/websocket-messages/
     module Message
       def list_pending_message
-        write_message('LIST_PENDING_MESSAGES', {})
+        write_ws_message(action: 'LIST_PENDING_MESSAGES', params: {})
       end
 
+      # ACKNOWLEDGE_MESSAGE_RECEIPT ack server received message
+      # {
+      #   "id": "UUID",
+      #   "action": "ACKNOWLEDGE_MESSAGE_RECEIPT",
+      #   "params": {
+      #     "message_id": "UUID // message_id is you received message's message_id",
+      #     "status": "READ"
+      #   }
+      # }
       def acknowledge_message_receipt(message_id)
         params = {
           message_id: message_id,
           status: 'READ'
         }
-        write_message('ACKNOWLEDGE_MESSAGE_RECEIPT', params)
+        write_ws_message(action: 'ACKNOWLEDGE_MESSAGE_RECEIPT', params: params)
       end
 
-      def plain_text_message(conversation_id, text)
-        encoded_text = Base64.encode64 text
+      # {
+      #   "id": "UUID // generated by client",
+      #   "action":  "CREATE_MESSAGE",
+      #   "params": {
+      #     "conversation_id": "UUID",
+      #     "category": "PLAIN_TEXT",
+      #     "status": "SENT",
+      #     "message_id": "UUID // generated by client",
+      #     "data": "Base64 encoded data" ,
+      #   }
+      # }
+      def plain_text(options)
+        options.merge!(category: 'PLAIN_TEXT')
+        base_message_params(options)
+      end
 
-        params = {
-          conversation_id: conversation_id,
-          category: 'PLAIN_TEXT',
-          status: 'SENT',
-          message_id: SecureRandom.uuid,
-          data: encoded_text
-        }
+      # {
+      #   "id": "UUID",
+      #   "action": "CREATE_MESSAGE",
+      #   "params": {
+      #     "conversation_id": "UUID"
+      #     "category": "PLAIN_IMAGE"
+      #     "status": "SENT",
+      #     "message_id": "UUID",
+      #     "data": "Base64 encoded data"
+      #   }
+      # }
+      # data format:
+      # {
+      #   "attachment_id":
+      #   "Read From POST /attachments",
+      #   "mime_type": "",
+      #   "width": 1024,
+      #   "height": 1024,
+      #   "size": 1024,
+      #   "thumbnail": "base64 encoded"
+      # }
+      def plain_image(options)
+        options.merge!(category: 'PLAIN_IMAGE')
+        base_message_params(options)
+      end
 
-        write_message('CREATE_MESSAGE', params)
+      # {
+      #   "id":  "UUID",
+      #   "action":  "CREATE_MESSAGE",
+      #   "params": {
+      #     "conversation_id": "UUID",
+      #     "category": "PLAIN_DATA",
+      #     "status": "SENT",
+      #     "message_id": "UUID",
+      #     "data": "Base64 encoded data",
+      #   }
+      # }
+      # data format:
+      # {
+      #   "attachment_id": "Read From POST /attachments",
+      #   "mime_type": "",
+      #   "size": 1024,
+      #   "name": "Share"
+      # }
+      def plain_data(options)
+        options.merge!(category: 'PLAIN_DATA')
+        base_message_params(options)
       end
 
-      def app_card_message
-        # TODO:
+      # {
+      #   "id":  "UUID",
+      #   "action":  "CREATE_MESSAGE",
+      #   "params": {
+      #     "conversation_id": "UUID",
+      #     "category": "PLAIN_STICKER",
+      #     "status": "SENT",
+      #     "message_id":  "UUID",
+      #     "data": "Base64 encoded data"
+      #   }
+      # }
+      # data format:
+      # {
+      #   "name": "hello",
+      #   "album_id": "UUID"
+      # }
+      def plain_sticker(options)
+        options.merge!(category: 'PLAIN_STICKER')
+        base_message_params(options)
       end
 
-      def app_button_group_message(conversation_id, recipient_id, options={})
-        options = options.with_indifferent_access
-        label = options[:label] || ''
-        color = options[:color] || '#467fcf'
-        action = options[:action] || ''
+      # {
+      #   "id": "UUID",
+      #   "action": "CREATE_MESSAGE",
+      #   "params": {
+      #     "conversation_id": "UUID",
+      #     "category": "PLAIN_CONTACT"
+      #     "status": "SENT",
+      #     "message_id": "UUID",
+      #     "data":  "Base64 encoded data"
+      #   }
+      # }
+      # data format:
+      # { "user_id": "UUID"}
+      def plain_contact(options)
+        options.merge!(category: 'PLAIN_CONTACT')
+        base_message_params(options)
+      end
 
-        data = [{ label: label, color: color, action: action }]
-        encoded_data = Base64.encode64 data.to_json
+      # {
+      #   "id": "UUID",
+      #   "action": "CREATE_MESSAGE",
+      #   "params": {
+      #     "conversation_id": "UUID",
+      #     "category": "APP_CARD",
+      #     "status": "SENT",
+      #     "message_id": "UUID",
+      #     "data": "Base64 encoded data"
+      #   }
+      # }
+      # data format:
+      # {
+      #   "icon_url": "https://mixin.one/assets/98b586edb270556d1972112bd7985e9e.png",
+      #   "title": "Mixin",
+      #   "description": "A free and lightning fast peer-to-peer transactional network for digital assets.",
+      #   "action": "https://mixin.one"
+      # }
+      def app_card(options)
+        options.merge!(category: 'APP_CARD')
+        base_message_params(options)
+      end
 
-        params = {
+      # {
+      #   "id": "UUID",
+      #   "action": "CREATE_MESSAGE",
+      #   "params": {
+      #     "conversation_id": "UUID",
+      #     "category": "APP_BUTTON_GROUP",
+      #     "status": "SENT",
+      #     "message_id": "UUID",
+      #     "data": "Base64 encoded data"
+      #   }
+      # }
+      # data format:
+      # [
+      #   {
+      #     "label": "Mixin Website",
+      #     "color": "#ABABAB",
+      #     "action": "https://mixin.one"
+      #   },
+      #   ...
+      # ]
+      def app_button_group(options)
+        options.merge!(category: 'APP_BUTTON_GROUP')
+        base_message_params(options)
+      end
+
+      # {
+      #   "id": "UUID",
+      #   "action": "CREATE_MESSAGE",
+      #   "params": {
+      #     "conversation_id": "UUID",
+      #     "category": "PLAIN_VIDEO",
+      #     "status": "SENT",
+      #     "message_id": "UUID",
+      #     "data": "Base64 encoded data"
+      #   }
+      # }
+      # data format:
+      # {
+      #   "attachment_id": "Read From POST /attachments",
+      #   "mime_type": "",
+      #   "width": 1024,
+      #   "height": 1024,
+      #   "size": 1024,
+      #   "duration": 1024,
+      #   "thumbnail": "base64 encoded"
+      # }
+      def plain_video(options)
+        options.merge!(category: 'PLAIN_VIDEO')
+        base_message_params(options)
+      end
+
+      # base format of message params
+      def base_message_params(conversation_id:, category:, data:, quote_message_id: nil, message_id: nil)
+        data = data.is_a?(String) ? data : data.to_json
+        {
           conversation_id: conversation_id,
-          recipient_id: recipient_id,
-          category: 'APP_BUTTON_GROUP',
+          category: category,
           status: 'SENT',
-          message_id: SecureRandom.uuid,
-          data: encoded_data
+          quote_message_id: quote_message_id,
+          message_id: message_id || SecureRandom.uuid,
+          data: Base64.encode64(data)
         }
-
-        write_message('CREATE_MESSAGE', params)
       end
 
-      def read_message(data)
+      # read the gzipped message form websocket
+      def read_ws_message(data)
         io = StringIO.new(data.pack('c*'), 'rb')
         gzip = Zlib::GzipReader.new io
         msg = gzip.read
         gzip.close
-        return msg
+
+        msg
       end
 
-      def write_message(action, params)
+      # gzip the message for websocket
+      def write_ws_message(action: 'CREATE_MESSAGE', params:)
         msg = {
           id: SecureRandom.uuid,
-          action:  action,
+          action: action,
           params: params
         }.to_json
 
@@ -71,7 +238,55 @@ module MixinBot
         gzip = Zlib::GzipWriter.new io
         gzip.write msg
         gzip.close
-        data = io.string.unpack('c*')
+        io.string.unpack('c*')
+      end
+
+      # use HTTP to send message
+      def send_text_message(options)
+        send_message plain_text(options)
+      end
+
+      def send_contact_message(options)
+        send_message plain_contact(options)
+      end
+
+      def send_app_card_message(options)
+        send_message app_card(options)
+      end
+
+      def send_app_button_group_message(options)
+        send_message app_button_group(options)
+      end
+
+      # {
+      #   "id": "UUID",
+      #   "action": "CREATE_PLAIN_MESSAGES",
+      #   "params": {
+      #     "messages": [
+      #       {
+      #         "conversation_id": "UUID",
+      #         "recipient_id": "UUID",
+      #         "message_id": "UUID",
+      #         "representative_id": "UUID (optional, only supported in peer to peer conversation)",
+      #         "quote_message_id": "UUID (optional, only supported text, e.g. PLAIN_TEXT)",
+      #         "category": "Only support plain category e.g.: PLAIN_TEXT, PLAIN_STICKER etc",
+      #         "data": "Correspond to category."
+      #       },
+      #       ...
+      #     ]
+      #   }
+      # }
+      # not verified yet
+      def send_plain_messages(messages)
+        send_message(messages: messages)
+      end
+
+      # http post request
+      def send_message(payload)
+        path = '/messages'
+        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
     end
   end

data/lib/mixin_bot/api/payment.rb

@@ -1,29 +1,29 @@
+# frozen_string_literal: true
+
 module MixinBot
   class API
     module Payment
       def pay_url(options)
-        options = options.with_indifferent_access
-        recipient_id = options.fetch('recipient_id')
-        asset_id = options.fetch('asset_id')
-        amount = options.fetch('amount')
-        memo = options.fetch('memo')
-        trace = options.fetch('trace')
-        url = format('https://mixin.one/pay?recipient=%s&asset=%s&amount=%s&trace=%s&memo=%s', recipient_id, asset_id, amount, trace, memo)
+        format(
+          'https://mixin.one/pay?recipient=%<recipient_id>s&asset=%<asset>s&amount=%<amount>s&trace=%<trace>s&memo=%<memo>s',
+          recipient_id: options[:recipient_id],
+          asset: options[:asset_id],
+          amount: options[:amount].to_s,
+          trace: options[:trace],
+          memo: options[:memo]
+        )
       end
 
+      # https://developers.mixin.one/api/alpha-mixin-network/verify-payment/
       def verify_payment(options)
-        options = options.with_indifferent_access
-        recipient_id = options.fetch('recipient_id')
-        asset_id = options.fetch('asset_id')
-        amount = options.fetch('amount')
-        trace = options.fetch('trace')
         path = 'payments'
         payload = {
-          asset_id: asset_id,
-          opponent_id: recipient_id,
-          amount: amount,
-          trace_id: trace,
+          asset_id: options[:asset_id],
+          opponent_id: options[:opponent_id],
+          amount: options[:amount].to_s,
+          trace_id: options[:trace]
         }
+
         client.post(path, json: payload)
       end
     end

data/lib/mixin_bot/api/pin.rb

@@ -1,46 +1,68 @@
+# frozen_string_literal: true
+
 module MixinBot
   class API
     module Pin
-      def verify_pin(pin_code, access_token=nil)
+      # https://developers.mixin.one/api/alpha-mixin-network/verify-pin/
+      def verify_pin(pin_code)
         path = '/pin/verify'
         payload = {
           pin: encrypt_pin(pin_code)
         }
 
-        access_token ||= self.access_token('POST', path, payload.to_json)
-        authorization = format('Bearer %s', 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)
+      end
+
+      # not verified yet
+      # https://developers.mixin.one/api/alpha-mixin-network/create-pin/
+      def update_pin(old_pin:, new_pin:)
+        path = '/pin/update'
+        timestamp = Time.now.utc.to_i
+        payload = {
+          old_pin: old_pin.nil? ? '' : encrypt_pin(old_pin, timestamp: timestamp),
+          pin: encrypt_pin(new_pin, timestamp: timestamp)
+        }
+
+        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
 
+      # decrypt the encrpted pin, just for test
       def decrypt_pin(msg)
         msg = Base64.strict_decode64 msg
         iv = msg[0..15]
         cipher = msg[16..47]
-        aes_key = JOSE::JWA::PKCS1::rsaes_oaep_decrypt('SHA256', pin_token, private_key, session_id)
+        aes_key = JOSE::JWA::PKCS1.rsaes_oaep_decrypt('SHA256', pin_token, private_key, session_id)
         alg = 'AES-256-CBC'
         decode_cipher = OpenSSL::Cipher.new(alg)
         decode_cipher.decrypt
         decode_cipher.iv = iv
         decode_cipher.key = aes_key
-        plain = decode_cipher.update(cipher)
-        return plain
+        decoded = decode_cipher.update(cipher)
+        decoded[0..5]
       end
 
-      def encrypt_pin(pin_code)
-        aes_key = JOSE::JWA::PKCS1::rsaes_oaep_decrypt('SHA256', pin_token, private_key, session_id)
-        ts = Time.now.utc.to_i
-        tszero = ts % 0x100
-        tsone = (ts % 0x10000) >> 8
-        tstwo = (ts % 0x1000000) >> 16
-        tsthree = (ts % 0x100000000) >> 24
+      # https://developers.mixin.one/api/alpha-mixin-network/encrypted-pin/
+      # use timestamp(timestamp) for iterator as default: must be bigger than the previous, the first time must be greater than 0. After a new session created, it will be reset to 0.
+      def encrypt_pin(pin_code, timestamp: nil)
+        aes_key = JOSE::JWA::PKCS1.rsaes_oaep_decrypt('SHA256', pin_token, private_key, session_id)
+        timestamp ||= Time.now.utc.to_i
+        tszero = timestamp % 0x100
+        tsone = (timestamp % 0x10000) >> 8
+        tstwo = (timestamp % 0x1000000) >> 16
+        tsthree = (timestamp % 0x100000000) >> 24
         tsstring = tszero.chr + tsone.chr + tstwo.chr + tsthree.chr + "\0\0\0\0"
         encrypt_content = pin_code + tsstring + tsstring
         pad_count = 16 - encrypt_content.length % 16
-        if pad_count > 0
-          padded_content = encrypt_content + pad_count.chr * pad_count
-        else
-          padded_content = encrypt_content
-        end
+        padded_content =
+          if pad_count.positive?
+            encrypt_content + pad_count.chr * pad_count
+          else
+            encrypt_content
+          end
 
         alg = 'AES-256-CBC'
         aes = OpenSSL::Cipher.new(alg)
@@ -50,7 +72,7 @@ module MixinBot
         aes.iv = iv
         cipher = aes.update(padded_content)
         msg = iv + cipher
-        return Base64.strict_encode64 msg
+        Base64.strict_encode64 msg
       end
     end
   end

data/lib/mixin_bot/api/snapshot.rb

@@ -1,25 +1,31 @@
+# frozen_string_literal: true
+
 module MixinBot
   class API
     module Snapshot
-      def read_snapshots(options)
-        options = options.with_indifferent_access
-        limit = options['limit']
-        offset = options['offset']
-        asset = options['asset']
-        order = options['order']
+      def read_snapshots(options = {})
+        path = format(
+          '/network/snapshots?limit=%<limit>s&offset=%<offset>s&asset=%<asset>s&order=%<order>s',
+          limit: options[:limit],
+          offset: options[:offset],
+          asset: options[:asset],
+          order: options[:order]
+        )
 
-        path = 'network/snapshots'
-        payload = {
-          limit: limit,
-          offset: offset,
-          asset: asset,
-          order: order
-        }
-        client.get(path, params: payload)
+        if options[:private]
+          # TODO:
+          # read private snapshots
+          access_token = access_token('GET', path)
+          authorization = format('Bearer %<access_token>s', access_token: access_token)
+          client.get(path, headers: { 'Authorization': authorization, 'Content-length': 0 })
+        else
+          # read public snapshots as default
+          client.get(path)
+        end
       end
 
       def read_snapshot(snapshot_id)
-        path = format('network/snapshots/%s', snapshot_id)
+        path = format('network/snapshots/%<snapshot_id>s', snapshot_id: snapshot_id)
         client.get(path)
       end
     end

data/lib/mixin_bot/api/transfer.rb

@@ -1,35 +1,34 @@
+# frozen_string_literal: true
+
 module MixinBot
   class API
     module Transfer
       def create_transfer(pin, options)
-        options = options.with_indifferent_access
-
-        asset_id = options.fetch('asset_id')
-        opponent_id = options.fetch('opponent_id')
-        amount = options.fetch('amount')
-        memo = options.fetch('memo')
-        trace_id = options.fetch('trace_id')
-        trace_id ||= SecureRandom.uuid
+        asset_id = options[:asset_id]
+        opponent_id = options[:opponent_id]
+        amount = options[:amount]
+        memo = options[:memo]
+        trace_id = options[:trace_id] || SecureRandom.uuid
 
         path = '/transfers'
         payload = {
           asset_id: asset_id,
           opponent_id: opponent_id,
           pin: pin,
-          amount: amount,
+          amount: amount.to_s,
           trace_id: trace_id,
           memo: memo
         }
 
-        access_token ||= self.access_token('POST', path, payload.to_json)
-        authorization = format('Bearer %s', 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)
       end
 
       def read_transfer(trace_id)
-        path = format('/transfers/trace/%s', trace_id)
-        access_token ||= self.access_token('GET', path, '')
-        authorization = format('Bearer %s', access_token)
+        path = format('/transfers/trace/%<trace_id>s', trace_id: trace_id)
+        access_token ||= access_token('GET', path, '')
+        authorization = format('Bearer %<access_token>s', access_token: access_token)
         client.get(path, headers: { 'Authorization': authorization })
       end
     end

data/lib/mixin_bot/api/user.rb

@@ -1,29 +1,62 @@
+# frozen_string_literal: true
+
 module MixinBot
   class API
     module User
-      def read_user(user_id, access_token=nil)
+      def read_user(user_id, access_token = nil)
         # user_id: Mixin User Id
-        path = format('/users/%s', user_id)
-        access_token ||= self.access_token('GET', path, '')
-        authorization = format('Bearer %s', access_token)
+        path = format('/users/%<user_id>s', user_id: user_id)
+        access_token ||= access_token('GET', path, '')
+        authorization = format('Bearer %<access_token>s', access_token: access_token)
         client.get(path, headers: { 'Authorization': authorization })
       end
 
-      def search_user(q, access_token=nil)
-        # q: Mixin Id or Phone Number
-        path = format('/search/%s', q)
-        access_token ||= self.access_token('GET', path, '')
-        authorization = format('Bearer %s', access_token)
+      # https://developers.mixin.one/api/alpha-mixin-network/app-user/
+      # Create a new Mixin Network user (like a normal Mixin Messenger user). You should keep PrivateKey which is used to sign an AuthenticationToken and encrypted PIN for the user.
+      def create_user(full_name, rsa_key = nil)
+        rsa_key ||= generate_rsa_key
+        session_secret = rsa_key[:public_key]
+        session_secret.gsub!(/^-----.*PUBLIC KEY-----$/, '').strip!
+
+        payload = {
+          full_name: full_name,
+          session_secret: session_secret
+        }
+
+        access_token = access_token('POST', '/users', payload.to_json)
+        authorization = format('Bearer %<access_token>s', access_token: access_token)
+        res = client.post('/users', headers: { 'Authorization': authorization }, json: payload)
+
+        res.merge(rsa_key: rsa_key)
+      end
+
+      def generate_rsa_key
+        rsa_key = OpenSSL::PKey::RSA.new 1024
+        {
+          private_key: rsa_key.to_pem,
+          public_key: rsa_key.public_key.to_pem
+        }
+      end
+      
+      # https://developers.mixin.one/api/beta-mixin-message/search-user/
+      # search by Mixin Id or Phone Number
+      def search_user(query, access_token = nil)
+        path = format('/search/%<query>s', query: query)
+
+        access_token ||= access_token('GET', path, '')
+        authorization = format('Bearer %<access_token>s', access_token: access_token)
         client.get(path, headers: { 'Authorization': authorization })
       end
 
-      def fetch_users(user_ids, access_token=nil)
+      # https://developers.mixin.one/api/beta-mixin-message/read-users/
+      def fetch_users(user_ids, access_token = nil)
         # user_ids: a array of user_ids
         path = '/users/fetch'
         user_ids = [user_ids] if user_ids.is_a? String
         payload = user_ids
-        access_token ||= self.access_token('POST', path, payload.to_json)
-        authorization = format('Bearer %s', 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)
       end
     end

data/lib/mixin_bot/api/withdraw.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    module Withdraw
+      # https://developers.mixin.one/api/alpha-mixin-network/create-address/
+      def create_withdraw_address(options)
+        path = '/addresses'
+        encrypted_pin = encrypt_pin(options[:pin])
+        payload = 
+          # for EOS withdraw, account_name & account_tag must be valid
+          if options[:public_key].nil?
+            {
+              asset_id: options[:asset_id],
+              account_name: options[:account_name],
+              account_tag: options[:account_tag],
+              label: options[:label],
+              pin: encrypted_pin
+            }
+          # for other withdraw
+          else
+            {
+              asset_id: options[:asset_id],
+              public_key: options[:public_key],
+              label: options[:label],
+              pin: encrypted_pin
+            }
+          end
+
+        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
+
+      # https://developers.mixin.one/api/alpha-mixin-network/read-address/
+      def get_withdraw_address(address)
+        path = format('/addresses/%<address>s', address: address)
+        access_token = access_token('GET', path, '')
+        authorization = format('Bearer %<access_token>s', access_token: access_token)
+        client.get(path, headers: { 'Authorization': authorization })
+      end
+
+      # https://developers.mixin.one/api/alpha-mixin-network/delete-address/
+      def delete_withdraw_address(address, pin)
+        path = format('/addresses/%<address>s/delete', address: address)
+        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
+
+      # https://developers.mixin.one/api/alpha-mixin-network/withdrawal-addresses/
+      def withdrawals(options)
+        address_id = options[:address_id]
+        pin = options[:pin]
+        amount = options[:amount]
+        trace_id = options[:trace_id]
+        memo = options[:memo]
+
+        path = '/withdrawals'
+        payload = {
+          address_id: address_id,
+          amount: amount,
+          trace_id: trace_id,
+          memo: memo,
+          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
+    end
+  end
+end

data/lib/mixin_bot/api.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative './client'
 require_relative './errors'
 require_relative './api/auth'
@@ -9,14 +11,15 @@ require_relative './api/pin'
 require_relative './api/snapshot'
 require_relative './api/transfer'
 require_relative './api/user'
+require_relative './api/withdraw'
 
 module MixinBot
   class API
     attr_reader :client_id, :client_secret, :session_id, :pin_token, :private_key
     attr_reader :client
 
-    def initialize(options={})
-      @client_id = options[:client_id]  || MixinBot.client_id
+    def initialize(options = {})
+      @client_id = options[:client_id] || MixinBot.client_id
       @client_secret = options[:client_secret] || MixinBot.client_secret
       @session_id = options[:session_id] || MixinBot.session_id
       @pin_token = Base64.decode64 options[:pin_token] || MixinBot.pin_token
@@ -33,5 +36,6 @@ module MixinBot
     include MixinBot::API::Snapshot
     include MixinBot::API::Transfer
     include MixinBot::API::User
+    include MixinBot::API::Withdraw
   end
 end

data/lib/mixin_bot/client.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module MixinBot
   class Client
-    SERVER_SCHEME = 'https'.freeze
-    SERVER_HOST = 'api.mixin.one'.freeze
+    SERVER_SCHEME = 'https'
+    SERVER_HOST = 'api.mixin.one'
 
     def get(path, options = {})
       request(:get, path, options)
@@ -14,30 +16,24 @@ module MixinBot
     private
 
     def request(verb, path, options = {})
-      uri = uri_for(path)
-      options = options.with_indifferent_access
+      uri = uri_for path
 
-      options['headers'] ||= {}
-      if options['headers']['Content-Type'].blank?
-        options['headers']['Content-Type'] = 'application/json'
-      end
+      options[:headers] ||= {}
+      options[:headers]['Content-Type'] ||= 'application/json'
 
       begin
         response = HTTP.timeout(connect: 5, write: 5, read: 5).request(verb, uri, options)
-      rescue HTTP::Error => ex
-        Rails.logger.error format('%s (%s):', ex.class.name, ex.message)
-        Rails.logger.error ex.backtrace.join("\n")
-        raise Errors::HttpError, ex.message
+      rescue HTTP::Error => e
+        raise Errors::HttpError, e.message
       end
 
-      unless response.status.success?
-        raise Errors::APIError.new(nil, response.to_s)
-      end
+      raise Errors::APIError.new(nil, response.to_s) unless response.status.success?
 
       parse_response(response) do |parse_as, result|
         case parse_as
         when :json
-          break result if result[:errcode].blank? || result[:errcode].zero?
+          break result if result[:errcode].nil? || result[:errcode].zero?
+
           raise Errors::APIError.new(result[:errcode], result[:errmsg])
         else
           result
@@ -58,34 +54,32 @@ module MixinBot
       content_type = response.headers[:content_type]
       parse_as = {
         %r{^application\/json} => :json,
-        %r{^image\/.*}         => :file,
-        %r{^text\/html}        => :xml,
-        %r{^text\/plain}       => :plain
+        %r{^image\/.*} => :file,
+        %r{^text\/html} => :xml,
+        %r{^text\/plain} => :plain
       }.each_with_object([]) { |match, memo| memo << match[1] if content_type =~ match[0] }.first || :plain
 
       if parse_as == :plain
-        result = ActiveSupport::JSON.decode(response.body.to_s).with_indifferent_access rescue nil
-        if result
-          return yield(:json, result)
-        else
-          return yield(:plain, response.body)
-        end
+        result = JSON.parse(response&.body&.to_s)
+        result && yield(:json, result)
+
+        yield(:plain, response.body)
       end
 
       case parse_as
       when :json
-        result = ActiveSupport::JSON.decode(response.body.to_s).with_indifferent_access
+        result = JSON.parse(response.body.to_s)
       when :file
-        if response.headers[:content_type] =~ %r{^image\/.*}
-          extension =
+        extension =
+          if response.headers[:content_type] =~ %r{^image\/.*}
             case response.headers['content-type']
             when 'image/gif'  then '.gif'
             when 'image/jpeg' then '.jpg'
             when 'image/png'  then '.png'
             end
-        else
-          extension = ''
-        end
+          else
+            ''
+          end
 
         begin
           file = Tempfile.new(['mixin-file-', extension])

data/lib/mixin_bot/errors.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MixinBot
   module Errors
     # 通用异常
@@ -14,7 +16,7 @@ module MixinBot
         @errcode = errcode
         @errmsg = errmsg
 
-        super(format('[%s]: %s', @errcode, @errmsg))
+        super(format('[%<errcode>s]: %<errmsg>s', errcode: @errcode, errmsg: @errmsg))
       end
     end
   end

data/lib/mixin_bot/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MixinBot
-  VERSION = '0.0.1.4'.freeze
+  VERSION = '0.1.0'
 end

data/lib/mixin_bot.rb

@@ -1,4 +1,5 @@
-require 'active_support/all'
+# frozen_string_literal: true
+
 require 'http'
 require 'base64'
 require 'openssl'
@@ -12,6 +13,6 @@ module MixinBot
   end
 
   def self.api
-    @api ||= MixinBot::API.new(options={})
+    @api ||= MixinBot::API.new
   end
 end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: mixin_bot
 version: !ruby/object:Gem::Version
-  version: 0.0.1.4
+  version: 0.1.0
 platform: ruby
 authors:
 - an-lee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-16 00:00:00.000000000 Z
+date: 2019-07-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: http
+  name: bcrypt
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -25,7 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: jwt
+  name: http
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -53,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: bcrypt
+  name: jwt
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -67,13 +67,55 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -99,6 +141,7 @@ files:
 - lib/mixin_bot/api/snapshot.rb
 - lib/mixin_bot/api/transfer.rb
 - lib/mixin_bot/api/user.rb
+- lib/mixin_bot/api/withdraw.rb
 - lib/mixin_bot/client.rb
 - lib/mixin_bot/errors.rb
 - lib/mixin_bot/version.rb