mixin_bot 0.0.1.4 → 0.3.0

data/lib/mixin_bot/api/message.rb

@@ -1,69 +1,266 @@
+# 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 // 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
 
-        write_message('CREATE_MESSAGE', params)
+      # {
+      #   "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
 
-      def app_card_message
-        # TODO:
+      # {
+      #   "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_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_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
 
-        data = [{ label: label, color: color, action: action }]
-        encoded_data = Base64.encode64 data.to_json
+      # {
+      #   "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
 
-        params = {
-          conversation_id: conversation_id,
-          recipient_id: recipient_id,
-          category: 'APP_BUTTON_GROUP',
+      # {
+      #   "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
+
+      # {
+      #   "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
+
+      def recall_message_params(message_id, options)
+        raise 'recipient_id is required!' if options[:recipient_id].nil?
+
+        options.merge!(
+          category: 'MESSAGE_RECALL',
+          data: {
+            message_id: message_id
+          }
+        )
+        base_message_params(options)
+      end
+
+      # base format of message params
+      def base_message_params(options)
+        data = options[:data].is_a?(String) ? options[:data] : options[:data].to_json
+        {
+          conversation_id: options[:conversation_id],
+          recipient_id: options[:recipient_id],
+          representative_id: options[:representative_id],
+          category: options[:category],
           status: 'SENT',
-          message_id: SecureRandom.uuid,
-          data: encoded_data
+          quote_message_id: options[:quote_message_id],
+          message_id: options[: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(params:, action: 'CREATE_MESSAGE')
         msg = {
           id: SecureRandom.uuid,
-          action:  action,
+          action: action,
           params: params
         }.to_json
 
@@ -71,7 +268,62 @@ 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_post_message(options)
+        send_message plain_post(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
+
+      def recall_message(message_id, options)
+        send_message [recall_message_params(message_id, 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."
+      #       },
+      #       ...
+      #     ]
+      #   }
+      # }
+      def send_plain_messages(messages)
+        send_message 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/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