mixin_bot 1.4.0 → 2.1.0

data/lib/mixin_bot/api/code.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    module Code
+      def read_code(code_id, access_token: nil)
+        path = format('/codes/%<code_id>s', code_id:)
+        client.get path, access_token: access_token || ''
+      end
+
+      def read_multisig_by_code(code_id, access_token: nil)
+        read_code(code_id, access_token:)
+      end
+
+      def create_scheme(target, access_token: nil)
+        client.post '/schemes', target:, access_token:
+      end
+      alias schemes create_scheme
+    end
+  end
+end

data/lib/mixin_bot/api/computer_api.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    # Delegates to {MixinBot::Computer} for API surface parity with Go SDK.
+    module ComputerApi
+      def get_computer_info
+        MixinBot::Computer.info
+      end
+
+      def get_computer_user(addr)
+        MixinBot::Computer.user(addr)
+      end
+
+      def get_computer_deployed_assets
+        MixinBot::Computer.deployed_assets
+      end
+
+      def get_computer_system_call(id)
+        MixinBot::Computer.system_call(id)
+      end
+
+      def computer_deploy_external_asset(assets)
+        MixinBot::Computer.deploy_external_assets(assets)
+      end
+
+      def lock_computer_nonce_account(mix)
+        MixinBot::Computer.lock_nonce_account(mix)
+      end
+
+      def get_fee_on_xin_based_on_sol(sol_amount)
+        MixinBot::Computer.fee_on_xin_from_sol(sol_amount)
+      end
+
+      def register_computer
+        MixinBot::Computer.register_computer(self)
+      end
+
+      def computer_user_id_to_bytes(id)
+        MixinBot::Computer.user_id_to_bytes(id)
+      end
+
+      def build_system_call_extra(uid, cid, skip_process: false, fid: nil)
+        MixinBot::Computer.build_system_call_extra(uid, cid, skip_process:, fid:)
+      end
+
+      def encode_operation_memo(operation, extra = +'')
+        MixinBot::Computer.encode_operation_memo(operation, extra)
+      end
+
+      def encode_mtg_extra(app_id, extra)
+        MixinBot::Computer.encode_mtg_extra(app_id, extra)
+      end
+
+      def decode_computer_extra_base64(extra)
+        MixinBot::Computer.decode_computer_extra_base64(extra)
+      end
+    end
+  end
+end

data/lib/mixin_bot/api/conversation.rb

@@ -29,7 +29,8 @@ module MixinBot
 
       def create_group_conversation(user_ids:, name:, **kwargs)
         random_id = kwargs[:random_id] || SecureRandom.uuid
-        conversation_id = kwargs[:conversation_id] || MixinBot.utils.generate_group_conversation_id(user_ids:, name:, owner_id: config.app_id, random_id:)
+        conversation_id = kwargs[:conversation_id] || MixinBot.utils.generate_group_conversation_id(user_ids:, name:,
+                                                                                                    owner_id: config.app_id, random_id:)
         create_conversation(
           announcement: kwargs[:announcement],
           category: 'GROUP',
@@ -54,23 +55,40 @@ module MixinBot
         )
       end
 
-      def update_group_conversation_name(name:, conversation_id:, access_token: nil)
+      def update_conversation(conversation_id:, **kwargs)
         path = format('/conversations/%<id>s', id: conversation_id)
         payload = {
-          name:
-        }
+          name: kwargs[:name],
+          announcement: kwargs[:announcement]
+        }.compact
+        client.post path, **payload, access_token: kwargs[:access_token]
+      end
+      alias update_group_info update_conversation
 
-        client.post path, **payload, access_token:
+      def update_group_conversation_name(name:, conversation_id:, access_token: nil)
+        update_conversation(conversation_id:, name:, access_token:)
       end
 
       def update_group_conversation_announcement(announcement:, conversation_id:, access_token: nil)
-        path = format('/conversations/%<id>s', id: conversation_id)
-        payload = {
-          announcement:
-        }
+        update_conversation(conversation_id:, announcement:, access_token:)
+      end
 
-        client.post path, **payload, access_token:
+      def mute_conversation(conversation_id, duration:, access_token: nil)
+        path = format('/conversations/%<id>s/mute', id: conversation_id)
+        client.post path, duration:, access_token:
       end
+      alias mute mute_conversation
+
+      def unmute_conversation(conversation_id, access_token: nil)
+        mute_conversation conversation_id, duration: 0, access_token:
+      end
+      alias unmute unmute_conversation
+
+      def set_conversation_disappear_duration(conversation_id, duration:, access_token: nil)
+        path = format('/conversations/%<id>s/disappear', id: conversation_id)
+        client.post path, duration:, access_token:
+      end
+      alias disappear_duration set_conversation_disappear_duration
 
       # participants = [{ user_id: "" }]
       def add_conversation_participants(conversation_id:, user_ids:, access_token: nil)
@@ -94,6 +112,11 @@ module MixinBot
         client.post path, access_token:
       end
 
+      def join_conversation(conversation_id, access_token: nil)
+        path = format('/conversations/%<conversation_id>s/join', conversation_id:)
+        client.post path, access_token:
+      end
+
       def rotate_conversation(conversation_id, access_token: nil)
         path = format('/conversations/%<id>s/rotate', id: conversation_id)
 

data/lib/mixin_bot/api/deposit.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    module Deposit
+      def pending_safe_deposits(**params)
+        query = {
+          limit: params[:limit],
+          offset: params[:offset],
+          asset: params[:asset],
+          destination: params[:destination],
+          tag: params[:tag]
+        }.compact
+        client.get '/safe/deposits', **query, access_token: params[:access_token] || ''
+      end
+      alias fetch_pending_safe_deposits pending_safe_deposits
+    end
+  end
+end

data/lib/mixin_bot/api/encrypted_message.rb

@@ -194,7 +194,7 @@ module MixinBot
         decrypter.key = key
         decrypter.iv = bytes[prefix_size...(prefix_size + 12)].pack('C*')
         decrypter.auth_tag = bytes.last(16).pack('C*')
-        decrypted = decrypter.update(bytes[(prefix_size + 12)...(bytes.size - 16)].pack('C*'))
+        decrypted = decrypter.update(bytes[(prefix_size + 12)...-16].pack('C*'))
         decrypter.final
 
         Base64.urlsafe_encode64 decrypted

data/lib/mixin_bot/api/external.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    module External
+      def external_proxy(method:, params: [], access_token: nil)
+        client.post '/external/proxy', method:, params:, access_token:
+      end
+      alias proxy external_proxy
+    end
+  end
+end

data/lib/mixin_bot/api/fiat.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    module Fiat
+      def fiats(access_token: nil)
+        client.get '/external/fiats', access_token: access_token || ''
+      end
+      alias get_fiats fiats
+    end
+  end
+end

data/lib/mixin_bot/api/inscription.rb

@@ -21,8 +21,8 @@ module MixinBot
         client.get path, offset:
       end
 
-      def collectibles(members: [], access_token: nil)
-        unspent_outputs = safe_outputs(state: :unspent, members:, access_token:)['data']
+      def collectibles(members: [], access_token: nil, state: :unspent)
+        unspent_outputs = safe_outputs(state:, members:, access_token:)['data']
         unspent_outputs.select { |output| output['inscription_hash'].present? }
       end
 

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