mixin_bot 0.1.4 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d5375d1baf6a03ec32d4e32ee415917e439780e6361473497a57f12ad2df248
-  data.tar.gz: 5d03c3a70cccdc5a12b589f4b8697e6b408107af79884949a2b645ef942ca71e
+  metadata.gz: 0d2d1a5483fbd7210ab5f4e9a08697c0ed2d6d1f90975192b9727d36bc4ad71f
+  data.tar.gz: 3d412e3b95814a3ac245d9ab46b0fa1dcfd4571b05903f363e5841b1108bb958
 SHA512:
-  metadata.gz: 5a4ff89a2d885624fe21c077137688593cd605791e8930c9cfe3926ed2f2b50607e4cd4cf992f5d1490e6ce430ab0d82606973a2504d3f12f9f4cf7d51e942c1
-  data.tar.gz: a90fa0d4e3d1f50e0a40a01b9da057061789226cb988c1a3fbb73c9e74c979fe70ce34ff03ec489de984883e798d29e87d8d58ccee3c398bb05bc24c7a9a4eaa
+  metadata.gz: c7503cd89d0f30a0517b6ce1022a6aaabf6d66737f16d38b7b1011fa342fab22e5cd3bd658516bf4e3faf784a06235ead91dd654a16f3b21d2df3f864bc00514
+  data.tar.gz: b5a3ec55cd38d404c8e6a458668927e3047c932ed8e7723b92fe8a701790ac61f2f81a3eef30e6e2ad457222290435e32856637b1aee8e9a4e141107834364a9

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,12 +1,18 @@
 # frozen_string_literal: true
 
-require 'http'
+require 'English'
 require 'base64'
+require 'digest'
 require 'faye/websocket'
-require 'openssl'
-require 'jwt'
+require 'http'
 require 'jose'
+require 'msgpack'
+require 'open3'
+require 'openssl'
+require 'rbnacl'
 require_relative './mixin_bot/api'
+require_relative './mixin_bot/cli'
+require_relative './mixin_bot/version'
 
 module MixinBot
   class<< self

data/lib/mixin_bot/api.rb

@@ -2,12 +2,14 @@
 
 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'
@@ -17,30 +19,66 @@ require_relative './api/withdraw'
 
 module MixinBot
   class API
-    attr_reader :client_id, :client_secret, :session_id, :pin_token, :private_key
-    attr_reader :client, :blaze_host
+    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
       @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(MixinBot.api_host)
+      @client = Client.new(MixinBot.api_host || 'api.mixin.one')
       @blaze_host = MixinBot.blaze_host || 'blaze.mixin.one'
+      @pin_token =
+        begin
+          Base64.urlsafe_decode64 options[:pin_token] || MixinBot.pin_token
+        rescue StandardError
+          ''
+        end
+      _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/auth.rb

@@ -3,7 +3,7 @@
 module MixinBot
   class API
     module Auth
-      def access_token(method, uri, body = '', exp_in = 600)
+      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
@@ -14,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)

data/lib/mixin_bot/api/blaze.rb

@@ -14,7 +14,7 @@ module MixinBot
         )
       end
 
-      def start_blaze_connect(reconnect = true, &_block)
+      def start_blaze_connect(reconnect: true, &_block)
         ws ||= blaze
         yield if block_given?
 
@@ -54,7 +54,7 @@ module MixinBot
           end
 
           ws = nil
-          start_blaze_connect { yield } if reconnect
+          start_blaze_connect(&_block) if reconnect
         end
       end
     end

data/lib/mixin_bot/api/conversation.rb

@@ -41,7 +41,7 @@ module MixinBot
         digest = md5.digest
         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]
+        cipher = digest[0...6] + digest6 + digest[7] + digest8 + digest[9..]
         hex = cipher.unpack1('H*')
 
         format(
@@ -50,7 +50,7 @@ module MixinBot
           second: hex[8..11],
           third: hex[12..15],
           forth: hex[16..19],
-          fifth: hex[20..-1]
+          fifth: hex[20..]
         )
       end
     end

data/lib/mixin_bot/api/me.rb

@@ -4,7 +4,7 @@ module MixinBot
   class API
     module Me
       # https://developers.mixin.one/api/beta-mixin-message/read-profile/
-      def read_me(access_token = nil)
+      def read_me(access_token: nil)
         path = '/me'
         access_token ||= access_token('GET', path, '')
         authorization = format('Bearer %<access_token>s', access_token: access_token)
@@ -26,7 +26,7 @@ module MixinBot
       end
 
       # https://developers.mixin.one/api/alpha-mixin-network/read-assets/
-      def read_assets(access_token = nil)
+      def read_assets(access_token: nil)
         path = '/assets'
         access_token ||= access_token('GET', path, '')
         authorization = format('Bearer %<access_token>s', access_token: access_token)
@@ -34,7 +34,7 @@ module MixinBot
       end
 
       # https://developers.mixin.one/api/alpha-mixin-network/read-asset/
-      def read_asset(asset_id, access_token = nil)
+      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)
@@ -42,7 +42,7 @@ module MixinBot
       end
 
       # https://developers.mixin.one/api/beta-mixin-message/friends/
-      def read_friends(access_token = nil)
+      def read_friends(access_token: nil)
         path = '/friends'
         access_token ||= access_token('GET', path, '')
         authorization = format('Bearer %<access_token>s', access_token: access_token)

data/lib/mixin_bot/api/message.rb

@@ -41,6 +41,22 @@ module MixinBot
         base_message_params(options)
       end
 
+      # {
+      #   "id": "UUID // generated by client",
+      #   "action":  "CREATE_MESSAGE",
+      #   "params": {
+      #     "conversation_id": "UUID",
+      #     "category": "PLAIN_POST",
+      #     "status": "SENT",
+      #     "message_id": "UUID // generated by client",
+      #     "data": "Base64 encoded data content is markdown" ,
+      #   }
+      # }
+      def plain_post(options)
+        options.merge!(category: 'PLAIN_POST')
+        base_message_params(options)
+      end
+
       # {
       #   "id": "UUID",
       #   "action": "CREATE_MESSAGE",
@@ -216,24 +232,16 @@ module MixinBot
       end
 
       # base format of message params
-      def base_message_params(
-        conversation_id:,
-        category:,
-        data:,
-        quote_message_id: nil,
-        message_id: nil,
-        recipient_id: nil,
-        representative_id: nil
-      )
-        data = data.is_a?(String) ? data : data.to_json
+      def base_message_params(options)
+        data = options[:data].is_a?(String) ? options[:data] : options[:data].to_json
         {
-          conversation_id: conversation_id,
-          recipient_id: recipient_id,
-          representative_id: representative_id,
-          category: category,
+          conversation_id: options[:conversation_id],
+          recipient_id: options[:recipient_id],
+          representative_id: options[:representative_id],
+          category: options[:category],
           status: 'SENT',
-          quote_message_id: quote_message_id,
-          message_id: message_id || SecureRandom.uuid,
+          quote_message_id: options[:quote_message_id],
+          message_id: options[:message_id] || SecureRandom.uuid,
           data: Base64.encode64(data)
         }
       end
@@ -249,7 +257,7 @@ module MixinBot
       end
 
       # gzip the message for websocket
-      def write_ws_message(action: 'CREATE_MESSAGE', params:)
+      def write_ws_message(params:, action: 'CREATE_MESSAGE')
         msg = {
           id: SecureRandom.uuid,
           action: action,
@@ -268,6 +276,10 @@ module MixinBot
         send_message plain_text(options)
       end
 
+      def send_post_message(options)
+        send_message plain_post(options)
+      end
+
       def send_contact_message(options)
         send_message plain_contact(options)
       end

data/lib/mixin_bot/api/multisig.rb

@@ -0,0 +1,335 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    module Multisig
+      # https://w3c.group/c/1574309272319630
+
+      # {"data":[
+      #   {
+      #     "type":"multisig_utxo",
+      #     "user_id":"514ae2ff-c24e-4379-a482-e2c0f798ebb1",
+      #     "utxo_id":"94711ac9-5981-4fe3-8c0e-19622219ea72",
+      #     "asset_id":"965e5c6e-434c-3fa9-b780-c50f43cd955c",
+      #     "transaction_hash":"2e67f3e36ee4b3c13effcc8a9aaafeb8122cad98f72d9ccc04d65a5ada2aa39d",
+      #     "output_index":0,
+      #     "amount":"0.123456",
+      #     "threshold":2,
+      #     "members":[
+      #       "514ae2ff-c24e-4379-a482-e2c0f798ebb1",
+      #       "13ce6c86-307a-5187-98b0-76424cbc0fbf",
+      #       "2b9df368-8e3e-46ce-ac57-e6111e8ff50e",
+      #       "3cb87491-4fa0-4c2f-b387-262b63cbc412"
+      #     ],
+      #     "memo":"难道你是女生",
+      #     "state":"unspent",
+      #     "created_at":"2019-11-03T13:30:43.922655Z",
+      #     "signed_by":"",
+      #     "signed_tx":""
+      #   }
+      # ]}
+      def multisigs(limit: 100, offset: nil, access_token: nil)
+        path = format('/multisigs?limit=%<limit>s&offset=%<offset>s', limit: limit, offset: offset)
+        access_token ||= access_token('GET', path, '')
+        authorization = format('Bearer %<access_token>s', access_token: access_token)
+        client.get(path, headers: { 'Authorization': authorization })
+      end
+
+      def all_multisigs(utxos: [], offset: nil, access_token: nil)
+        res = multisigs(limit: 100, offset: offset, access_token: access_token)
+
+        return [] if res['data'].nil?
+
+        utxos += res['data']
+
+        if res['data'].length < 100
+          utxos
+        else
+          all_multisigs(utxos: utxos, offset: utxos[-1]['created_at'], access_token: access_token)
+        end
+      end
+
+      def create_output(receivers:, index:, access_token: nil)
+        path = '/outputs'
+        payload = {
+          receivers: receivers,
+          index: index
+        }
+        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
+
+      # transfer from the multisig address
+      # create a request for multi sign
+      # for now, raw(RAW-TRANSACTION-HEX) can only be generated by Mixin SDK of Golang or Javascript
+      def create_sign_multisig_request(raw, access_token: nil)
+        path = '/multisigs'
+        payload = {
+          action: 'sign',
+          raw: 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)
+      end
+
+      # transfer from the multisig address
+      # create a request for unlock a multi-sign
+      def create_unlock_multisig_request(raw, access_token: nil)
+        path = '/multisigs'
+        payload = {
+          action: 'unlock',
+          raw: 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)
+      end
+
+      def sign_multisig_request(request_id, pin)
+        path = format('/multisigs/%<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)
+      end
+
+      def unlock_multisig_request(request_id, pin)
+        path = format('/multisigs/%<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_multisig_request(request_id, pin)
+        path = format('/multisigs/%<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)
+      end
+
+      # pay to the multisig address
+      # used for create multisig payment code_id
+      def create_multisig_payment(params)
+        path = '/payments'
+        payload = {
+          asset_id: params[:asset_id],
+          amount: params[:amount].to_s,
+          trace_id: params[:trace_id] || SecureRandom.uuid,
+          memo: params[:memo],
+          opponent_multisig: {
+            receivers: params[:receivers],
+            threshold: params[:threshold]
+          }
+        }
+        access_token = params[: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 verify_multisig(code_id, access_token: nil)
+        path = format('/codes/%<code_id>s', code_id: code_id)
+        access_token ||= access_token('GET', path, '')
+        authorization = format('Bearer %<access_token>s', access_token: access_token)
+        client.get(path, headers: { 'Authorization': authorization })
+      end
+
+      # send a signed transaction to main net
+      def send_raw_transaction(raw, access_token: nil)
+        path = '/external/proxy'
+        payload = {
+          method: 'sendrawtransaction',
+          params: [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)
+      end
+
+      def build_threshold_script(threshold)
+        s = threshold.to_s(16)
+        s = s.length == 1 ? "0#{s}" : s
+        raise 'NVALID THRESHOLD' if s.length > 2
+
+        "fffe#{s}"
+      end
+
+      # filter utxo by members, asset_id and threshold
+      def filter_utxos(params)
+        utxos = all_multisigs(access_token: params[:access_token])
+
+        unless params[:members].nil?
+          utxos = utxos.filter(
+            &lambda { |utxo|
+              utxo['members'].sort == params[:members].sort
+            }
+          )
+        end
+
+        unless params[:asset_id].nil?
+          utxos = utxos.filter(
+            &lambda { |utxo|
+              utxo['asset_id'] == params[:asset_id]
+            }
+          )
+        end
+
+        unless params[:threshold].nil?
+          utxos = utxos.filter(
+            &lambda { |utxo|
+              utxo['threshold'] == params[:threshold]
+            }
+          )
+        end
+
+        unless params[:state].nil?
+          utxos = utxos.filter(
+            &lambda { |utxo|
+              utxo['state'] == params[:state]
+            }
+          )
+        end
+
+        utxos
+      end
+
+      # params:
+      # {
+      #   senders: [ uuid ],
+      #   receivers: [ uuid ],
+      #   threshold: integer,
+      #   asset_id: uuid,
+      #   asset_mixin_id: string,
+      #   amount: string / float,
+      #   memo: string,
+      # }
+      def build_raw_transaction(params)
+        senders        = params[:senders]
+        receivers      = params[:receivers]
+        asset_id       = params[:asset_id]
+        asset_mixin_id = params[:asset_mixin_id]
+        amount         = params[:amount]
+        memo           = params[:memo]
+        threshold      = params[:threshold]
+        access_token   = params[:access_token]
+        utxos          = params[:utxos]
+
+        raise 'access_token required!' if access_token.nil? && !senders.include?(client_id)
+
+        # default to use all unspent utxo
+        utxos ||= filter_utxos(
+          members: senders,
+          asset_id: asset_id,
+          threshold: threshold,
+          state: 'unspent',
+          access_token: access_token
+        )
+        amount = amount.to_f.round(8)
+        input_amount = utxos.map(
+          &lambda { |utxo|
+            utxo['amount'].to_f
+          }
+        ).sum.round(8)
+
+        if input_amount < amount
+          raise format(
+            'not enough amount! %<input_amount>s < %<amount>s',
+            input_amount: input_amount,
+            amount: amount
+          )
+        end
+
+        inputs = utxos.map(
+          &lambda { |utx|
+            {
+              'hash' => utx['transaction_hash'],
+              'index' => utx['output_index']
+            }
+          }
+        )
+
+        outputs = []
+        output0 = create_output(receivers: receivers, index: 0)['data']
+        output0['amount'] = format('%<amount>.8f', amount: amount)
+        output0['script'] = build_threshold_script(receivers.length)
+        outputs << output0
+
+        if input_amount > amount
+          output1 = create_output(receivers: senders, index: 1)['data']
+          output1['amount'] = format('%<amount>.8f', amount: input_amount - amount)
+          output1['script'] = build_threshold_script(utxos[0]['threshold'].to_i)
+          outputs << output1
+        end
+
+        extra = Digest.hexencode memo.to_s.slice(0, 140)
+        tx = {
+          version: 1,
+          asset: asset_mixin_id,
+          inputs: inputs,
+          outputs: outputs,
+          extra: extra
+        }
+
+        build_transaction tx.to_json
+      end
+
+      def str_to_bin(str)
+        return if str.nil?
+
+        str.scan(/../).map(&:hex).pack('c*')
+      end
+
+      def build_inputs(inputs)
+        res = []
+        prototype = {
+          'Hash' => nil,
+          'Index' => nil,
+          'Genesis' => nil,
+          'Deposit' => nil,
+          'Mint' => nil
+        }
+        inputs.each do |input|
+          struc = prototype.dup
+          struc['Hash'] = str_to_bin input['hash']
+          struc['Index'] = input['index']
+          res << struc
+        end
+
+        res
+      end
+
+      def build_outputs(outputs)
+        res = []
+        prototype = {
+          'Type' => 0,
+          'Amount' => nil,
+          'Keys' => nil,
+          'Script' => nil,
+          'Mask' => nil
+        }
+        outputs.each do |output|
+          struc = prototype.dup
+          struc['Type'] = str_to_bin output['type']
+          struc['Amount'] = str_to_bin output['amount']
+          struc['Keys'] = output['keys'].map(&->(key) { str_to_bin(key) })
+          struc['Script'] = str_to_bin output['script']
+          struc['Mask'] = str_to_bin output['mask']
+          res << struc
+        end
+
+        res
+      end
+    end
+  end
+end