mixin_bot 0.12.1 → 1.0.0

data/lib/mixin_bot/api/encrypted_message.rb

@@ -90,11 +90,11 @@ module MixinBot
           category: options[:category],
           quote_message_id: options[:quote_message_id],
           message_id: options[:message_id] || SecureRandom.uuid,
-          data_base64: data_base64,
-          checksum: checksum,
+          data_base64:,
+          checksum:,
           recipient_sessions: session_ids.map(&->(s) { { session_id: s } }),
           silent: false
-        }
+        }.compact
       end
 
       def send_encrypted_messages(messages)
@@ -104,19 +104,19 @@ module MixinBot
       # http post request
       def send_encrypted_message(payload)
         path = '/encrypted_messages'
-        payload = [payload] unless payload.is_a?(Array)
-        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)
+        payload = [payload] if payload.is_a? Hash
+        raise ArgumentError, 'Wrong payload format!' unless payload.is_a? Array
+
+        client.post path, *payload
       end
 
       def encrypt_message(data, sessions = [], sk: nil, pk: nil)
         raise ArgumentError, 'Wrong sessions format!' unless sessions.all?(&->(s) { s.key?('session_id') && s.key?('public_key') })
 
-        sk = private_key[0...32]
-        pk ||= private_key[32...]
+        sk ||= config.session_private_key[0...32]
+        pk ||= config.session_private_key[32...]
 
-        checksum = Digest::MD5.hexdigest sessions.map(&->(s) { s['session_id'] }).sort.join
+        Digest::MD5.hexdigest sessions.map(&->(s) { s['session_id'] }).sort.join
         encrypter = OpenSSL::Cipher.new('AES-128-GCM').encrypt
         key = encrypter.random_key
         nounce = encrypter.random_iv
@@ -128,14 +128,14 @@ module MixinBot
         bytes = [1]
         bytes += [sessions.size].pack('v*').bytes
         bytes += JOSE::JWA::Ed25519.pk_to_curve25519(pk).bytes
-        
+
         sessions.each do |session|
           aes_key = JOSE::JWA::X25519.shared_secret(
             Base64.urlsafe_decode64(session['public_key']),
             JOSE::JWA::Ed25519.secret_to_curve25519(sk)
           )
 
-          padding = 16 - key.size % 16
+          padding = 16 - (key.size % 16)
           padtext = ([padding] * padding).pack('C*')
 
           encrypter = OpenSSL::Cipher.new('AES-256-CBC').encrypt
@@ -143,7 +143,7 @@ module MixinBot
           iv = encrypter.random_iv
           encrypter.iv = iv
 
-          bytes += (MixinBot::Utils::UUID.new(hex: session['session_id']).packed + iv).bytes
+          bytes += (MixinBot::UUID.new(hex: session['session_id']).packed + iv).bytes
           bytes += encrypter.update(key + padtext).bytes
         end
 
@@ -156,19 +156,19 @@ module MixinBot
       def decrypt_message(data, sk: nil, si: nil)
         bytes = Base64.urlsafe_decode64(data).bytes
 
-        si ||= session_id
-        sk ||= private_key[0...32]
+        si ||= config.session_id
+        sk ||= config.session_private_key[0...32]
 
         size = 16 + 48
         return '' if bytes.size < 1 + 2 + 32 + size + 12
 
         session_length = bytes[1...3].pack('v*').unpack1('C*')
-        prefix_size = 35 + session_length * size
+        prefix_size = 35 + (session_length * size)
 
         i = 35
         key = ''
         while i < prefix_size
-          uuid = MixinBot::Utils::UUID.new(raw: bytes[i...(i + 16)].pack('C*')).unpacked
+          uuid = MixinBot::UUID.new(raw: bytes[i...(i + 16)].pack('C*')).unpacked
           if uuid == si
             pub = bytes[3...35]
             aes_key = JOSE::JWA::X25519.shared_secret(

data/lib/mixin_bot/api/legacy_multisig.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    module LegacyMultisig
+      MULTISIG_REQUEST_ACTIONS = %i[sign unlock].freeze
+      def create_multisig_request(action, raw, access_token: nil)
+        raise ArgumentError, "request action is limited in #{MULTISIG_REQUEST_ACTIONS.join(', ')}" unless MULTISIG_REQUEST_ACTIONS.include? action.to_sym
+
+        path = '/multisigs/requests'
+        payload = {
+          action:,
+          raw:
+        }
+        client.post path, **payload, access_token:
+      end
+
+      # transfer from the multisig address
+      def create_sign_multisig_request(raw, access_token: nil)
+        create_multisig_request 'sign', raw, access_token:
+      end
+
+      # transfer from the multisig address
+      # create a request for unlock a multi-sign
+      def create_unlock_multisig_request(raw, access_token: nil)
+        create_multisig_request 'unlock', raw, access_token:
+      end
+
+      def sign_multisig_request(request_id, pin = nil)
+        pin ||= config.pin
+        path = format('/multisigs/requests/%<request_id>s/sign', request_id:)
+        payload =
+          if pin.length > 6
+            {
+              pin_base64: encrypt_tip_pin(pin, 'TIP:MULTISIG:REQUEST:SIGN:', request_id)
+            }
+          else
+            {
+              pin: encrypt_pin(pin)
+            }
+          end
+
+        client.post path, **payload, access_token:
+      end
+
+      def unlock_multisig_request(request_id, pin = nil)
+        pin ||= config.pin
+
+        path = format('/multisigs/requests/%<request_id>s/unlock', request_id:)
+        payload =
+          if pin.length > 6
+            {
+              pin_base64: encrypt_tip_pin(pin, 'TIP:MULTISIG:REQUEST:UNLOCK:', request_id)
+            }
+          else
+            {
+              pin: encrypt_pin(pin)
+            }
+          end
+
+        client.post path, **payload
+      end
+
+      # pay to the multisig address
+      # used for create multisig payment code_id
+      def create_multisig_payment(**kwargs)
+        path = '/payments'
+        payload = {
+          asset_id: kwargs[:asset_id],
+          amount: format('%.8f', kwargs[:amount].to_d),
+          trace_id: kwargs[:trace_id] || SecureRandom.uuid,
+          memo: kwargs[:memo],
+          opponent_multisig: {
+            receivers: kwargs[:receivers],
+            threshold: kwargs[:threshold]
+          }
+        }
+        client.post path, **payload, access_token: kwargs[:access_token]
+      end
+
+      def verify_multisig(code_id, access_token: nil)
+        path = format('/codes/%<code_id>s', code_id:)
+        client.get path, access_token:
+      end
+    end
+  end
+end

data/lib/mixin_bot/api/legacy_output.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    module LegacyOutput
+      def outputs(**kwargs)
+        limit = kwargs[:limit] || 100
+        offset = kwargs[:offset] || ''
+        state = kwargs[:state] || ''
+        members = kwargs[:members] || []
+        threshold = kwargs[:threshold] || ''
+        access_token = kwargs[:access_token]
+        members = SHA3::Digest::SHA256.hexdigest(members&.sort&.join)
+
+        path = '/multisigs/outputs'
+        params = {
+          limit:,
+          offset:,
+          state:,
+          members:,
+          threshold:
+        }.compact_blank
+
+        client.get path, **params, access_token:
+      end
+      alias multisigs outputs
+      alias multisig_outputs outputs
+
+      def create_output(receivers:, index:, hint: nil, access_token: nil)
+        path = '/outputs'
+        payload = {
+          receivers:,
+          index:,
+          hint:
+        }
+        client.post path, **payload, access_token:
+      end
+
+      def build_output(receivers:, index:, amount:, threshold:, hint: nil)
+        _output = create_output(receivers:, index:, hint:)
+        {
+          amount: format('%.8f', amount.to_d.to_r),
+          script: build_threshold_script(threshold),
+          mask: _output['mask'],
+          keys: _output['keys']
+        }
+      end
+    end
+  end
+end

data/lib/mixin_bot/api/legacy_payment.rb

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

data/lib/mixin_bot/api/legacy_snapshot.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    module LegacySnapshot
+      def network_snapshots(**kwargs)
+        path = '/network/snapshots'
+        params = {
+          limit: kwargs[:limit],
+          offset: kwargs[:offset],
+          asset: kwargs[:asset],
+          order: kwargs[:order]
+        }
+
+        client.get path, **params, access_token: kwargs[:access_token]
+      end
+
+      def snapshots(**kwargs)
+        path = '/snapshots'
+
+        params = {
+          limit: kwargs[:limit],
+          offset: kwargs[:offset],
+          asset: kwargs[:asset],
+          opponent: kwargs[:opponent],
+          order: kwargs[:order]
+        }
+
+        client.get path, **params, access_token: kwargs[:access_token]
+      end
+
+      def network_snapshot(snapshot_id, **kwargs)
+        path = format('/network/snapshots/%<snapshot_id>s', snapshot_id:)
+
+        client.get path, access_token: kwargs[:access_token]
+      end
+    end
+  end
+end

data/lib/mixin_bot/api/legacy_transaction.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    module LegacyTransaction
+      LEGACY_TX_VERSION = 0x04
+
+      # use safe transaction protocol instead
+      # kwargs:
+      # {
+      #   senders: [ uuid ],
+      #   senders_threshold: integer,
+      #   receivers: [ uuid ],
+      #   receivers_threshold: integer,
+      #   asset_id: uuid,
+      #   amount: string / float,
+      #   memo: string,
+      # }
+      RAW_TRANSACTION_ARGUMENTS = %i[utxos senders senders_threshold receivers receivers_threshold amount].freeze
+      def build_raw_transaction(**kwargs)
+        raise ArgumentError, "#{RAW_TRANSACTION_ARGUMENTS.join(', ')} are needed for build raw transaction" unless RAW_TRANSACTION_ARGUMENTS.all? { |param| kwargs.keys.include? param }
+
+        senders             = kwargs[:senders]
+        senders_threshold   = kwargs[:senders_threshold]
+        receivers           = kwargs[:receivers]
+        receivers_threshold = kwargs[:receivers_threshold]
+        amount              = kwargs[:amount]
+        asset_id            = kwargs[:asset_id]
+        asset_mixin_id      = kwargs[:asset_mixin_id]
+        utxos               = kwargs[:utxos]
+        extra               = kwargs[:extra]
+        access_token        = kwargs[:access_token]
+        outputs             = kwargs[:outputs] || []
+        hint                = kwargs[:hint]
+        version             = kwargs[:version] || LEGACY_TX_VERSION
+
+        raise 'access_token required!' if access_token.nil? && !senders.include?(config.app_id)
+
+        amount = amount.to_d.round(8)
+        input_amount = utxos.map(
+          &lambda { |utxo|
+            utxo['amount'].to_d
+          }
+        ).sum
+
+        if input_amount < amount
+          raise format(
+            'not enough amount! %<input_amount>s < %<amount>s',
+            input_amount:,
+            amount:
+          )
+        end
+
+        inputs = utxos.map(
+          &lambda { |utx|
+            {
+              'hash' => utx['transaction_hash'],
+              'index' => utx['output_index']
+            }
+          }
+        )
+
+        if outputs.empty?
+          receivers_threshold = 1 if receivers.size == 1
+          output0 = build_output(
+            receivers:,
+            index: 0,
+            amount:,
+            threshold: receivers_threshold,
+            hint:
+          )
+          outputs.push output0
+
+          if input_amount > amount
+            output1 = build_output(
+              receivers: senders,
+              index: 1,
+              amount: input_amount - amount,
+              threshold: senders_threshold,
+              hint:
+            )
+            outputs.push output1
+          end
+        end
+
+        asset = asset_mixin_id || SHA3::Digest::SHA256.hexdigest(asset_id)
+        {
+          version:,
+          asset:,
+          inputs:,
+          outputs:,
+          extra:
+        }
+      end
+
+      # use safe transaction protocol instead
+      MULTISIG_TRANSACTION_ARGUMENTS = %i[asset_id receivers threshold amount].freeze
+      def create_multisig_transaction(pin, **options)
+        raise ArgumentError, "#{MULTISIG_TRANSACTION_ARGUMENTS.join(', ')} are needed for create multisig transaction" unless MULTISIG_TRANSACTION_ARGUMENTS.all? { |param| options.keys.include? param }
+
+        asset_id = options[:asset_id]
+        receivers = options[:receivers].sort
+        threshold = options[:threshold]
+        amount = format('%.8f', options[:amount].to_d.to_r)
+        memo = options[:memo]
+        trace_id = options[:trace_id] || SecureRandom.uuid
+
+        path = '/transactions'
+        payload = {
+          asset_id:,
+          opponent_multisig: {
+            receivers:,
+            threshold:
+          },
+          amount:,
+          trace_id:,
+          memo:
+        }
+
+        if pin.length > 6
+          payload[:pin_base64] = encrypt_tip_pin(pin, 'TIP:TRANSACTION:CREATE:', asset_id, receivers.join, threshold, amount, trace_id, memo)
+        else
+          payload[:pin] = encrypt_pin(pin)
+        end
+
+        client.post path, **payload
+      end
+
+      # use safe transaction protocol instead
+      MAINNET_TRANSACTION_ARGUMENTS = %i[asset_id opponent_id amount].freeze
+      def create_mainnet_transaction(pin, **options)
+        raise ArgumentError, "#{MAINNET_TRANSACTION_ARGUMENTS.join(', ')} are needed for create main net transactions" unless MAINNET_TRANSACTION_ARGUMENTS.all? { |param| options.keys.include? param }
+
+        asset_id = options[:asset_id]
+        opponent_id = options[:opponent_id]
+        amount = format('%.8f', options[:amount].to_d)
+        memo = options[:memo]
+        trace_id = options[:trace_id] || SecureRandom.uuid
+
+        path = '/transactions'
+        payload = {
+          asset_id:,
+          opponent_id:,
+          amount:,
+          trace_id:,
+          memo:
+        }
+
+        if pin.length > 6
+          payload[:pin_base64] = encrypt_tip_pin(pin, 'TIP:TRANSACTION:CREATE:', asset_id, opponent_id, amount, trace_id, memo)
+        else
+          payload[:pin] = encrypt_pin(pin)
+        end
+
+        client.post path, **payload
+      end
+
+      # use safe transaction protocol instead
+      def transactions(**options)
+        path = '/external/transactions'
+        params = {
+          limit: options[:limit],
+          offset: options[:offset],
+          asset: options[:asset],
+          destination: options[:destination],
+          tag: options[:tag]
+        }
+
+        client.get path, **params
+      end
+    end
+  end
+end

data/lib/mixin_bot/api/legacy_transfer.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    module LegacyTransfer
+      TRANSFER_ARGUMENTS = %i[asset_id opponent_id amount].freeze
+      def create_transfer(pin, **kwargs)
+        raise ArgumentError, "#{TRANSFER_ARGUMENTS.join(', ')} are needed for create transfer" unless TRANSFER_ARGUMENTS.all? { |param| kwargs.keys.include? param }
+
+        asset_id = kwargs[:asset_id]
+        opponent_id = kwargs[:opponent_id]
+        amount = format('%.8f', kwargs[:amount].to_d.to_r).gsub(/\.?0+$/, '')
+        trace_id = kwargs[:trace_id] || SecureRandom.uuid
+        memo = kwargs[:memo] || ''
+
+        payload = {
+          asset_id:,
+          opponent_id:,
+          amount:,
+          trace_id:,
+          memo:
+        }
+
+        if pin.length > 6
+          pin_base64 = encrypt_tip_pin pin, 'TIP:TRANSFER:CREATE:', asset_id, opponent_id, amount, trace_id, memo
+          payload[:pin_base64] = pin_base64
+        else
+          encrypted_pin = encrypt_pin pin
+          payload[:pin] = encrypted_pin
+        end
+
+        path = '/transfers'
+        client.post path, **payload
+      end
+
+      def transfer(trace_id, access_token: nil)
+        path = format('/transfers/trace/%<trace_id>s', trace_id:)
+        client.get path, access_token:
+      end
+    end
+  end
+end

data/lib/mixin_bot/api/me.rb

@@ -3,37 +3,33 @@
 module MixinBot
   class API
     module Me
-      # https://developers.mixin.one/api/beta-mixin-message/read-profile/
       def me(access_token: nil)
         path = '/me'
-        access_token ||= access_token('GET', path, '')
-        authorization = format('Bearer %<access_token>s', access_token: access_token)
-        client.get(path, headers: { 'Authorization': authorization })
+        client.get path, access_token:
       end
-      alias read_me me
 
-      # 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)
+      #   String: Base64 of image, supports format png, jpeg and gif, base64 image size > 1024.
+      def update_me(**kwargs)
         path = '/me'
         payload = {
-          full_name: full_name,
-          avatar_base64: avatar_base64
+          full_name: kwargs[:full_name],
+          avatar_base64: kwargs[:avatar_base64],
+          access_token: kwargs[:access_token]
         }
-        access_token ||= access_token('POST', path, payload.to_json)
-        authorization = format('Bearer %<access_token>s', access_token: access_token)
-        client.post(path, headers: { 'Authorization': authorization }, json: payload)
+        client.post path, **payload
       end
 
       # https://developers.mixin.one/api/beta-mixin-message/friends/
       def friends(access_token: nil)
         path = '/friends'
-        access_token ||= access_token('GET', path, '')
-        authorization = format('Bearer %<access_token>s', access_token: access_token)
-        client.get(path, headers: { 'Authorization': authorization })
+        client.get path, access_token:
+      end
+
+      def safe_me(access_token: nil)
+        path = '/safe/me'
+        client.get path, access_token:
       end
-      alias read_friends friends
     end
   end
 end

data/lib/mixin_bot/api/message.rb

@@ -10,10 +10,10 @@ module MixinBot
 
       def acknowledge_message_receipt(message_id)
         params = {
-          message_id: message_id,
+          message_id:,
           status: 'READ'
         }
-        write_ws_message(action: 'ACKNOWLEDGE_MESSAGE_RECEIPT', params: params)
+        write_ws_message(action: 'ACKNOWLEDGE_MESSAGE_RECEIPT', params:)
       end
 
       def plain_text(options)
@@ -72,7 +72,7 @@ module MixinBot
         options.merge!(
           category: 'MESSAGE_RECALL',
           data: {
-            message_id: message_id
+            message_id:
           }
         )
         base_message_params(options)
@@ -90,11 +90,11 @@ module MixinBot
           quote_message_id: options[:quote_message_id],
           message_id: options[:message_id] || SecureRandom.uuid,
           data: Base64.encode64(data)
-        }
+        }.compact
       end
 
       # read the gzipped message form websocket
-      def read_ws_message(data)
+      def ws_message(data)
         io = StringIO.new(data.pack('c*'), 'rb')
         gzip = Zlib::GzipReader.new io
         msg = gzip.read
@@ -107,8 +107,8 @@ module MixinBot
       def write_ws_message(params:, action: 'CREATE_MESSAGE')
         msg = {
           id: SecureRandom.uuid,
-          action: action,
-          params: params
+          action:,
+          params:
         }.to_json
 
         io = StringIO.new 'wb'
@@ -158,9 +158,12 @@ module MixinBot
       # 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)
+
+        if payload.is_a? Hash
+          client.post path, **payload
+        elsif payload.is_a? Array
+          client.post path, *payload
+        end
       end
     end
   end