mixin_bot 0.0.1.4 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc2618a1deab474b441b98f81845094b3178d3f5123d73a33aaefd0cc82f6e0d
-  data.tar.gz: 0da61f7a15af136541318f8af9fa107a864f5b4cdbc6c45ce17c8bea0ae8ac74
+  metadata.gz: 490beec97c1c3ba36f339f4a947f7717ee7eafa0aad01ba7d36c0ad8962af0e2
+  data.tar.gz: e00974b0b39f0002d60ced9f3ad416ce4b0addc63ba2d6e14584fc5b3f64a4c3
 SHA512:
-  metadata.gz: a474915b84c4fea0086aba993b5b4e0f43744aaa64808cd0728c966ad5f5d7c1375d6525fcedc203ec6943b1d163a8a56a0dc32e34cff15cdf3f55e0c15b7eaa
-  data.tar.gz: fcf9a02b7eb85c63e959bc47ea9054b7901d05bc68950ab8a90c99d976b424178f31db2fef693eb94c191480ebe77e27a5a21d6a8d326cc5a7c12d70f7f3d921
+  metadata.gz: ccf975f89a77c9421151ec6235939a9b1e78359253597daa81e70e7e4badd1362e9c617425e547681ac25be72bdad25c0d56334dc9cc9a56b97abe0b08913dd7
+  data.tar.gz: c6d2dabfd14fa960f32549e2ba082d275a618f058b25ab54217e900197d42d10659c48a36e484aff55ed58c92e3355c35a121e599e6b110286bbd9ac3fc06b22

data/bin/mixinbot

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/mixin_bot'
+
+MixinBot::CLI.start(ARGV)

data/lib/mixin_bot.rb

@@ -1,17 +1,25 @@
-require 'active_support/all'
-require 'http'
+# frozen_string_literal: true
+
+require 'English'
 require 'base64'
-require 'openssl'
-require 'jwt'
+require 'digest'
+require 'faye/websocket'
+require 'http'
 require 'jose'
+require 'jwt'
+require 'msgpack'
+require 'open3'
+require 'openssl'
 require_relative './mixin_bot/api'
+require_relative './mixin_bot/cli'
+require_relative './mixin_bot/version'
 
 module MixinBot
   class<< self
-    attr_accessor :client_id, :client_secret, :session_id, :pin_token, :private_key, :scope
+    attr_accessor :client_id, :client_secret, :session_id, :pin_token, :private_key, :scope, :api_host, :blaze_host
   end
 
   def self.api
-    @api ||= MixinBot::API.new(options={})
+    @api ||= MixinBot::API.new
   end
 end

data/lib/mixin_bot/api.rb

@@ -1,37 +1,79 @@
+# frozen_string_literal: true
+
 require_relative './client'
 require_relative './errors'
+require_relative './api/app'
+require_relative './api/attachment'
 require_relative './api/auth'
+require_relative './api/blaze'
 require_relative './api/conversation'
 require_relative './api/me'
 require_relative './api/message'
+require_relative './api/multisig'
 require_relative './api/payment'
 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
+    attr_reader :client_id, :client_secret, :session_id, :pin_token, :private_key, :client, :blaze_host, :schmoozer
 
-    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
-      @private_key = OpenSSL::PKey::RSA.new options[:private_key] || MixinBot.private_key
-      @client = Client.new
+      @pin_token = Base64.urlsafe_decode64 options[:pin_token] || MixinBot.pin_token
+      @client = Client.new(MixinBot.api_host || 'api.mixin.one')
+      @blaze_host = MixinBot.blaze_host || 'blaze.mixin.one'
+      _private_key = options[:private_key] || MixinBot.private_key
+      @private_key =
+        if /^-----BEGIN RSA PRIVATE KEY-----/.match? _private_key
+          _private_key.gsub('\\r\\n', "\n").gsub("\r\n", "\n")
+        else
+          Base64.urlsafe_decode64 _private_key
+        end
+    end
+
+    # Use a mixin software to implement transaction build
+    def build_transaction(json)
+      ensure_mixin_command_exist
+      command = format("mixin signrawtransaction --raw '%<arg>s'", arg: json)
+
+      output, error = Open3.capture3(command)
+      raise error unless error.empty?
+
+      output.chomp
     end
 
+    include MixinBot::API::App
+    include MixinBot::API::Attachment
     include MixinBot::API::Auth
+    include MixinBot::API::Blaze
     include MixinBot::API::Conversation
     include MixinBot::API::Me
     include MixinBot::API::Message
+    include MixinBot::API::Multisig
     include MixinBot::API::Payment
     include MixinBot::API::Pin
     include MixinBot::API::Snapshot
     include MixinBot::API::Transfer
     include MixinBot::API::User
+    include MixinBot::API::Withdraw
+
+    private
+
+    def ensure_mixin_command_exist
+      return if command?('mixin')
+
+      raise '`mixin` command is not valid!'
+    end
+
+    def command?(name)
+      `which #{name}`
+      $CHILD_STATUS.success?
+    end
   end
 end

data/lib/mixin_bot/api/app.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    module App
+      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 })
+      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 })
+      end
+
+      def favorite_apps(user_id, access_token: nil)
+        path = format('/users/%<id>s/apps/favorite', 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
+    end
+  end
+end

data/lib/mixin_bot/api/attachment.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    module Attachment
+      # https://developers.mixin.one/api/beta-mixin-message/create-attachment/
+      # Sample Response
+      # {
+      #   "data":{
+      #     "type":"attachment",
+      #     "attachment_id":"7a54e394-1626-4cd4-b967-543932c2a032",
+      #     "upload_url":"https://moments-shou-tv.s3.amazonaws.com/mixin/attachments/xxx",
+      #     "view_url":"https://moments.shou.tv/mixin/attachments/1526305123xxxx"
+      #   }
+      # }
+      # Once get the upload_url, use it to upload the your file via PUT request
+      def create_attachment
+        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: {})
+      end
+
+      def read_attachment(attachment_id)
+        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 })
+      end
+    end
+  end
+end

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, scp: 'FULL')
+        sig = Digest::SHA256.hexdigest(method + uri + body)
         iat = Time.now.utc.to_i
         exp = (Time.now.utc + exp_in).to_i
         jti = SecureRandom.uuid
@@ -12,9 +14,19 @@ module MixinBot
           iat: iat,
           exp: exp,
           jti: jti,
-          sig: sig
+          sig: sig,
+          scp: scp
         }
-        JWT.encode payload, private_key, 'RS512'
+        if pin_token.size == 32
+          jwk = JOSE::JWK.from_okp [:Ed25519, private_key]
+          jws = JOSE::JWS.from({ 'alg' => 'EdDSA' })
+        else
+          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)
@@ -28,12 +40,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)
-        scope ||= (MixinBot.scope || 'PROFILE:READ+PHONE:READ')
-        format('https://mixin.one/oauth/authorize?client_id=%s&scope=%s', client_id, scope)
+      def request_oauth(scope = nil)
+        scope ||= (MixinBot.scope || 'PROFILE:READ')
+        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/blaze.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    module Blaze
+      def blaze
+        access_token = access_token('GET', '/', '')
+        authorization = format('Bearer %<access_token>s', access_token: access_token)
+        Faye::WebSocket::Client.new(
+          format('wss://%<host>s/', host: blaze_host),
+          ['Mixin-Blaze-1'],
+          headers: { 'Authorization' => authorization },
+          ping: 60
+        )
+      end
+
+      def start_blaze_connect(reconnect: true, &_block)
+        ws ||= blaze
+        yield if block_given?
+
+        ws.on :open do |event|
+          if defined? on_open
+            on_open ws, event
+          else
+            p [Time.now.to_s, :open]
+            ws.send list_pending_message
+          end
+        end
+
+        ws.on :message do |event|
+          if defined? on_message
+            on_message ws, event
+          else
+            raw = JSON.parse read_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?
+          end
+        end
+
+        ws.on :error do |event|
+          if defined? on_error
+            on_error ws, event
+          else
+            p [Time.now.to_s, :error]
+          end
+        end
+
+        ws.on :close do |event|
+          if defined? on_close
+            on_close ws, event
+          else
+            p [Time.now.to_s, :close, event.code, event.reason]
+          end
+
+          ws = nil
+          start_blaze_connect(&block) if reconnect
+        end
+      end
+    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,21 +28,30 @@ 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
 
-      def unique_conversation_id(user_id)
+      def unique_conversation_id(user_id, opponent_id = nil)
+        opponent_id ||= client_id
         md5 = Digest::MD5.new
-        md5 << [user_id, client_id].min
-        md5 << [user_id, client_id].max
+        md5 << [user_id, opponent_id].min
+        md5 << [user_id, opponent_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..]
+        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..]
+        )
       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(access_token: nil)
         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, access_token: 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(access_token: nil)
         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, 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 })
       end
 
-      def read_friends(access_token=nil)
+      # https://developers.mixin.one/api/beta-mixin-message/friends/
+      def read_friends(access_token: nil)
         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