meshtastic 0.0.182 → 0.0.183

data/lib/meshtastic/admin.rb

@@ -3,6 +3,7 @@
 require 'timeout'
 require 'monitor'
 require 'meshtastic/admin_pb'
+require 'meshtastic/mqtt'
 
 module Meshtastic
   module Admin
@@ -18,7 +19,7 @@ module Meshtastic
     end
 
     SKIP = %i[
-      message serial_obj bluetooth_obj tcp_obj mqtt_obj to from channel want_ack hop_limit
+      message transport_obj to from channel want_ack hop_limit
       want_response port_num data via psks seconds owner long_name short_name index config_type
       module_config_type path node_num lat lon altitude time channel_settings channel_pb
       config module_config messages ringtone scale location event event_code kb_char touch_x
@@ -27,7 +28,26 @@ module Meshtastic
     ].freeze
     PAYLOAD_FIELDS = Meshtastic::AdminMessage.descriptor.lookup_oneof('payload_variant').map { |field| field.name.to_sym }.freeze
 
+    # Classify a handle returned by a transport's connect method.
+    public_class_method def self.transport_type(opts = {})
+      reject_legacy_transport_options(opts)
+      transport = opts[:transport_obj]
+      return :mqtt if transport.is_a?(MQTTClient)
+      raise ArgumentError, 'transport_obj has ambiguous transport handle keys' if transport.is_a?(Hash) && transport.key?(:bluetooth_conn) && (transport.key?(:serial_conn) || transport.key?(:tcp_socket))
+
+      if transport.is_a?(Hash) && transport.key?(:tcp_socket)
+        raise ArgumentError, 'transport_obj TCP handle requires tcp_socket and serial_conn' unless transport[:tcp_socket] && transport[:serial_conn]
+
+        return :tcp
+      end
+      return :bluetooth if transport.is_a?(Hash) && transport[:bluetooth_conn]
+      return :serial if transport.is_a?(Hash) && transport[:serial_conn]
+
+      raise ArgumentError, 'transport_obj must be a connected Serial, Bluetooth, TCP handle or MQTT client'
+    end
+
     public_class_method def self.encode(opts = {})
+      reject_legacy_transport_options(opts)
       original = opts[:message] || Meshtastic::AdminMessage.new
       raise ArgumentError, 'message must be an AdminMessage' unless original.is_a?(Meshtastic::AdminMessage)
 
@@ -54,8 +74,9 @@ module Meshtastic
     end
 
     public_class_method def self.send(opts = {})
+      type = transport_type(opts)
       message = encode(opts)
-      connection = opts[:serial_obj] || opts[:bluetooth_obj] || opts[:tcp_obj]
+      connection = opts[:transport_obj] unless type == :mqtt
       destination = opts[:to] || connection&.dig(:my_node_num)
       destination = destination.delete_prefix('!').to_i(16) if destination.is_a?(String) && destination.match?(/\A![0-9a-fA-F]{8}\z/)
       raise ArgumentError, 'an explicit unicast destination or connected my_node_num is required' unless destination.is_a?(Integer) && destination.between?(1, 0xfffffffe)
@@ -70,19 +91,21 @@ module Meshtastic
         payload: message.to_proto,
         want_response: want_response
       )
-      delivery = opts.merge(data: data, port_num: Meshtastic::PortNum::ADMIN_APP, to: destination)
+      delivery = opts.except(:transport_obj).merge(data: data, port_num: Meshtastic::PortNum::ADMIN_APP, to: destination)
+      delivery[:"#{type}_obj"] = opts[:transport_obj]
       delivery[:from] = 0 if connection && !opts.key?(:from)
       Meshtastic.deliver_data(delivery)
     end
 
     public_class_method def self.request(opts = {})
+      type = transport_type(opts)
       request_id = opts.fetch(:request_id) { Random.rand(2..0xffffffff) }
       raise ArgumentError, 'request_id must be an Integer from 2 through 0xffffffff' unless request_id.is_a?(Integer) && request_id.between?(2, 0xffffffff)
 
       options = opts.except(:request_id, :wait)
       return { request_id: request_id, result: send(options.merge(last_packet_id: request_id - 1)) } unless opts.fetch(:wait, true)
 
-      connection = options[:serial_obj] || options[:bluetooth_obj] || options[:tcp_obj]
+      connection = options[:transport_obj] unless type == :mqtt
       queue = connection && connection[:from_radio_queue]
       raise ArgumentError, 'synchronous Admin requires a connected radio receive queue' unless queue
 
@@ -114,6 +137,11 @@ module Meshtastic
       lock.exit if acquired
     end
 
+    private_class_method def self.reject_legacy_transport_options(opts = {})
+      legacy = opts.keys & %i[serial_obj bluetooth_obj tcp_obj mqtt_obj]
+      raise ArgumentError, "Admin no longer accepts #{legacy.join(', ')}; use transport_obj: with the connected handle" unless legacy.empty?
+    end
+
     private_class_method def self.acquire_session(opts = {})
       connection = opts[:connection]
       raise ArgumentError, 'automatic Admin sessions require a radio receive queue; supply session_passkey for MQTT' unless connection && connection[:from_radio_queue]
@@ -174,6 +202,7 @@ module Meshtastic
     end
 
     public_class_method def self.decode(opts = {})
+      reject_legacy_transport_options(opts)
       packet = opts[:packet]
       packet = packet.packet if packet.is_a?(Meshtastic::FromRadio)
       data = packet.is_a?(Meshtastic::MeshPacket) ? packet.decoded : packet
@@ -186,6 +215,7 @@ module Meshtastic
     end
 
     public_class_method def self.response(opts = {})
+      reject_legacy_transport_options(opts)
       packet = opts[:packet]
       packet = packet.packet if packet.is_a?(Meshtastic::FromRadio)
       return nil unless packet.is_a?(Meshtastic::MeshPacket) && packet.decoded&.portnum == :ADMIN_APP
@@ -419,6 +449,14 @@ module Meshtastic
 
     public_class_method def self.help
       puts "USAGE:
+        # Classify the actual connected transport handle.
+        #{self}.transport_type(
+          transport_obj: 'required - handle from Serial.connect, Bluetooth.connect, TCP.connect or MQTT.connect'
+        )
+        # Returns :serial, :bluetooth, :tcp or :mqtt; TCP includes serial framing keys.
+        # Nil, unknown and ambiguous handles are rejected. Old transport option keys are rejected.
+        # All send wrappers below require transport_obj and accept the shared send options.
+
         # Encode exactly one AdminMessage payload without modifying the caller.
         #{self}.encode(
           message: 'optional - existing AdminMessage to copy instead of a new one',
@@ -427,10 +465,7 @@ module Meshtastic
 
         # Send an AdminMessage on ADMIN_APP over a connected transport.
         #{self}.send(
-          serial_obj: 'optional - serial handle from Meshtastic::Serial.connect',
-          bluetooth_obj: 'optional - BLE handle from Meshtastic::Bluetooth.connect',
-          tcp_obj: 'optional - TCP handle from Meshtastic::TCP.connect',
-          mqtt_obj: 'optional - MQTT client from Meshtastic::MQTT.connect',
+          transport_obj: 'required - actual connected Serial, Bluetooth, TCP handle or MQTT client',
           to: 'optional - unicast node integer or !eighthex; defaults to connected my_node_num; required for MQTT',
           from: 'optional - sender number; radio default zero denotes the local PhoneAPI client',
           channel: 'optional - routing channel index (default zero)',
@@ -478,13 +513,13 @@ module Meshtastic
 
         # Reboot the node after a delay.
         #{self}.reboot(
-          serial_obj: 'optional - serial handle from Meshtastic::Serial.connect',
+          transport_obj: 'required - actual connected Serial, Bluetooth, TCP handle or MQTT client',
           seconds: 'optional - delay before reboot in seconds (default: 5)'
         )
 
         # Shut down the node after a delay.
         #{self}.shutdown(
-          serial_obj: 'optional - serial handle from Meshtastic::Serial.connect',
+          transport_obj: 'required - actual connected Serial, Bluetooth, TCP handle or MQTT client',
           seconds: 'optional - delay before shutdown in seconds (default: 5)'
         )
 
@@ -497,7 +532,7 @@ module Meshtastic
 
         # Request the node owner User protobuf.
         #{self}.get_owner(
-          serial_obj: 'optional - serial handle from Meshtastic::Serial.connect'
+          transport_obj: 'required - actual connected Serial, Bluetooth, TCP handle or MQTT client'
         )
 
         # Write a Channel protobuf to the node.
@@ -533,7 +568,7 @@ module Meshtastic
 
         # Request canned-message module strings.
         #{self}.get_canned_messages(
-          serial_obj: 'optional - serial handle from Meshtastic::Serial.connect'
+          transport_obj: 'required - actual connected Serial, Bluetooth, TCP handle or MQTT client'
         )
 
         # Set canned-message module strings.
@@ -543,12 +578,12 @@ module Meshtastic
 
         # Request DeviceMetadata (firmware version and hardware).
         #{self}.get_device_metadata(
-          serial_obj: 'optional - serial handle from Meshtastic::Serial.connect'
+          transport_obj: 'required - actual connected Serial, Bluetooth, TCP handle or MQTT client'
         )
 
         # Request the RTTTL ringtone string.
         #{self}.get_ringtone(
-          serial_obj: 'optional - serial handle from Meshtastic::Serial.connect'
+          transport_obj: 'required - actual connected Serial, Bluetooth, TCP handle or MQTT client'
         )
 
         # Set the RTTTL ringtone string.
@@ -558,17 +593,17 @@ module Meshtastic
 
         # Request DeviceConnectionStatus.
         #{self}.get_device_connection_status(
-          serial_obj: 'optional - serial handle from Meshtastic::Serial.connect'
+          transport_obj: 'required - actual connected Serial, Bluetooth, TCP handle or MQTT client'
         )
 
         # Request remote-hardware pin definitions.
         #{self}.get_node_remote_hardware_pins(
-          serial_obj: 'optional - serial handle from Meshtastic::Serial.connect'
+          transport_obj: 'required - actual connected Serial, Bluetooth, TCP handle or MQTT client'
         )
 
         # Ask the node to enter DFU / UF2 mode.
         #{self}.enter_dfu(
-          serial_obj: 'optional - serial handle from Meshtastic::Serial.connect'
+          transport_obj: 'required - actual connected Serial, Bluetooth, TCP handle or MQTT client'
         )
 
         # Delete a file on the node filesystem.
@@ -640,7 +675,7 @@ module Meshtastic
 
         # Clear the fixed GPS position on the node.
         #{self}.remove_fixed_position(
-          serial_obj: 'optional - serial handle from Meshtastic::Serial.connect'
+          transport_obj: 'required - actual connected Serial, Bluetooth, TCP handle or MQTT client'
         )
 
         # Set node wall-clock time.
@@ -650,7 +685,7 @@ module Meshtastic
 
         # Request DeviceUIConfig.
         #{self}.get_ui_config(
-          serial_obj: 'optional - serial handle from Meshtastic::Serial.connect'
+          transport_obj: 'required - actual connected Serial, Bluetooth, TCP handle or MQTT client'
         )
 
         # Store DeviceUIConfig on the node.
@@ -675,12 +710,12 @@ module Meshtastic
 
         # Open a settings edit transaction.
         #{self}.begin_edit(
-          serial_obj: 'optional - serial handle from Meshtastic::Serial.connect'
+          transport_obj: 'required - actual connected Serial, Bluetooth, TCP handle or MQTT client'
         )
 
         # Commit a settings edit transaction.
         #{self}.commit_edit(
-          serial_obj: 'optional - serial handle from Meshtastic::Serial.connect'
+          transport_obj: 'required - actual connected Serial, Bluetooth, TCP handle or MQTT client'
         )
 
         # Add a SharedContact to the node.
@@ -705,13 +740,13 @@ module Meshtastic
 
         # Clear the node database.
         #{self}.nodedb_reset(
-          serial_obj: 'optional - serial handle from Meshtastic::Serial.connect',
+          transport_obj: 'required - actual connected Serial, Bluetooth, TCP handle or MQTT client',
           preserve_favorites: 'optional - retain favorite nodes (default true); some firmware roles always preserve favorites'
         )
 
         # Exit the firmware simulator if running.
         #{self}.exit_simulator(
-          serial_obj: 'optional - serial handle from Meshtastic::Serial.connect'
+          transport_obj: 'required - actual connected Serial, Bluetooth, TCP handle or MQTT client'
         )
 
         # Write a SensorConfig protobuf.

data/lib/meshtastic/module_config.rb

@@ -5,11 +5,25 @@ require 'meshtastic/module_config_pb'
 module Meshtastic
   class ModuleConfig
     public_class_method def self.get(opts = {})
-      Admin.send(opts.merge(get_module_config_request: opts.fetch(:module_config_type, :MQTT_CONFIG)))
+      Admin.send(admin_options(opts).merge(get_module_config_request: opts.fetch(:module_config_type, :MQTT_CONFIG)))
     end
 
     public_class_method def self.set(opts = {})
-      Admin.send(opts.merge(set_module_config: opts.fetch(:module_config)))
+      Admin.send(admin_options(opts).merge(set_module_config: opts.fetch(:module_config)))
+    end
+
+    # Keep the external transport aliases out of the Admin API.
+    private_class_method def self.admin_options(opts = {})
+      options = opts.merge({})
+      keys = %i[transport_obj serial_obj bluetooth_obj tcp_obj mqtt_obj]
+      selected = keys.reject { |name| options[name].nil? }
+      raise ArgumentError, 'provide exactly one transport connection' if selected.length > 1
+
+      key = selected.first
+      connection = options[key] if key
+      keys.each { |name| options.delete(name) }
+      options[:transport_obj] = connection if key
+      options
     end
 
     public_class_method def self.authors
@@ -19,10 +33,14 @@ module Meshtastic
     public_class_method def self.help
       puts "        USAGE:
         # Run the get class method for this module.
-        #{self}.get
+        #{self}.get(transport_obj: connection, module_config_type: :MQTT_CONFIG)
 
         # Run the set class method for this module.
-        #{self}.set
+        #{self}.set(transport_obj: connection, module_config: module_config)
+
+        # Legacy serial_obj:, bluetooth_obj:, tcp_obj:, mqtt_obj: remain accepted.
+        # Supply one non-nil connection only; mixed connection options are rejected.
+        # Remote setters inherit Admin automatic sessions, not persistence readback.
 
         # Run the authors class method for this module.
         #{self}.authors

data/lib/meshtastic/rtttl.rb

@@ -11,11 +11,25 @@ module Meshtastic
     end
 
     public_class_method def self.set(opts = {})
-      Admin.send(opts.merge(set_ringtone_message: opts.fetch(:ringtone)))
+      Admin.send(admin_options(opts).merge(set_ringtone_message: opts.fetch(:ringtone)))
     end
 
     public_class_method def self.get(opts = {})
-      Admin.send(opts.merge(get_ringtone_request: true))
+      Admin.send(admin_options(opts).merge(get_ringtone_request: true))
+    end
+
+    # Keep the external transport aliases out of the Admin API.
+    private_class_method def self.admin_options(opts = {})
+      options = opts.merge({})
+      keys = %i[transport_obj serial_obj bluetooth_obj tcp_obj mqtt_obj]
+      selected = keys.reject { |name| options[name].nil? }
+      raise ArgumentError, 'provide exactly one transport connection' if selected.length > 1
+
+      key = selected.first
+      connection = options[key] if key
+      keys.each { |name| options.delete(name) }
+      options[:transport_obj] = connection if key
+      options
     end
 
     public_class_method def self.authors
@@ -28,10 +42,14 @@ module Meshtastic
         #{self}.encode
 
         # Run the set class method for this module.
-        #{self}.set
+        #{self}.set(transport_obj: connection, ringtone: ringtone)
 
         # Run the get class method for this module.
-        #{self}.get
+        #{self}.get(transport_obj: connection)
+
+        # Legacy serial_obj:, bluetooth_obj:, tcp_obj:, mqtt_obj: remain accepted.
+        # Supply one non-nil connection only; mixed connection options are rejected.
+        # Remote setters inherit Admin automatic sessions, not persistence readback.
 
         # Run the authors class method for this module.
         #{self}.authors

data/lib/meshtastic/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Meshtastic
-  VERSION = '0.0.182'
+  VERSION = '0.0.183'
 end

data/spec/lib/meshtastic/admin/channel_spec.rb

@@ -2,6 +2,13 @@
 
 require 'spec_helper'
 
+RSpec.describe Meshtastic::Admin::Channel do
+  it 'documents transport_obj rather than legacy connection keywords' do
+    expect { described_class.help }.to output(/transport_obj:/).to_stdout
+    expect { described_class.help }.not_to output(/serial_obj:|bluetooth_obj:|tcp_obj:|mqtt_obj:/).to_stdout
+  end
+end
+
 shared_context 'channel serial framing' do
   def fake_serial_obj
     written = +''.b
@@ -26,16 +33,23 @@ end
 describe Meshtastic::Admin::Channel do
   include_context 'channel serial framing'
 
+  it 'rejects legacy connection keys before filtering or building channel options' do
+    %i[serial_obj bluetooth_obj tcp_obj mqtt_obj].each do |key|
+      expect { described_class.set(transport_obj: fake_serial_obj, key => nil, index: -1) }
+        .to raise_error(ArgumentError, /#{key}.*transport_obj/)
+    end
+  end
+
   it 'requests a channel by index via Admin' do
     serial_obj = fake_serial_obj
-    described_class.get(serial_obj: serial_obj, index: 1)
+    described_class.get(transport_obj: serial_obj, index: 1)
     expect(decode_admin(serial_obj).get_channel_request).to eq(2)
   end
 
   [0, 7].each do |index|
     it "requests zero-based slot #{index} with its one-based wire index" do
       serial_obj = fake_serial_obj
-      described_class.get(serial_obj: serial_obj, index: index)
+      described_class.get(transport_obj: serial_obj, index: index)
       expect(decode_admin(serial_obj).get_channel_request).to eq(index + 1)
     end
   end
@@ -43,7 +57,7 @@ describe Meshtastic::Admin::Channel do
   it 'sets a Channel protobuf including settings and role' do
     serial_obj = fake_serial_obj
     settings = described_class.build_settings(name: 'LongFast', uplink_enabled: true)
-    described_class.set(serial_obj: serial_obj, index: 0, role: :PRIMARY, settings: settings)
+    described_class.set(transport_obj: serial_obj, index: 0, role: :PRIMARY, settings: settings)
     channel = decode_admin(serial_obj).set_channel
     expect(channel.index).to eq(0)
     expect(channel.role).to eq(:PRIMARY)
@@ -124,7 +138,7 @@ describe Meshtastic::Admin::Channel, 'channel URL support' do
   it 'rejects invalid settings lengths and slot indexes before any write' do
     [-1, 8, 0.5, 'junk'].each do |index|
       serial_obj = fake_serial_obj
-      expect { described_class.set(serial_obj: serial_obj, index: index, role: :PRIMARY) }.to raise_error(ArgumentError)
+      expect { described_class.set(transport_obj: serial_obj, index: index, role: :PRIMARY) }.to raise_error(ArgumentError)
       expect(serial_obj[:written]).to be_empty
     end
     expect { described_class.build_settings(psk: 'bad') }.to raise_error(ArgumentError)
@@ -137,7 +151,7 @@ describe Meshtastic::Admin::Channel, 'channel URL support' do
   it 'validates and overlays supplied channel/settings before transmission' do
     serial_obj = fake_serial_obj
     original = Meshtastic::Channel.new(index: 2, role: :SECONDARY, settings: { name: 'before', uplink_enabled: true })
-    described_class.set(serial_obj: serial_obj, channel: original, name: 'after', uplink_enabled: false)
+    described_class.set(transport_obj: serial_obj, channel: original, name: 'after', uplink_enabled: false)
     written = decode_admin(serial_obj).set_channel
     expect(written.index).to eq(2)
     expect(written.settings.name).to eq('after')
@@ -145,7 +159,7 @@ describe Meshtastic::Admin::Channel, 'channel URL support' do
     expect(original.settings.name).to eq('before')
     expect(described_class.build(settings: { name: 'hash' }).settings.name).to eq('hash')
     invalid = Meshtastic::Channel.new(index: 8)
-    expect { described_class.set(serial_obj: fake_serial_obj, channel: invalid) }.to raise_error(ArgumentError)
+    expect { described_class.set(transport_obj: fake_serial_obj, channel: invalid) }.to raise_error(ArgumentError)
     expect { described_class.build(settings: { psk: 'bad' }) }.to raise_error(ArgumentError)
   end
 
@@ -153,7 +167,7 @@ describe Meshtastic::Admin::Channel, 'channel URL support' do
     serial_obj = fake_serial_obj
     channel_set = Meshtastic::ChannelSet.new(settings: [{ name: 'main' }, { name: 'other' }], lora_config: { region: :US })
     url = "https://meshtastic.org/e/##{Base64.urlsafe_encode64(channel_set.to_proto, padding: false)}"
-    results = described_class.apply_url(serial_obj: serial_obj, url: url, session_passkey: 'test-key')
+    results = described_class.apply_url(transport_obj: serial_obj, url: url, session_passkey: 'test-key')
     frames = serial_obj[:written].dup
     messages = []
     until frames.empty?
@@ -176,11 +190,11 @@ describe Meshtastic::Admin::Channel, 'channel URL support' do
     serial_obj = fake_serial_obj
     invalid = Meshtastic::ChannelSet.new(settings: [{ name: 'good' }, { psk: 'bad' }])
     url = "https://meshtastic.org/e/##{Base64.urlsafe_encode64(invalid.to_proto, padding: false)}"
-    expect { described_class.apply_url(serial_obj: serial_obj, url: url) }.to raise_error(ArgumentError)
+    expect { described_class.apply_url(transport_obj: serial_obj, url: url) }.to raise_error(ArgumentError)
     expect(serial_obj[:written]).to be_empty
     valid = Meshtastic::ChannelSet.new(settings: [{ name: 'test' }])
     url = "https://meshtastic.org/e/?add=true##{Base64.urlsafe_encode64(valid.to_proto, padding: false)}"
-    expect { described_class.apply_url(serial_obj: serial_obj, url: url) }.to raise_error(ArgumentError, /add-only/)
+    expect { described_class.apply_url(transport_obj: serial_obj, url: url) }.to raise_error(ArgumentError, /add-only/)
     expect(serial_obj[:written]).to be_empty
   end
 

data/spec/lib/meshtastic/admin/config_spec.rb

@@ -2,6 +2,13 @@
 
 require 'spec_helper'
 
+RSpec.describe Meshtastic::Admin::Config do
+  it 'documents transport_obj rather than legacy connection keywords' do
+    expect { described_class.help }.to output(/transport_obj:/).to_stdout
+    expect { described_class.help }.not_to output(/serial_obj:|bluetooth_obj:|tcp_obj:|mqtt_obj:/).to_stdout
+  end
+end
+
 describe Meshtastic::Admin::Config do
   def fake_serial_obj
     written = +''.b
@@ -22,9 +29,18 @@ describe Meshtastic::Admin::Config do
     Meshtastic::AdminMessage.decode(Meshtastic::ToRadio.decode(body).packet.decoded.payload)
   end
 
+  it 'rejects legacy connection keys rather than silently filtering them' do
+    %i[serial_obj bluetooth_obj tcp_obj mqtt_obj].each do |key|
+      handle = fake_serial_obj
+      expect { described_class.set_device_ui(transport_obj: handle, key => nil, device_ui: {}) }
+        .to raise_error(ArgumentError, /#{key}/)
+      expect(handle[:written]).to be_empty
+    end
+  end
+
   it 'requests LoRa config via Admin' do
     serial_obj = fake_serial_obj
-    described_class.get(serial_obj: serial_obj, config_type: :LORA_CONFIG)
+    described_class.get(transport_obj: serial_obj, config_type: :LORA_CONFIG)
     expect(decode_admin(serial_obj).get_config_request).to eq(:LORA_CONFIG)
   end
 
@@ -32,13 +48,13 @@ describe Meshtastic::Admin::Config do
     serial_obj = fake_serial_obj
     config = Meshtastic::Config.new
     config.device = Meshtastic::Config::DeviceConfig.new(role: :CLIENT)
-    described_class.set(serial_obj: serial_obj, config: config)
+    described_class.set(transport_obj: serial_obj, config: config)
     expect(decode_admin(serial_obj).set_config.device.role).to eq(:CLIENT)
   end
 
   it 'requests each ConfigType via named getters' do
     serial_obj = fake_serial_obj
-    described_class.get_lora(serial_obj: serial_obj)
+    described_class.get_lora(transport_obj: serial_obj)
     expect(decode_admin(serial_obj).get_config_request).to eq(:LORA_CONFIG)
   end
 
@@ -48,7 +64,7 @@ describe Meshtastic::Admin::Config do
     it "writes the #{field.name} section through real serial framing" do
       serial_obj = fake_serial_obj
       section = field.subtype.msgclass.new
-      described_class.public_send("set_#{field.name}", serial_obj: serial_obj, field.name.to_sym => section)
+      described_class.public_send("set_#{field.name}", transport_obj: serial_obj, field.name.to_sym => section)
       config = decode_admin(serial_obj).set_config
       expect(config.payload_variant).to eq(field.name.to_sym)
       expect(config[field.name]).to eq(section)
@@ -57,7 +73,7 @@ describe Meshtastic::Admin::Config do
 
   it 'rejects an empty config before writing bytes' do
     serial_obj = fake_serial_obj
-    expect { described_class.set(serial_obj: serial_obj, config: Meshtastic::Config.new) }.to raise_error(ArgumentError)
+    expect { described_class.set(transport_obj: serial_obj, config: Meshtastic::Config.new) }.to raise_error(ArgumentError)
     expect(serial_obj[:written]).to be_empty
   end
 
@@ -66,31 +82,31 @@ describe Meshtastic::Admin::Config do
 
     it "accepts a field hash for #{field.name}" do
       serial_obj = fake_serial_obj
-      described_class.public_send("set_#{field.name}", serial_obj: serial_obj, field.name.to_sym => {})
+      described_class.public_send("set_#{field.name}", transport_obj: serial_obj, field.name.to_sym => {})
       expect(decode_admin(serial_obj).set_config.payload_variant).to eq(field.name.to_sym)
     end
 
     it "rejects missing #{field.name} before writing bytes" do
       serial_obj = fake_serial_obj
-      expect { described_class.public_send("set_#{field.name}", serial_obj: serial_obj) }.to(raise_error { |error| expect([ArgumentError, KeyError]).to include(error.class) })
+      expect { described_class.public_send("set_#{field.name}", transport_obj: serial_obj) }.to(raise_error { |error| expect([ArgumentError, KeyError]).to include(error.class) })
       expect(serial_obj[:written]).to be_empty
     end
   end
 
   it 'uses dedicated device UI requests and stores instead of firmware no-op Config fields' do
     serial_obj = fake_serial_obj
-    described_class.get_device_ui(serial_obj: serial_obj)
+    described_class.get_device_ui(transport_obj: serial_obj)
     expect(decode_admin(serial_obj).payload_variant).to eq(:get_ui_config_request)
     serial_obj = fake_serial_obj
-    described_class.set_device_ui(serial_obj: serial_obj, device_ui: {})
+    described_class.set_device_ui(transport_obj: serial_obj, device_ui: {})
     expect(decode_admin(serial_obj).payload_variant).to eq(:store_ui_config)
   end
 
   it 'rejects the read-only session-key placeholder without transmitting' do
     serial_obj = fake_serial_obj
     config = Meshtastic::Config.new(sessionkey: {})
-    expect { described_class.set(serial_obj: serial_obj, config: config) }.to raise_error(ArgumentError, /request-only/)
-    expect { described_class.set_sessionkey(serial_obj: serial_obj, sessionkey: {}) }.to raise_error(ArgumentError, /request-only/)
+    expect { described_class.set(transport_obj: serial_obj, config: config) }.to raise_error(ArgumentError, /request-only/)
+    expect { described_class.set_sessionkey(transport_obj: serial_obj, sessionkey: {}) }.to raise_error(ArgumentError, /request-only/)
     expect(serial_obj[:written]).to be_empty
   end
 
@@ -101,7 +117,7 @@ describe Meshtastic::Admin::Config do
   }.each do |section, config_type|
     it "requests #{section} using its protocol ConfigType" do
       serial_obj = fake_serial_obj
-      described_class.public_send("get_#{section}", serial_obj: serial_obj)
+      described_class.public_send("get_#{section}", transport_obj: serial_obj)
       message = decode_admin(serial_obj)
       expect(message.payload_variant).to eq(:get_config_request)
       expect(message.get_config_request).to eq(config_type)