proofmode 0.8.0

data/lib/proofmode.rb

@@ -0,0 +1,1499 @@
+# This file was autogenerated by some hot garbage in the `uniffi` crate.
+# Trust me, you don't want to mess with it!
+
+# Common helper code.
+#
+# Ideally this would live in a separate .rb file where it can be unittested etc
+# in isolation, and perhaps even published as a re-useable package.
+#
+# However, it's important that the details of how this helper code works (e.g. the
+# way that different builtin types are passed across the FFI) exactly match what's
+# expected by the rust code on the other side of the interface. In practice right
+# now that means coming from the exact some version of `uniffi` that was used to
+# compile the rust component. The easiest way to ensure this is to bundle the Ruby
+# helpers directly inline like we're doing here.
+
+require 'ffi'
+
+
+module Proofmode
+  def self.uniffi_in_range(i, type_name, min, max)
+  raise TypeError, "no implicit conversion of #{i} into Integer" unless i.respond_to?(:to_int)
+  i = i.to_int
+  raise RangeError, "#{type_name} requires #{min} <= value < #{max}" unless (min <= i && i < max)
+  i
+end
+
+def self.uniffi_utf8(v)
+  raise TypeError, "no implicit conversion of #{v} into String" unless v.respond_to?(:to_str)
+  v = v.to_str.encode(Encoding::UTF_8)
+  raise Encoding::InvalidByteSequenceError, "not a valid UTF-8 encoded string" unless v.valid_encoding?
+  v
+end
+
+def self.uniffi_bytes(v)
+  raise TypeError, "no implicit conversion of #{v} into String" unless v.respond_to?(:to_str)
+  v.to_str
+end
+
+  class RustBuffer < FFI::Struct
+  layout :capacity, :uint64,
+         :len,      :uint64,
+         :data,     :pointer
+
+  def self.alloc(size)
+    return Proofmode.rust_call(:ffi_proofmode_rustbuffer_alloc, size)
+  end
+
+  def self.reserve(rbuf, additional)
+    return Proofmode.rust_call(:ffi_proofmode_rustbuffer_reserve, rbuf, additional)
+  end
+
+  def free
+    Proofmode.rust_call(:ffi_proofmode_rustbuffer_free, self)
+  end
+
+  def capacity
+    self[:capacity]
+  end
+
+  def len
+    self[:len]
+  end
+
+  def len=(value)
+    self[:len] = value
+  end
+
+  def data
+    self[:data]
+  end
+
+  def to_s
+    "RustBuffer(capacity=#{capacity}, len=#{len}, data=#{data.read_bytes len})"
+  end
+
+  # The allocated buffer will be automatically freed if an error occurs, ensuring that
+  # we don't accidentally leak it.
+  def self.allocWithBuilder
+    builder = RustBufferBuilder.new
+
+    begin
+      yield builder
+    rescue => e
+      builder.discard
+      raise e
+    end
+  end
+
+  # The RustBuffer will be freed once the context-manager exits, ensuring that we don't
+  # leak it even if an error occurs.
+  def consumeWithStream
+    stream = RustBufferStream.new self
+
+    yield stream
+
+    raise RuntimeError, 'junk data left in buffer after consuming' if stream.remaining != 0
+  ensure
+    free
+  end# The primitive String type.
+
+  def self.allocFromString(value)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write value.encode('utf-8')
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoString
+    consumeWithStream do |stream|
+      return stream.read(stream.remaining).force_encoding(Encoding::UTF_8)
+    end
+  end
+
+  # The primitive Bytes type.
+
+  def self.allocFromBytes(value)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_Bytes(value)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoBytes
+    consumeWithStream do |stream|
+      return stream.readBytes
+    end
+  end
+
+  # The Record type CellInfo.
+
+  def self.check_lower_TypeCellInfo(v)
+    
+    RustBuffer.check_lower_Optionalstring(v.cell_id)
+    RustBuffer.check_lower_Optionalstring(v.lac)
+  end
+
+  def self.alloc_from_TypeCellInfo(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeCellInfo(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeCellInfo
+    consumeWithStream do |stream|
+      return stream.readTypeCellInfo
+    end
+  end
+
+  # The Record type DeviceData.
+
+  def self.check_lower_TypeDeviceData(v)
+    
+    
+    
+    RustBuffer.check_lower_Optionalstring(v.device_id)
+  end
+
+  def self.alloc_from_TypeDeviceData(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeDeviceData(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeDeviceData
+    consumeWithStream do |stream|
+      return stream.readTypeDeviceData
+    end
+  end
+
+  # The Record type LocationData.
+
+  def self.check_lower_TypeLocationData(v)
+    
+    
+    RustBuffer.check_lower_Optionalf64(v.altitude)
+    RustBuffer.check_lower_Optionalf64(v.accuracy)
+    RustBuffer.check_lower_Optionalstring(v.provider)
+  end
+
+  def self.alloc_from_TypeLocationData(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeLocationData(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeLocationData
+    consumeWithStream do |stream|
+      return stream.readTypeLocationData
+    end
+  end
+
+  # The Record type NetworkData.
+
+  def self.check_lower_TypeNetworkData(v)
+    
+    RustBuffer.check_lower_Optionalstring(v.wifi_ssid)
+    RustBuffer.check_lower_OptionalTypeCellInfo(v.cell_info)
+  end
+
+  def self.alloc_from_TypeNetworkData(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeNetworkData(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeNetworkData
+    consumeWithStream do |stream|
+      return stream.readTypeNetworkData
+    end
+  end
+
+  # The Record type ProofModeConfig.
+
+  def self.check_lower_TypeProofModeConfig(v)
+    
+    
+    
+    
+    
+  end
+
+  def self.alloc_from_TypeProofModeConfig(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeProofModeConfig(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeProofModeConfig
+    consumeWithStream do |stream|
+      return stream.readTypeProofModeConfig
+    end
+  end
+
+  
+
+  # The Optional<T> type for f64.
+
+  def self.check_lower_Optionalf64(v)
+    if not v.nil?
+      
+    end
+  end
+
+  def self.alloc_from_Optionalf64(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_Optionalf64(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoOptionalf64
+    consumeWithStream do |stream|
+      return stream.readOptionalf64
+    end
+  end
+
+  # The Optional<T> type for string.
+
+  def self.check_lower_Optionalstring(v)
+    if not v.nil?
+      
+    end
+  end
+
+  def self.alloc_from_Optionalstring(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_Optionalstring(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoOptionalstring
+    consumeWithStream do |stream|
+      return stream.readOptionalstring
+    end
+  end
+
+  # The Optional<T> type for bytes.
+
+  def self.check_lower_Optionalbytes(v)
+    if not v.nil?
+      
+    end
+  end
+
+  def self.alloc_from_Optionalbytes(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_Optionalbytes(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoOptionalbytes
+    consumeWithStream do |stream|
+      return stream.readOptionalbytes
+    end
+  end
+
+  # The Optional<T> type for TypeCellInfo.
+
+  def self.check_lower_OptionalTypeCellInfo(v)
+    if not v.nil?
+      RustBuffer.check_lower_TypeCellInfo(v)
+    end
+  end
+
+  def self.alloc_from_OptionalTypeCellInfo(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_OptionalTypeCellInfo(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoOptionalTypeCellInfo
+    consumeWithStream do |stream|
+      return stream.readOptionalTypeCellInfo
+    end
+  end
+
+  # The Optional<T> type for TypeDeviceData.
+
+  def self.check_lower_OptionalTypeDeviceData(v)
+    if not v.nil?
+      RustBuffer.check_lower_TypeDeviceData(v)
+    end
+  end
+
+  def self.alloc_from_OptionalTypeDeviceData(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_OptionalTypeDeviceData(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoOptionalTypeDeviceData
+    consumeWithStream do |stream|
+      return stream.readOptionalTypeDeviceData
+    end
+  end
+
+  # The Optional<T> type for TypeLocationData.
+
+  def self.check_lower_OptionalTypeLocationData(v)
+    if not v.nil?
+      RustBuffer.check_lower_TypeLocationData(v)
+    end
+  end
+
+  def self.alloc_from_OptionalTypeLocationData(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_OptionalTypeLocationData(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoOptionalTypeLocationData
+    consumeWithStream do |stream|
+      return stream.readOptionalTypeLocationData
+    end
+  end
+
+  # The Optional<T> type for TypeNetworkData.
+
+  def self.check_lower_OptionalTypeNetworkData(v)
+    if not v.nil?
+      RustBuffer.check_lower_TypeNetworkData(v)
+    end
+  end
+
+  def self.alloc_from_OptionalTypeNetworkData(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_OptionalTypeNetworkData(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoOptionalTypeNetworkData
+    consumeWithStream do |stream|
+      return stream.readOptionalTypeNetworkData
+    end
+  end
+
+  # The Sequence<T> type for string.
+
+  def self.check_lower_Sequencestring(v)
+    v.each do |item|
+      
+    end
+  end
+
+  def self.alloc_from_Sequencestring(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_Sequencestring(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoSequencestring
+    consumeWithStream do |stream|
+      return stream.readSequencestring
+    end
+  end
+
+  # The Map<T> type for string.
+
+  def self.check_lower_MapStringString(v)
+    v.each do |k, v|
+      
+      
+    end
+  end
+
+  def self.alloc_from_MapStringString(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_MapStringString(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoMapStringString
+    consumeWithStream do |stream|
+      return stream.readMapStringString
+    end
+  end
+end
+
+module UniFFILib
+  class ForeignBytes < FFI::Struct
+    layout :len,      :int32,
+           :data,     :pointer
+
+    def len
+      self[:len]
+    end
+
+    def data
+      self[:data]
+    end
+
+    def to_s
+      "ForeignBytes(len=#{len}, data=#{data.read_bytes(len)})"
+    end
+  end
+end
+
+private_constant :UniFFILib
+  
+# Helper for structured reading of values from a RustBuffer.
+class RustBufferStream
+
+  def initialize(rbuf)
+    @rbuf = rbuf
+    @offset = 0
+  end
+
+  def remaining
+    @rbuf.len - @offset
+  end
+
+  def read(size)
+    raise InternalError, 'read past end of rust buffer' if @offset + size > @rbuf.len
+
+    data = @rbuf.data.get_bytes @offset, size
+
+    @offset += size
+
+    data
+  end
+
+  def readF64
+    unpack_from 8, 'G'
+  end
+
+  def readBool
+    v = unpack_from 1, 'c'
+
+    return false if v == 0
+    return true if v == 1
+
+    raise InternalError, 'Unexpected byte for Boolean type'
+  end
+
+  def readString
+    size = unpack_from 4, 'l>'
+
+    raise InternalError, 'Unexpected negative string length' if size.negative?
+
+    read(size).force_encoding(Encoding::UTF_8)
+  end
+
+  def readBytes
+    size = unpack_from 4, 'l>'
+
+    raise InternalError, 'Unexpected negative byte string length' if size.negative?
+
+    read(size).force_encoding(Encoding::BINARY)
+  end
+
+  # The Object type ProofModeCallbacks.
+
+  def readTypeProofModeCallbacks
+    handle = unpack_from 8, 'Q>'
+    return ProofModeCallbacks.uniffi_allocate(handle)
+  end
+
+  # The Record type CellInfo.
+
+  def readTypeCellInfo
+    CellInfo.new(
+      carrier: readString,
+      cell_id: readOptionalstring,
+      lac: readOptionalstring
+    )
+  end
+
+  # The Record type DeviceData.
+
+  def readTypeDeviceData
+    DeviceData.new(
+      manufacturer: readString,
+      model: readString,
+      os_version: readString,
+      device_id: readOptionalstring
+    )
+  end
+
+  # The Record type LocationData.
+
+  def readTypeLocationData
+    LocationData.new(
+      latitude: readF64,
+      longitude: readF64,
+      altitude: readOptionalf64,
+      accuracy: readOptionalf64,
+      provider: readOptionalstring
+    )
+  end
+
+  # The Record type NetworkData.
+
+  def readTypeNetworkData
+    NetworkData.new(
+      network_type: readString,
+      wifi_ssid: readOptionalstring,
+      cell_info: readOptionalTypeCellInfo
+    )
+  end
+
+  # The Record type ProofModeConfig.
+
+  def readTypeProofModeConfig
+    ProofModeConfig.new(
+      auto_notarize: readBool,
+      track_location: readBool,
+      track_device_id: readBool,
+      track_network: readBool,
+      add_credentials: readBool
+    )
+  end
+
+  
+
+  
+
+  # The Error type ProofModeError
+
+  def readTypeProofModeError
+    variant = unpack_from 4, 'l>'
+    
+    if variant == 1
+        return ProofModeError::Io.new(
+            readString()
+        )
+    end
+    if variant == 2
+        return ProofModeError::Generation.new(
+            readString()
+        )
+    end
+    if variant == 3
+        return ProofModeError::Check.new(
+            readString()
+        )
+    end
+
+    raise InternalError, 'Unexpected variant tag for TypeProofModeError'
+  end
+  
+
+  # The Optional<T> type for f64.
+
+  def readOptionalf64
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return readF64
+    else
+      raise InternalError, 'Unexpected flag byte for Optionalf64'
+    end
+  end
+
+  # The Optional<T> type for string.
+
+  def readOptionalstring
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return readString
+    else
+      raise InternalError, 'Unexpected flag byte for Optionalstring'
+    end
+  end
+
+  # The Optional<T> type for bytes.
+
+  def readOptionalbytes
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return readBytes
+    else
+      raise InternalError, 'Unexpected flag byte for Optionalbytes'
+    end
+  end
+
+  # The Optional<T> type for TypeCellInfo.
+
+  def readOptionalTypeCellInfo
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return readTypeCellInfo
+    else
+      raise InternalError, 'Unexpected flag byte for OptionalTypeCellInfo'
+    end
+  end
+
+  # The Optional<T> type for TypeDeviceData.
+
+  def readOptionalTypeDeviceData
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return readTypeDeviceData
+    else
+      raise InternalError, 'Unexpected flag byte for OptionalTypeDeviceData'
+    end
+  end
+
+  # The Optional<T> type for TypeLocationData.
+
+  def readOptionalTypeLocationData
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return readTypeLocationData
+    else
+      raise InternalError, 'Unexpected flag byte for OptionalTypeLocationData'
+    end
+  end
+
+  # The Optional<T> type for TypeNetworkData.
+
+  def readOptionalTypeNetworkData
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return readTypeNetworkData
+    else
+      raise InternalError, 'Unexpected flag byte for OptionalTypeNetworkData'
+    end
+  end
+
+  # The Sequence<T> type for string.
+
+  def readSequencestring
+    count = unpack_from 4, 'l>'
+
+    raise InternalError, 'Unexpected negative sequence length' if count.negative?
+
+    items = []
+
+    count.times do
+      items.append readString
+    end
+
+    items
+  end
+
+  # The Map<T> type for string.
+
+  def readMapStringString
+    count = unpack_from 4, 'l>'
+    raise InternalError, 'Unexpected negative map size' if count.negative?
+
+    items = {}
+    count.times do
+      key = readString
+      items[key] = readString
+    end
+
+    items
+  end
+
+  def unpack_from(size, format)
+    raise InternalError, 'read past end of rust buffer' if @offset + size > @rbuf.len
+
+    value = @rbuf.data.get_bytes(@offset, size).unpack format
+
+    @offset += size
+
+    # TODO: verify this
+    raise 'more than one element!!!' if value.size > 1
+
+    value[0]
+  end
+end
+
+private_constant :RustBufferStream
+  
+# Helper for structured writing of values into a RustBuffer.
+class RustBufferBuilder
+  def initialize
+    @rust_buf = RustBuffer.alloc 16
+    @rust_buf.len = 0
+  end
+
+  def finalize
+    rbuf = @rust_buf
+
+    @rust_buf = nil
+
+    rbuf
+  end
+
+  def discard
+    return if @rust_buf.nil?
+
+    rbuf = finalize
+    rbuf.free
+  end
+
+  def write(value)
+    reserve(value.bytes.size) do
+      @rust_buf.data.put_array_of_char @rust_buf.len, value.bytes
+    end
+  end
+
+  def write_F64(v)
+    pack_into(8, 'G', v)
+  end
+
+  def write_Bool(v)
+    pack_into(1, 'c', v ? 1 : 0)
+  end
+
+  def write_String(v)
+    v = Proofmode::uniffi_utf8(v)
+    pack_into 4, 'l>', v.bytes.size
+    write v
+  end
+
+  def write_Bytes(v)
+    v = Proofmode::uniffi_bytes(v)
+    pack_into 4, 'l>', v.bytes.size
+    write v
+  end
+
+  # The Object type ProofModeCallbacks.
+
+  def write_TypeProofModeCallbacks(obj)
+    handle = ProofModeCallbacks.uniffi_lower obj
+    pack_into(8, 'Q>', handle)
+  end
+
+  # The Record type CellInfo.
+
+  def write_TypeCellInfo(v)
+    self.write_String(v.carrier)
+    self.write_Optionalstring(v.cell_id)
+    self.write_Optionalstring(v.lac)
+  end
+
+  # The Record type DeviceData.
+
+  def write_TypeDeviceData(v)
+    self.write_String(v.manufacturer)
+    self.write_String(v.model)
+    self.write_String(v.os_version)
+    self.write_Optionalstring(v.device_id)
+  end
+
+  # The Record type LocationData.
+
+  def write_TypeLocationData(v)
+    self.write_F64(v.latitude)
+    self.write_F64(v.longitude)
+    self.write_Optionalf64(v.altitude)
+    self.write_Optionalf64(v.accuracy)
+    self.write_Optionalstring(v.provider)
+  end
+
+  # The Record type NetworkData.
+
+  def write_TypeNetworkData(v)
+    self.write_String(v.network_type)
+    self.write_Optionalstring(v.wifi_ssid)
+    self.write_OptionalTypeCellInfo(v.cell_info)
+  end
+
+  # The Record type ProofModeConfig.
+
+  def write_TypeProofModeConfig(v)
+    self.write_Bool(v.auto_notarize)
+    self.write_Bool(v.track_location)
+    self.write_Bool(v.track_device_id)
+    self.write_Bool(v.track_network)
+    self.write_Bool(v.add_credentials)
+  end
+
+  
+
+  # The Optional<T> type for f64.
+
+  def write_Optionalf64(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_F64(v)
+    end
+  end
+
+  # The Optional<T> type for string.
+
+  def write_Optionalstring(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_String(v)
+    end
+  end
+
+  # The Optional<T> type for bytes.
+
+  def write_Optionalbytes(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_Bytes(v)
+    end
+  end
+
+  # The Optional<T> type for TypeCellInfo.
+
+  def write_OptionalTypeCellInfo(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_TypeCellInfo(v)
+    end
+  end
+
+  # The Optional<T> type for TypeDeviceData.
+
+  def write_OptionalTypeDeviceData(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_TypeDeviceData(v)
+    end
+  end
+
+  # The Optional<T> type for TypeLocationData.
+
+  def write_OptionalTypeLocationData(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_TypeLocationData(v)
+    end
+  end
+
+  # The Optional<T> type for TypeNetworkData.
+
+  def write_OptionalTypeNetworkData(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_TypeNetworkData(v)
+    end
+  end
+
+  # The Sequence<T> type for string.
+
+  def write_Sequencestring(items)
+    pack_into(4, 'l>', items.size)
+
+    items.each do |item|
+      self.write_String(item)
+    end
+  end
+
+  # The Map<T> type for string.
+
+  def write_MapStringString(items)
+    pack_into(4, 'l>', items.size)
+
+    items.each do |k, v|
+      write_String(k)
+      self.write_String(v)
+    end
+  end
+
+  private
+
+  def reserve(num_bytes)
+    if @rust_buf.len + num_bytes > @rust_buf.capacity
+      @rust_buf = RustBuffer.reserve(@rust_buf, num_bytes)
+    end
+
+    yield
+
+    @rust_buf.len += num_bytes
+  end
+
+  def pack_into(size, format, value)
+    reserve(size) do
+      @rust_buf.data.put_array_of_char @rust_buf.len, [value].pack(format).bytes
+    end
+  end
+end
+
+private_constant :RustBufferBuilder
+
+  # Error definitions
+  class RustCallStatus < FFI::Struct
+  layout :code,    :int8,
+         :error_buf, RustBuffer
+
+  def code
+    self[:code]
+  end
+
+  def error_buf
+    self[:error_buf]
+  end
+
+  def to_s
+    "RustCallStatus(code=#{self[:code]})"
+  end
+end
+
+# These match the values from the uniffi::rustcalls module
+CALL_SUCCESS = 0
+CALL_ERROR = 1
+CALL_PANIC = 2
+
+
+module ProofModeError
+  class Io < StandardError
+    def initialize(message)
+        @message = message
+        super()
+      end
+
+    attr_reader :message
+    
+
+    def to_s
+     "#{self.class.name}(message=#{@message.inspect})"
+    end
+  end
+  class Generation < StandardError
+    def initialize(message)
+        @message = message
+        super()
+      end
+
+    attr_reader :message
+    
+
+    def to_s
+     "#{self.class.name}(message=#{@message.inspect})"
+    end
+  end
+  class Check < StandardError
+    def initialize(message)
+        @message = message
+        super()
+      end
+
+    attr_reader :message
+    
+
+    def to_s
+     "#{self.class.name}(message=#{@message.inspect})"
+    end
+  end
+
+end
+
+
+# Map error modules to the RustBuffer method name that reads them
+ERROR_MODULE_TO_READER_METHOD = {
+
+  ProofModeError => :readTypeProofModeError,
+
+}
+
+private_constant :ERROR_MODULE_TO_READER_METHOD, :CALL_SUCCESS, :CALL_ERROR, :CALL_PANIC,
+                 :RustCallStatus
+
+def self.consume_buffer_into_error(error_module, rust_buffer)
+  rust_buffer.consumeWithStream do |stream|
+    reader_method = ERROR_MODULE_TO_READER_METHOD[error_module]
+    return stream.send(reader_method)
+  end
+end
+
+class InternalError < StandardError
+end
+
+def self.rust_call(fn_name, *args)
+  # Call a rust function
+  rust_call_with_error(nil, fn_name, *args)
+end
+
+def self.rust_call_with_error(error_module, fn_name, *args)
+  # Call a rust function and handle errors
+  #
+  # Use this when the rust function returns a Result<>.  error_module must be the error_module that corresponds to that Result.
+
+
+  # Note: RustCallStatus.new zeroes out the struct, which is exactly what we
+  # want to pass to Rust (code=0, error_buf=RustBuffer(len=0, capacity=0,
+  # data=NULL))
+  status = RustCallStatus.new
+  args << status
+
+  result = UniFFILib.public_send(fn_name, *args)
+
+  case status.code
+  when CALL_SUCCESS
+    result
+  when CALL_ERROR
+    if error_module.nil?
+      status.error_buf.free
+      raise InternalError, "CALL_ERROR with no error_module set"
+    else
+      raise consume_buffer_into_error(error_module, status.error_buf)
+    end
+  when CALL_PANIC
+    # When the rust code sees a panic, it tries to construct a RustBuffer
+    # with the message.  But if that code panics, then it just sends back
+    # an empty buffer.
+    if status.error_buf.len > 0
+      raise InternalError, status.error_buf.consumeIntoString()
+    else
+      raise InternalError, "Rust panic"
+    end
+  else
+    raise InternalError, "Unknown call status: #{status.code}"
+  end
+end
+
+private_class_method :consume_buffer_into_error
+
+  # This is how we find and load the dynamic library provided by the component.
+# For now we just look it up by name.
+module UniFFILib
+  extend FFI::Library
+
+  
+  ffi_lib 'proofmode'
+  
+
+  attach_function :uniffi_proofmode_fn_clone_proofmodecallbacks,
+    [:uint64, RustCallStatus.by_ref],
+    :uint64
+  attach_function :uniffi_proofmode_fn_free_proofmodecallbacks,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  attach_function :uniffi_proofmode_fn_init_callback_vtable_proofmodecallbacks,
+    [:pointer, RustCallStatus.by_ref],
+    :void
+  attach_function :uniffi_proofmode_fn_method_proofmodecallbacks_get_location,
+    [:uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :uniffi_proofmode_fn_method_proofmodecallbacks_get_device_info,
+    [:uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :uniffi_proofmode_fn_method_proofmodecallbacks_get_network_info,
+    [:uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :uniffi_proofmode_fn_method_proofmodecallbacks_save_data,
+    [:uint64, RustBuffer.by_value, RustBuffer.by_value, RustBuffer.by_value, RustCallStatus.by_ref],
+    :int8
+  attach_function :uniffi_proofmode_fn_method_proofmodecallbacks_save_text,
+    [:uint64, RustBuffer.by_value, RustBuffer.by_value, RustBuffer.by_value, RustCallStatus.by_ref],
+    :int8
+  attach_function :uniffi_proofmode_fn_method_proofmodecallbacks_sign_data,
+    [:uint64, RustBuffer.by_value, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :uniffi_proofmode_fn_method_proofmodecallbacks_report_progress,
+    [:uint64, RustBuffer.by_value, RustCallStatus.by_ref],
+    :void
+  attach_function :uniffi_proofmode_fn_func_check_files,
+    [RustBuffer.by_value, :uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :uniffi_proofmode_fn_func_generate_proof,
+    [RustBuffer.by_value, RustBuffer.by_value, RustBuffer.by_value, :uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :uniffi_proofmode_fn_func_get_file_hash,
+    [RustBuffer.by_value, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :uniffi_proofmode_fn_func_get_version,
+    [RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :ffi_proofmode_rustbuffer_alloc,
+    [:uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :ffi_proofmode_rustbuffer_from_bytes,
+    [ForeignBytes, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :ffi_proofmode_rustbuffer_free,
+    [RustBuffer.by_value, RustCallStatus.by_ref],
+    :void
+  attach_function :ffi_proofmode_rustbuffer_reserve,
+    [RustBuffer.by_value, :uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :uniffi_proofmode_checksum_func_check_files,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_proofmode_checksum_func_generate_proof,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_proofmode_checksum_func_get_file_hash,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_proofmode_checksum_func_get_version,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_proofmode_checksum_method_proofmodecallbacks_get_location,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_proofmode_checksum_method_proofmodecallbacks_get_device_info,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_proofmode_checksum_method_proofmodecallbacks_get_network_info,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_proofmode_checksum_method_proofmodecallbacks_save_data,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_proofmode_checksum_method_proofmodecallbacks_save_text,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_proofmode_checksum_method_proofmodecallbacks_sign_data,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_proofmode_checksum_method_proofmodecallbacks_report_progress,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :ffi_proofmode_uniffi_contract_version,
+    [RustCallStatus.by_ref],
+    :uint32
+  
+end
+
+  # Public interface members begin here.
+
+  
+  
+  # Record type CellInfo
+class CellInfo
+  attr_reader :carrier, :cell_id, :lac
+
+  def initialize(carrier:, cell_id:, lac:)
+    @carrier = carrier
+    @cell_id = cell_id
+    @lac = lac
+  end
+
+  def ==(other)
+    if @carrier != other.carrier
+      return false
+    end
+    if @cell_id != other.cell_id
+      return false
+    end
+    if @lac != other.lac
+      return false
+    end
+
+    true
+  end
+end
+  
+  # Record type DeviceData
+class DeviceData
+  attr_reader :manufacturer, :model, :os_version, :device_id
+
+  def initialize(manufacturer:, model:, os_version:, device_id:)
+    @manufacturer = manufacturer
+    @model = model
+    @os_version = os_version
+    @device_id = device_id
+  end
+
+  def ==(other)
+    if @manufacturer != other.manufacturer
+      return false
+    end
+    if @model != other.model
+      return false
+    end
+    if @os_version != other.os_version
+      return false
+    end
+    if @device_id != other.device_id
+      return false
+    end
+
+    true
+  end
+end
+  
+  # Record type LocationData
+class LocationData
+  attr_reader :latitude, :longitude, :altitude, :accuracy, :provider
+
+  def initialize(latitude:, longitude:, altitude:, accuracy:, provider:)
+    @latitude = latitude
+    @longitude = longitude
+    @altitude = altitude
+    @accuracy = accuracy
+    @provider = provider
+  end
+
+  def ==(other)
+    if @latitude != other.latitude
+      return false
+    end
+    if @longitude != other.longitude
+      return false
+    end
+    if @altitude != other.altitude
+      return false
+    end
+    if @accuracy != other.accuracy
+      return false
+    end
+    if @provider != other.provider
+      return false
+    end
+
+    true
+  end
+end
+  
+  # Record type NetworkData
+class NetworkData
+  attr_reader :network_type, :wifi_ssid, :cell_info
+
+  def initialize(network_type:, wifi_ssid:, cell_info:)
+    @network_type = network_type
+    @wifi_ssid = wifi_ssid
+    @cell_info = cell_info
+  end
+
+  def ==(other)
+    if @network_type != other.network_type
+      return false
+    end
+    if @wifi_ssid != other.wifi_ssid
+      return false
+    end
+    if @cell_info != other.cell_info
+      return false
+    end
+
+    true
+  end
+end
+  
+  # Record type ProofModeConfig
+class ProofModeConfig
+  attr_reader :auto_notarize, :track_location, :track_device_id, :track_network, :add_credentials
+
+  def initialize(auto_notarize:, track_location:, track_device_id:, track_network:, add_credentials:)
+    @auto_notarize = auto_notarize
+    @track_location = track_location
+    @track_device_id = track_device_id
+    @track_network = track_network
+    @add_credentials = add_credentials
+  end
+
+  def ==(other)
+    if @auto_notarize != other.auto_notarize
+      return false
+    end
+    if @track_location != other.track_location
+      return false
+    end
+    if @track_device_id != other.track_device_id
+      return false
+    end
+    if @track_network != other.track_network
+      return false
+    end
+    if @add_credentials != other.add_credentials
+      return false
+    end
+
+    true
+  end
+end
+  
+
+  
+  
+
+def self.check_files(file_paths, callbacks)
+    file_paths = file_paths.map { |v| Proofmode::uniffi_utf8(v) }
+    RustBuffer.check_lower_Sequencestring(file_paths)
+    
+    callbacks = callbacks
+    (ProofModeCallbacks.uniffi_check_lower callbacks)
+    
+  result = Proofmode.rust_call_with_error(ProofModeError,:uniffi_proofmode_fn_func_check_files,RustBuffer.alloc_from_Sequencestring(file_paths),(ProofModeCallbacks.uniffi_lower callbacks))
+  return result.consumeIntoString
+end
+
+
+  
+  
+
+def self.generate_proof(media_data, metadata, config, callbacks)
+    media_data = Proofmode::uniffi_bytes(media_data)
+    
+    
+    metadata = metadata.each.with_object({}) { |(k, v), res| res[Proofmode::uniffi_utf8(k)] = Proofmode::uniffi_utf8(v) }
+    RustBuffer.check_lower_MapStringString(metadata)
+    
+    config = config
+    RustBuffer.check_lower_TypeProofModeConfig(config)
+    
+    callbacks = callbacks
+    (ProofModeCallbacks.uniffi_check_lower callbacks)
+    
+  result = Proofmode.rust_call_with_error(ProofModeError,:uniffi_proofmode_fn_func_generate_proof,RustBuffer.allocFromBytes(media_data),RustBuffer.alloc_from_MapStringString(metadata),RustBuffer.alloc_from_TypeProofModeConfig(config),(ProofModeCallbacks.uniffi_lower callbacks))
+  return result.consumeIntoString
+end
+
+
+  
+  
+
+def self.get_file_hash(media_data)
+    media_data = Proofmode::uniffi_bytes(media_data)
+    
+    
+  result = Proofmode.rust_call(:uniffi_proofmode_fn_func_get_file_hash,RustBuffer.allocFromBytes(media_data))
+  return result.consumeIntoString
+end
+
+
+  
+  
+
+def self.get_version()
+  result = Proofmode.rust_call(:uniffi_proofmode_fn_func_get_version,)
+  return result.consumeIntoString
+end
+
+
+  
+
+  
+  class ProofModeCallbacks
+
+  # A private helper for initializing instances of the class from a raw handle,
+  # bypassing any initialization logic and ensuring they are GC'd properly.
+  def self.uniffi_allocate(handle)
+    inst = allocate
+    inst.instance_variable_set :@handle, handle
+    ObjectSpace.define_finalizer(inst, uniffi_define_finalizer_by_handle(handle, inst.object_id))
+    return inst
+  end
+
+  # A private helper for registering an object finalizer.
+  # N.B. it's important that this does not capture a reference
+  # to the actual instance, only its underlying handle.
+  def self.uniffi_define_finalizer_by_handle(handle, object_id)
+    Proc.new do |_id|
+      Proofmode.rust_call(
+        :uniffi_proofmode_fn_free_proofmodecallbacks,
+        handle
+      )
+    end
+  end
+
+  # A private helper for lowering instances into a raw handle.
+  # This does an explicit typecheck, because accidentally lowering a different type of
+  # object in a place where this type is expected, could lead to memory unsafety.
+  def self.uniffi_check_lower(inst)
+    if not inst.is_a? self
+      raise TypeError.new "Expected a ProofModeCallbacks instance, got #{inst}"
+    end
+  end
+
+  def uniffi_clone_handle()
+    return Proofmode.rust_call(
+      :uniffi_proofmode_fn_clone_proofmodecallbacks,
+      @handle
+    )
+  end
+
+  def self.uniffi_lower(inst)
+    return inst.uniffi_clone_handle()
+  end
+
+  
+
+  def get_location()
+    result = Proofmode.rust_call(:uniffi_proofmode_fn_method_proofmodecallbacks_get_location,uniffi_clone_handle(),)
+    return result.consumeIntoOptionalTypeLocationData
+  end
+  def get_device_info()
+    result = Proofmode.rust_call(:uniffi_proofmode_fn_method_proofmodecallbacks_get_device_info,uniffi_clone_handle(),)
+    return result.consumeIntoOptionalTypeDeviceData
+  end
+  def get_network_info()
+    result = Proofmode.rust_call(:uniffi_proofmode_fn_method_proofmodecallbacks_get_network_info,uniffi_clone_handle(),)
+    return result.consumeIntoOptionalTypeNetworkData
+  end
+  def save_data(hash, filename, data)
+        hash = Proofmode::uniffi_utf8(hash)
+        
+        filename = Proofmode::uniffi_utf8(filename)
+        
+        data = Proofmode::uniffi_bytes(data)
+        
+    result = Proofmode.rust_call(:uniffi_proofmode_fn_method_proofmodecallbacks_save_data,uniffi_clone_handle(),RustBuffer.allocFromString(hash),RustBuffer.allocFromString(filename),RustBuffer.allocFromBytes(data))
+    return 1 == result
+  end
+  def save_text(hash, filename, text)
+        hash = Proofmode::uniffi_utf8(hash)
+        
+        filename = Proofmode::uniffi_utf8(filename)
+        
+        text = Proofmode::uniffi_utf8(text)
+        
+    result = Proofmode.rust_call(:uniffi_proofmode_fn_method_proofmodecallbacks_save_text,uniffi_clone_handle(),RustBuffer.allocFromString(hash),RustBuffer.allocFromString(filename),RustBuffer.allocFromString(text))
+    return 1 == result
+  end
+  def sign_data(data)
+        data = Proofmode::uniffi_bytes(data)
+        
+    result = Proofmode.rust_call(:uniffi_proofmode_fn_method_proofmodecallbacks_sign_data,uniffi_clone_handle(),RustBuffer.allocFromBytes(data))
+    return result.consumeIntoOptionalbytes
+  end
+  def report_progress(message)
+        message = Proofmode::uniffi_utf8(message)
+        
+      Proofmode.rust_call(:uniffi_proofmode_fn_method_proofmodecallbacks_report_progress,uniffi_clone_handle(),RustBuffer.allocFromString(message))
+  end
+  
+  
+end
+  
+end
+