mixin_bot 1.4.0 → 2.0.0

data/lib/mixin_bot/api/legacy_collectible.rb

@@ -6,24 +6,27 @@ module MixinBot
       NFT_ASSET_MIXIN_ID = '1700941284a95f31b25ec8c546008f208f88eee4419ccdcdbe6e3195e60128ca'
 
       def legacy_collectible(id, access_token: nil)
+        warn_legacy_mixin_api!('LegacyCollectible#legacy_collectible')
         path = "/collectibles/tokens/#{id}"
         client.get path, access_token:
       end
 
       def legacy_collection(id, access_token: nil)
+        warn_legacy_mixin_api!('LegacyCollectible#legacy_collection')
         path = "/collectibles/collections/#{id}"
         client.get path, access_token:
       end
 
       def legacy_collectibles(**kwargs)
+        warn_legacy_mixin_api!('LegacyCollectible#legacy_collectibles')
         limit = kwargs[:limit] || 100
         offset = kwargs[:offset] || ''
         state = kwargs[:state] || ''
 
-        members = kwargs[:members] || [config.app_id]
-        threshold = kwargs[:threshold] || members.length
+        member_ids = kwargs[:members] || [config.app_id]
+        threshold = kwargs[:threshold] || member_ids.length
 
-        members = SHA3::Digest::SHA256.hexdigest(members&.sort&.join)
+        members_hash = MixinBot.utils.hash_members(member_ids)
 
         access_token = kwargs[:access_token]
 
@@ -32,7 +35,7 @@ module MixinBot
           limit:,
           offset:,
           state:,
-          members:,
+          members: members_hash,
           threshold:
         }
 
@@ -41,7 +44,11 @@ module MixinBot
 
       COLLECTABLE_REQUEST_ACTIONS = %i[sign unlock].freeze
       def create_collectible_request(action, raw, access_token: nil)
-        raise ArgumentError, "request action is limited in #{COLLECTABLE_REQUEST_ACTIONS.join(', ')}" unless COLLECTABLE_REQUEST_ACTIONS.include? action.to_sym
+        warn_legacy_mixin_api!('LegacyCollectible#create_collectible_request')
+        unless COLLECTABLE_REQUEST_ACTIONS.include? action.to_sym
+          raise ArgumentError,
+                "request action is limited in #{COLLECTABLE_REQUEST_ACTIONS.join(', ')}"
+        end
 
         path = '/collectibles/requests'
         payload = {
@@ -52,47 +59,33 @@ module MixinBot
       end
 
       def create_sign_collectible_request(raw, access_token: nil)
+        warn_legacy_mixin_api!('LegacyCollectible#create_sign_collectible_request')
         create_collectible_request 'sign', raw, access_token:
       end
 
       def create_unlock_collectible_request(raw, access_token: nil)
+        warn_legacy_mixin_api!('LegacyCollectible#create_unlock_collectible_request')
         create_collectible_request 'unlock', raw, access_token:
       end
 
       def sign_collectible_request(request_id, pin = nil)
+        warn_legacy_mixin_api!('LegacyCollectible#sign_collectible_request')
         pin ||= config.pin
         raise ArgumentError, 'pin is needed for sign collectible request' if pin.blank?
 
         path = format('/collectibles/requests/%<request_id>s/sign', request_id:)
-        payload =
-          if pin.length > 6
-            pin_base64 =  encrypt_tip_pin(pin, 'TIP:COLLECTIBLE:REQUEST:SIGN:', request_id)
-            {
-              pin_base64:
-            }
-          else
-            {
-              pin: encrypt_pin(pin)
-            }
-          end
+        payload = tip_or_legacy_pin_payload(pin, 'TIP:COLLECTIBLE:REQUEST:SIGN:', request_id)
+
         client.post path, **payload
       end
 
       def unlock_collectible_request(request_id, pin = nil)
+        warn_legacy_mixin_api!('LegacyCollectible#unlock_collectible_request')
         pin ||= config.pin
         raise ArgumentError, 'pin is needed for sign collectible request' if pin.blank?
 
         path = format('/collectibles/requests/%<request_id>s/unlock', request_id:)
-        payload =
-          if pin.length > 6
-            {
-              pin_base64: encrypt_tip_pin(pin, 'TIP:COLLECTIBLE:REQUEST:UNLOCK:', request_id)
-            }
-          else
-            {
-              pin: encrypt_pin(pin)
-            }
-          end
+        payload = tip_or_legacy_pin_payload(pin, 'TIP:COLLECTIBLE:REQUEST:UNLOCK:', request_id)
 
         client.post path, **payload
       end
@@ -114,7 +107,13 @@ module MixinBot
     # }
     COLLECTIBLE_TRANSACTION_ARGUMENTS = %i[collectible nfo receivers receivers_threshold].freeze
     def build_collectible_transaction(**kwargs)
-      raise ArgumentError, "#{COLLECTIBLE_TRANSACTION_ARGUMENTS.join(', ')} are needed for build collectible transaction" unless COLLECTIBLE_TRANSACTION_ARGUMENTS.all? { |param| kwargs.keys.include? param }
+      warn_legacy_mixin_api!('LegacyCollectible#build_collectible_transaction')
+      unless COLLECTIBLE_TRANSACTION_ARGUMENTS.all? do |param|
+               kwargs.keys.include? param
+             end
+        raise ArgumentError,
+              "#{COLLECTIBLE_TRANSACTION_ARGUMENTS.join(', ')} are needed for build collectible transaction"
+      end
 
       kwargs = kwargs.with_indifferent_access
       collectible = kwargs['collectible']

data/lib/mixin_bot/api/legacy_multisig.rb

@@ -5,7 +5,11 @@ module MixinBot
     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
+        warn_legacy_mixin_api!('LegacyMultisig#create_multisig_request')
+        unless MULTISIG_REQUEST_ACTIONS.include? action.to_sym
+          raise ArgumentError,
+                "request action is limited in #{MULTISIG_REQUEST_ACTIONS.join(', ')}"
+        end
 
         path = '/multisigs/requests'
         payload = {
@@ -17,46 +21,39 @@ module MixinBot
 
       # transfer from the multisig address
       def create_sign_multisig_request(raw, access_token: nil)
+        warn_legacy_mixin_api!('LegacyMultisig#create_sign_multisig_request')
         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)
+        warn_legacy_mixin_api!('LegacyMultisig#create_unlock_multisig_request')
         create_multisig_request 'unlock', raw, access_token:
       end
 
       def sign_multisig_request(request_id, pin = nil)
+        warn_legacy_mixin_api!('LegacyMultisig#sign_multisig_request')
         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
+        payload = tip_or_legacy_pin_payload(pin, 'TIP:MULTISIG:REQUEST:SIGN:', request_id)
 
         client.post path, **payload
       end
 
+      def cancel_multisig_request(request_id, access_token: nil)
+        warn_legacy_mixin_api!('LegacyMultisig#cancel_multisig_request')
+        path = format('/multisigs/requests/%<request_id>s/cancel', request_id:)
+        client.post path, access_token:
+      end
+      alias cancel_multisig cancel_multisig_request
+
       def unlock_multisig_request(request_id, pin = nil)
+        warn_legacy_mixin_api!('LegacyMultisig#unlock_multisig_request')
         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
+        payload = tip_or_legacy_pin_payload(pin, 'TIP:MULTISIG:REQUEST:UNLOCK:', request_id)
 
         client.post path, **payload
       end
@@ -64,6 +61,7 @@ module MixinBot
       # pay to the multisig address
       # used for create multisig payment code_id
       def create_multisig_payment(**kwargs)
+        warn_legacy_mixin_api!('LegacyMultisig#create_multisig_payment')
         path = '/payments'
         payload = {
           asset_id: kwargs[:asset_id],
@@ -79,6 +77,7 @@ module MixinBot
       end
 
       def verify_multisig(code_id, access_token: nil)
+        warn_legacy_mixin_api!('LegacyMultisig#verify_multisig')
         path = format('/codes/%<code_id>s', code_id:)
         client.get path, access_token:
       end

data/lib/mixin_bot/api/legacy_output.rb

@@ -3,21 +3,26 @@
 module MixinBot
   class API
     module LegacyOutput
+      def read_multisigs(**)
+        warn_legacy_mixin_api!('LegacyOutput#read_multisigs')
+        legacy_outputs(**)
+      end
+
       def legacy_outputs(**kwargs)
+        warn_legacy_mixin_api!('LegacyOutput#legacy_outputs')
         limit = kwargs[:limit] || 100
         offset = kwargs[:offset] || ''
         state = kwargs[:state] || ''
-        members = kwargs[:members] || []
+        members_hash = MixinBot.utils.hash_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:,
+          members: members_hash,
           threshold:
         }.compact_blank
 
@@ -27,6 +32,7 @@ module MixinBot
       alias multisig_outputs legacy_outputs
 
       def create_output(receivers:, index:, hint: nil, access_token: nil)
+        warn_legacy_mixin_api!('LegacyOutput#create_output')
         path = '/outputs'
         payload = {
           receivers:,
@@ -37,6 +43,7 @@ module MixinBot
       end
 
       def build_output(receivers:, index:, amount:, threshold:, hint: nil)
+        warn_legacy_mixin_api!('LegacyOutput#build_output')
         _output = create_output(receivers:, index:, hint:)
         {
           amount: format('%.8f', amount.to_d.to_r),

data/lib/mixin_bot/api/legacy_payment.rb

@@ -4,6 +4,7 @@ module MixinBot
   class API
     module LegacyPayment
       def pay_url(**kwargs)
+        warn_legacy_mixin_api!('LegacyPayment#pay_url')
         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],
@@ -16,6 +17,7 @@ module MixinBot
 
       # https://developers.mixin.one/api/alpha-mixin-network/verify-payment/
       def verify_payment(**kwargs)
+        warn_legacy_mixin_api!('LegacyPayment#verify_payment')
         path = '/payments'
         payload = {
           asset_id: kwargs[:asset_id],

data/lib/mixin_bot/api/legacy_snapshot.rb

@@ -4,6 +4,7 @@ module MixinBot
   class API
     module LegacySnapshot
       def network_snapshots(**kwargs)
+        warn_legacy_mixin_api!('LegacySnapshot#network_snapshots')
         path = '/network/snapshots'
         params = {
           limit: kwargs[:limit],
@@ -16,6 +17,7 @@ module MixinBot
       end
 
       def snapshots(**kwargs)
+        warn_legacy_mixin_api!('LegacySnapshot#snapshots')
         path = '/snapshots'
 
         params = {
@@ -30,10 +32,24 @@ module MixinBot
       end
 
       def network_snapshot(snapshot_id, **kwargs)
+        warn_legacy_mixin_api!('LegacySnapshot#network_snapshot')
         path = format('/network/snapshots/%<snapshot_id>s', snapshot_id:)
 
         client.get path, access_token: kwargs[:access_token]
       end
+
+      def snapshot(snapshot_id, access_token: nil)
+        warn_legacy_mixin_api!('LegacySnapshot#snapshot')
+        path = format('/snapshots/%<snapshot_id>s', snapshot_id:)
+        client.get path, access_token:
+      end
+      alias snapshot_by_id snapshot
+
+      def snapshot_by_trace_id(trace_id, access_token: nil)
+        warn_legacy_mixin_api!('LegacySnapshot#snapshot_by_trace_id')
+        path = format('/snapshots/trace/%<trace_id>s', trace_id:)
+        client.get path, access_token:
+      end
     end
   end
 end

data/lib/mixin_bot/api/legacy_transaction.rb

@@ -18,7 +18,13 @@ module MixinBot
       # }
       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 }
+        warn_legacy_mixin_api!('LegacyTransaction#build_raw_transaction')
+        unless RAW_TRANSACTION_ARGUMENTS.all? do |param|
+                 kwargs.keys.include? param
+               end
+          raise ArgumentError,
+                "#{RAW_TRANSACTION_ARGUMENTS.join(', ')} are needed for build raw transaction"
+        end
 
         senders             = kwargs[:senders]
         senders_threshold   = kwargs[:senders_threshold]
@@ -96,7 +102,13 @@ module MixinBot
       # 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 }
+        warn_legacy_mixin_api!('LegacyTransaction#create_multisig_transaction')
+        unless MULTISIG_TRANSACTION_ARGUMENTS.all? do |param|
+                 options.keys.include? param
+               end
+          raise ArgumentError,
+                "#{MULTISIG_TRANSACTION_ARGUMENTS.join(', ')} are needed for create multisig transaction"
+        end
 
         asset_id = options[:asset_id]
         receivers = options[:receivers].sort
@@ -117,11 +129,9 @@ module MixinBot
           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
+        payload.update(
+          tip_or_legacy_pin_payload(pin, 'TIP:TRANSACTION:CREATE:', asset_id, receivers.join, threshold, amount, trace_id, memo)
+        )
 
         client.post path, **payload
       end
@@ -129,7 +139,13 @@ module MixinBot
       # 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 }
+        warn_legacy_mixin_api!('LegacyTransaction#create_mainnet_transaction')
+        unless MAINNET_TRANSACTION_ARGUMENTS.all? do |param|
+                 options.keys.include? param
+               end
+          raise ArgumentError,
+                "#{MAINNET_TRANSACTION_ARGUMENTS.join(', ')} are needed for create main net transactions"
+        end
 
         asset_id = options[:asset_id]
         opponent_id = options[:opponent_id]
@@ -146,17 +162,16 @@ module MixinBot
           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
+        payload.update(
+          tip_or_legacy_pin_payload(pin, 'TIP:TRANSACTION:CREATE:', asset_id, opponent_id, amount, trace_id, memo)
+        )
 
         client.post path, **payload
       end
 
       # use safe transaction protocol instead
       def transactions(**options)
+        warn_legacy_mixin_api!('LegacyTransaction#transactions')
         path = '/external/transactions'
         params = {
           limit: options[:limit],

data/lib/mixin_bot/api/legacy_transfer.rb

@@ -5,7 +5,10 @@ module MixinBot
     module LegacyTransfer
       TRANSFER_ARGUMENTS = %i[asset_id opponent_id amount].freeze
       def create_legacy_transfer(pin, **kwargs)
-        raise ArgumentError, "#{TRANSFER_ARGUMENTS.join(', ')} are needed for create transfer" unless TRANSFER_ARGUMENTS.all? { |param| kwargs.keys.include? param }
+        warn_legacy_mixin_api!('LegacyTransfer#create_legacy_transfer')
+        raise ArgumentError, "#{TRANSFER_ARGUMENTS.join(', ')} are needed for create transfer" unless TRANSFER_ARGUMENTS.all? do |param|
+                                                                                                        kwargs.keys.include? param
+                                                                                                      end
 
         asset_id = kwargs[:asset_id]
         opponent_id = kwargs[:opponent_id]
@@ -21,22 +24,22 @@ module MixinBot
           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
+        payload.update(
+          tip_or_legacy_pin_payload(pin, 'TIP:TRANSFER:CREATE:', asset_id, opponent_id, amount, trace_id, memo)
+        )
 
         path = '/transfers'
         client.post path, **payload
       end
 
       def legacy_transfer(trace_id, access_token: nil)
+        warn_legacy_mixin_api!('LegacyTransfer#legacy_transfer')
         path = format('/transfers/trace/%<trace_id>s', trace_id:)
         client.get path, access_token:
       end
+
+      alias transfer legacy_transfer
+      alias create_transfer create_legacy_transfer
     end
   end
 end

data/lib/mixin_bot/api/legacy_user.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    module LegacyUser
+      # Upgrades a legacy RSA keystore user to Ed25519 session keys.
+      #
+      # @param keystore [Hash] :pin, :session_id, :pin_token (base64), :private_key (PEM)
+      def upgrade_legacy_user(keystore)
+        kl = keystore.with_indifferent_access
+        priv = OpenSSL::PKey::RSA.new(kl[:private_key])
+        token = Base64.decode64(kl[:pin_token])
+        key_bytes = priv.decrypt(
+          token,
+          rsa_padding_mode: 'oaep',
+          rsa_oaep_md: 'sha256',
+          rsa_mgf1_md: 'sha1',
+          oaep_label: kl[:session_id]
+        )
+
+        pin_byte = kl[:pin].to_s.b
+        pin_byte += [Time.now.to_i].pack('Q<')
+        pin_byte += [0].pack('Q<')
+        padding = 16 - (pin_byte.length % 16)
+        pin_byte += ([padding].pack('C') * padding)
+
+        cipher = OpenSSL::Cipher.new('AES-256-CBC')
+        cipher.encrypt
+        iv = cipher.random_iv
+        cipher.key = key_bytes
+        ciphertext = iv + cipher.update(pin_byte) + cipher.final
+
+        pub_bytes = priv.public_key.to_der
+        seed = Digest::SHA512.digest(priv.to_der)[0, 32]
+        pub_ed25519 = RbNaCl::Signatures::Ed25519::SigningKey.new(seed).verify_key.to_bytes
+
+        payload = {
+          session_secret_legacy: Base64.urlsafe_encode64(pub_bytes, padding: false),
+          session_secret: Base64.urlsafe_encode64(pub_ed25519, padding: false),
+          session_id: kl[:session_id],
+          pin: Base64.urlsafe_encode64(ciphertext, padding: false)
+        }
+
+        result = client.post '/legacy/users', **payload, access_token: ''
+        data = result['data'] || result.data
+        result['data'] = data.merge('session_private_key' => seed.unpack1('H*')) if data.is_a?(Hash)
+        result
+      end
+    end
+  end
+end

data/lib/mixin_bot/api/me.rb

@@ -2,14 +2,60 @@
 
 module MixinBot
   class API
+    ##
+    # API methods for bot profile management.
+    #
+    # Provides methods to:
+    # - Retrieve bot profile information
+    # - Update bot profile (name, avatar)
+    # - List friends
+    # - Access Safe API profile
+    #
     module Me
+      ##
+      # Retrieves the bot's profile information.
+      #
+      # Returns detailed information about the bot including:
+      # - user_id
+      # - full_name
+      # - avatar_url
+      # - identity_number
+      # - phone
+      # - biography
+      # - created_at
+      #
+      # @param access_token [String, nil] optional access token for authentication
+      # @return [Hash] the bot profile
+      #
+      # @example
+      #   profile = api.me
+      #   puts profile['full_name']
+      #   puts profile['identity_number']
+      #
+      # @see https://developers.mixin.one/docs/api/users/me
+      #
       def me(access_token: nil)
         path = '/me'
         client.get path, access_token:
       end
 
-      # avatar_base64:
-      #   String: Base64 of image, supports format png, jpeg and gif, base64 image size > 1024.
+      ##
+      # Updates the bot's profile.
+      #
+      # Allows updating:
+      # - full_name: the bot's display name
+      # - avatar_base64: Base64-encoded avatar image (PNG, JPEG, or GIF, size > 1024 bytes)
+      #
+      # @param kwargs [Hash] update options
+      # @option kwargs [String] :full_name the new name for the bot
+      # @option kwargs [String] :avatar_base64 Base64-encoded image data
+      # @option kwargs [String] :access_token optional access token
+      # @return [Hash] the updated profile
+      #
+      # @example
+      #   api.update_me(full_name: 'My Awesome Bot')
+      #   api.update_me(avatar_base64: Base64.strict_encode64(File.read('avatar.png')))
+      #
       def update_me(**kwargs)
         path = '/me'
         payload = {
@@ -20,16 +66,66 @@ module MixinBot
         client.post path, **payload
       end
 
-      # https://developers.mixin.one/api/beta-mixin-message/friends/
+      ##
+      # Retrieves the bot's friend list.
+      #
+      # Returns an array of users who have interacted with the bot
+      # and are in the bot's contact list.
+      #
+      # @param access_token [String, nil] optional access token
+      # @return [Array<Hash>] array of user profiles
+      #
+      # @example
+      #   friends = api.friends
+      #   friends.each do |friend|
+      #     puts "#{friend['full_name']} (#{friend['user_id']})"
+      #   end
+      #
+      # @see https://developers.mixin.one/docs/api/users/friends
+      #
       def friends(access_token: nil)
         path = '/friends'
         client.get path, access_token:
       end
 
+      ##
+      # Retrieves the bot's Safe API profile.
+      #
+      # Returns Safe API-specific profile information including:
+      # - Safe wallet address
+      # - TIP signing key
+      # - Safe network status
+      #
+      # @param access_token [String, nil] optional access token
+      # @return [Hash] the Safe API profile
+      #
+      # @example
+      #   safe_profile = api.safe_me
+      #   puts safe_profile['user_id']
+      #
       def safe_me(access_token: nil)
         path = '/safe/me'
         client.get path, access_token:
       end
+      alias request_user_me safe_me
+
+      def update_preferences(message_source: nil, conversation_source: nil, currency: nil, threshold: nil,
+                             access_token: nil)
+        path = '/me/preferences'
+        payload = {
+          receive_message_source: message_source,
+          accept_conversation_source: conversation_source,
+          fiat_currency: currency,
+          transfer_notification_threshold: threshold
+        }.compact
+        client.post path, **payload, access_token:
+      end
+      alias update_preference update_preferences
+
+      def relationship(user_id:, action:, access_token: nil)
+        path = '/relationships'
+        client.post path, user_id:, action:, access_token:
+      end
     end
   end
 end