confium 0.3.4-aarch64-linux → 0.5.0-aarch64-linux

data/README.adoc

@@ -10,7 +10,7 @@ Confium supports three deployment modes:
 * **Mode 2 — TC PKI replacement**: drop-in for existing PKI consumers (PKCS#11 server, OpenSSL 3.0 provider, JCE)
 * **Mode 3 — TC Certificate PKI**: institutional deployments with custom certificate formats (OIML CNML, BIPM, pharma, accreditation)
 
-This gem wraps the high-value Confium subsystems via a Rust native extension. Pre-compiled platform gems are published for Linux and macOS, so `gem install` needs no Rust toolchain there; other platforms build from source at install time with `rb_sys` + `magnus`. No separate C ABI library to install; everything is statically linked into the extension.
+This gem wraps the high-value Confium subsystems via a pure-Rust native extension (`rb_sys` + `magnus`, no C dependencies). Pre-compiled platform gems are published for Linux (glibc + musl), macOS, and Windows, so `gem install` needs no Rust toolchain there; other platforms build from source at install time.
 
 == Installation
 
@@ -32,17 +32,13 @@ $ gem install confium
 
 * Ruby ≥ 3.1
 * Nothing else on the pre-compiled platforms: `x86_64-linux`,
-  `aarch64-linux`, `x86_64-darwin`, `arm64-darwin` (each gem carries
-  one extension per Ruby C-ABI window)
+  `aarch64-linux`, `x86_64-linux-musl`, `aarch64-linux-musl`,
+  `x86_64-darwin`, `arm64-darwin`, `x64-mingw-ucrt` (each gem
+  carries one extension per Ruby C-ABI window)
 
 Source builds (other platforms, or installing from the repo) also
-need:
-
-* Rust stable toolchain (`rustup default stable`)
-* C toolchain (clang/gcc/Xcode CLT)
-
-There is no separate `libconfium` to install — the extension
-statically links everything.
+need the Rust stable toolchain (`rustup default stable`) — and
+nothing else: the extension has no C dependencies to satisfy.
 
 == Quick start
 

data/lib/confium/audit/otlp_sink.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'time'
+
+module Confium
+  module Audit
+    # Exports audit records to an OpenTelemetry Collector over
+    # OTLP/HTTP JSON (the logs signal — an audit event is a log
+    # record, not a span).
+    #
+    #   Confium::Audit.sink = Confium::Audit::OtlpSink.new(
+    #     endpoint: 'http://localhost:4318/v1/logs',
+    #     headers: { 'Authorization' => "Bearer #{token}" },
+    #     service_name: 'confium-issuer'
+    #   )
+    #
+    # Delivery is synchronous per record; failures are reported on
+    # $stderr and the record is dropped (the audit core's policy — a
+    # telemetry outage must never break signing). stdlib only.
+    class OtlpSink < Sink
+      DEFAULT_ENDPOINT = 'http://localhost:4318/v1/logs'
+      SEVERITY = { 'success' => 9, 'failure' => 17, 'error' => 17 }.freeze # INFO / ERROR
+
+      def initialize(endpoint: DEFAULT_ENDPOINT, headers: {}, service_name: 'confium', timeout: 5)
+        super()
+        @uri = URI.parse(endpoint)
+        @headers = headers
+        @service_name = service_name
+        @timeout = timeout
+        @dropped = 0
+      end
+
+      # Records dropped after failed delivery (diagnostic only).
+      attr_reader :dropped
+
+      def write(record)
+        payload = envelope(record)
+        response = Net::HTTP.post(@uri, JSON.generate(payload), headers.merge('Content-Type' => 'application/json'))
+        raise "collector responded #{response.code}" unless response.is_a?(Net::HTTPSuccess)
+      rescue StandardError => e
+        @dropped += 1
+        warn "confium: OTLP delivery failed, audit record dropped (##{@dropped}): #{e.class}: #{e.message}"
+      end
+
+      def close; end
+
+      private
+
+      def headers
+        { 'User-Agent' => "confium-otlp-sink #{Confium::VERSION}" }.merge(@headers)
+      end
+
+      # OTLP/JSON logs request: one resource, one scope, one record.
+      def envelope(record)
+        {
+          'resourceLogs' => [
+            {
+              'resource' => {
+                'attributes' => [
+                  { 'key' => 'service.name', 'value' => { 'stringValue' => @service_name } },
+                  { 'key' => 'telemetry.sdk.name', 'value' => { 'stringValue' => 'confium' } },
+                  { 'key' => 'telemetry.sdk.version', 'value' => { 'stringValue' => Confium::VERSION } }
+                ]
+              },
+              'scopeLogs' => [
+                {
+                  'scope' => { 'name' => 'confium.audit' },
+                  'logRecords' => [log_record(record)]
+                }
+              ]
+            }
+          ]
+        }
+      end
+
+      def log_record(record)
+        {
+          'timeUnixNano' => (parse_time(record['timestamp']) * 1_000_000_000).to_i.to_s,
+          'severityNumber' => SEVERITY.fetch(record['result'], 9),
+          'severityText' => record['result'] == 'success' ? 'INFO' : 'ERROR',
+          'body' => { 'stringValue' => "#{record['operation']} #{record['result']}".strip },
+          'attributes' => attributes_for(record)
+        }
+      end
+
+      def attributes_for(record)
+        record.except('timestamp').map do |key, value|
+          { 'key' => key, 'value' => { 'stringValue' => value.to_s } }
+        end
+      end
+
+      def parse_time(timestamp)
+        return Time.now.to_f unless timestamp.is_a?(String)
+
+        Time.parse(timestamp).to_f
+      rescue ArgumentError
+        Time.now.to_f
+      end
+    end
+  end
+end

data/lib/confium/audit.rb

@@ -124,3 +124,5 @@ module Confium
     end
   end
 end
+
+require_relative 'audit/otlp_sink'

data/lib/confium/composite.rb

@@ -16,6 +16,32 @@ module Confium
     class Signature
       BINARY_FIELDS = %w[public_key signature].freeze
 
+      # Serialize the components this instance was built from, in the
+      # canonical wire format. Instances remember their source: built
+      # from components, or from a JSON document (which is emitted
+      # verbatim when it was canonical).
+      def to_json(*_args)
+        cached = @confium_components_json
+        return cached if cached
+
+        components = @confium_components or
+          raise Confium::Error, 'Signature was not built with component data; use Signature.new or from_json'
+        Signature.components_to_json(components)
+      end
+
+      class << self
+        # magnus exposes the constructor as a class-level `new`;
+        # capture it before this reopen shadows it (plain `super`
+        # falls through to Class#new instead).
+        alias __native_new new
+
+        def new(*args)
+          sig = __native_new(*args)
+          sig.instance_variable_set(:@confium_components, args.first) if args.first.is_a?(Array)
+          sig
+        end
+      end
+
       def self.components_to_json(components)
         JSON.generate(components.map do |component|
           component.transform_values do |value|
@@ -35,7 +61,19 @@ module Confium
           raise ArgumentError, 'expected a non-empty "components" array'
         end
 
-        new(components.map { |c| decode_binary_fields(c) })
+        sig = new(components.map { |c| decode_binary_fields(c) })
+        sig.instance_variable_set(:@confium_components, components)
+        sig.instance_variable_set(:@confium_components_json, canonical_json(json, data))
+        sig
+      end
+
+      # The canonical wire form of whatever the caller handed us: a
+      # String passes through untouched; parsed structures are
+      # re-generated from their components array.
+      def self.canonical_json(json, data)
+        return json if json.is_a?(String)
+
+        JSON.generate(data.is_a?(Hash) ? data['components'] : data)
       end
 
       def self.decode_binary_fields(component)

data/lib/confium/openpgp.rb

@@ -1,33 +1,155 @@
 # frozen_string_literal: true
 
-# Confium::OpenPGP — OpenPGP (RFC 9580) via bundled rnp-rs.
-#
-# The native extension provides _native_armor / _native_dearmor.
-# This file adds the idiomatic Ruby wrappers with default args.
-#
-# Architecture: RNP is HARD-BUNDLED in the native extension. No
-# external gem dependency. Users get OpenPGP armor encode/decode
-# out of the box.
-
 module Confium
+  # OpenPGP ASCII armor (RFC 9580 §6) — Radix-64 framing with a
+  # CRC-24 checksum, implemented in pure Ruby.
+  #
+  # This replaced the earlier native wrapper around librnp, which
+  # pulled a full vendored Botan/json-c C/C++ build into every
+  # install just to do armor framing. The wire format is unchanged;
+  # spec/fixtures/openpgp_armor_vectors.json holds differential
+  # vectors captured from the native implementation.
   module OpenPGP
+    MESSAGE = 'message'
+    PUBLIC_KEY = 'public key'
+    SECRET_KEY = 'secret key'
+    SIGNATURE = 'signature'
+    CLEARTEXT = 'cleartext signed message'
+
+    LABELS = {
+      nil => 'MESSAGE',
+      MESSAGE => 'MESSAGE',
+      'public key' => 'PUBLIC KEY BLOCK',
+      SECRET_KEY => 'PRIVATE KEY BLOCK',
+      'private key' => 'PRIVATE KEY BLOCK',
+      SIGNATURE => 'SIGNATURE',
+      # Raw bytes cannot form a cleartext-signed message (that
+      # requires a signature packet); armor them as a plain message.
+      CLEARTEXT => 'MESSAGE',
+      'cleartext' => 'MESSAGE'
+    }.freeze
+
+    CRC_POLY = 0x1864CFB
+    CRC_INIT = 0xB704CE
+    B64_CHARS = [('A'..'Z').to_a, ('a'..'z').to_a, ('0'..'9').to_a, %w[+ /]].flatten.freeze
+    CRC_TABLE = (0..255).map do |i|
+      c = i << 16
+      8.times do
+        c = c.nobits?(0x800_000) ? c << 1 : ((c << 1) ^ CRC_POLY)
+        c &= 0xFFFFFF
+      end
+      c
+    end.freeze
+
+    private_constant :LABELS, :CRC_POLY, :CRC_INIT, :B64_CHARS, :CRC_TABLE
+
     class << self
-      # ASCII-armor encode raw bytes.
+      # ASCII-armor encode raw bytes. Output uses CRLF line endings
+      # and 76-character data lines, byte-for-byte matching the
+      # earlier native (rnp) implementation.
       #
       # @param data [String] Binary data to encode.
-      # @param type [String] Armor type — one of MESSAGE, PUBLIC_KEY,
-      #   SECRET_KEY, SIGNATURE, CLEARTEXT. Defaults to MESSAGE.
+      # @param type [String] One of MESSAGE, PUBLIC_KEY, SECRET_KEY,
+      #   SIGNATURE, CLEARTEXT (armored as a plain message). Defaults
+      #   to MESSAGE.
       # @return [String] Armored ASCII string.
+      # @raise [ArgumentError] if +type+ is not a known armor type.
       def armor(data, type = MESSAGE)
-        _native_armor(data, type)
+        label = LABELS[type]
+        raise ArgumentError, "unknown armor type: #{type.inspect}" unless label
+
+        bytes = data.to_s.b
+        b64 = [bytes].pack('m0')
+        lines = b64.scan(/.{1,76}/)
+        <<~ARMOR.gsub("\n", "\r\n")
+          -----BEGIN PGP #{label}-----
+
+          #{lines.join("\n")}
+          =#{crc24_armor(bytes)}
+          -----END PGP #{label}-----
+        ARMOR
       end
 
-      # Decode ASCII-armored data to raw bytes.
+      # Decode ASCII-armored data to raw bytes. Accepts LF or CRLF
+      # line endings, arbitrary line widths, and Armor Headers
+      # (Comment:, Version:, ...) between the BEGIN line and the
+      # blank line. The CRC-24 checksum line is verified when
+      # present.
       #
       # @param data [String] Armored ASCII string.
-      # @return [String] Raw binary data.
+      # @return [String] Raw binary data (ASCII-8BIT).
+      # @raise [Confium::ParseError] on missing delimiters, non-base64
+      #   content, or a CRC mismatch.
       def dearmor(data)
-        _native_dearmor(data)
+        b64, crc_line = extract_body(data.to_s)
+        # @type var bytes: String
+        bytes = b64.unpack1('m0')
+        return ''.b if crc_line == crc24_armor(''.b) && b64.empty?
+
+        raise ParseError, 'armor CRC-24 checksum mismatch' if crc_line && crc24_armor(bytes) != crc_line.to_s
+
+        bytes
+      end
+
+      private
+
+      # Locate the armored block, skip the BEGIN line and any Armor
+      # Headers, and split the remaining lines into the joined
+      # Radix-64 data and the checksum line (if present).
+      def extract_body(text)
+        lines = block_lines(text)
+        b64, crc_line = collect_data(lines)
+        raise ParseError, 'armored block has no data' if b64.empty? && crc_line.nil?
+
+        [b64, crc_line]
+      end
+
+      # The lines of the armored block between BEGIN and END, with
+      # the BEGIN line and any Armor Headers removed.
+      def block_lines(text)
+        slice = block_slice(text.gsub("\r\n", "\n"))
+        lines = slice.split("\n")
+        lines.shift # BEGIN
+        lines.shift while lines.first&.match?(/^\s|^[A-Za-z0-9-]+: /)
+        lines.shift if lines.first == ''
+        lines
+      end
+
+      # The text between the BEGIN and END delimiter lines.
+      def block_slice(normalized)
+        begin_line = normalized.index(/^-----BEGIN PGP [A-Z ]+-----$/)
+        raise ParseError, 'not an ASCII-armored block (no BEGIN line)' unless begin_line
+
+        end_match = normalized.match(/^-----END PGP [A-Z ]+-----$/)
+        raise ParseError, 'not an ASCII-armored block (no END line)' unless end_match
+
+        normalized[begin_line...end_match.begin(0)].to_s
+      end
+
+      def collect_data(lines)
+        b64 = +''
+        crc_line = nil
+        lines.each do |line|
+          next if line.empty?
+
+          if line.start_with?('=')
+            crc_line = line[1..]
+          elsif line.match?(%r{\A[A-Za-z0-9+/]+={0,2}\z})
+            b64 << line
+          else
+            raise ParseError, "invalid armor data line: #{line[0, 20].inspect}"
+          end
+        end
+        [b64, crc_line]
+      end
+
+      # CRC-24 (RFC 9580 §6.1), encoded as the four Radix-64
+      # characters of the 24-bit value as three big-endian bytes.
+      def crc24_armor(bytes)
+        crc = CRC_INIT
+        bytes.each_byte { |b| crc = ((crc << 8) & 0xFFFFFF) ^ CRC_TABLE[((crc >> 16) ^ b) & 0xFF] }
+        three_bytes = [crc >> 16, (crc >> 8) & 0xFF, crc & 0xFF].pack('C3')
+        [three_bytes].pack('m0')
       end
     end
   end

data/lib/confium/tc/coordinator.rb

@@ -1,15 +1,17 @@
 # frozen_string_literal: true
 
-# Confium::TC::Coordinator wraps the async session coordinator service.
-#
-# The coordinator enables globally distributed threshold signers to
-# participate when convenient — no simultaneity required.
+# Confium::TC::Coordinator coordinates an in-process threshold
+# signing session: signers submit commitments and shares at their own
+# pace; once the threshold is met, aggregation runs the real
+# threshold-ECDSA combine (CMP20 or GG18 — the same in-process
+# drivers behind Confium::TC::Cmp20 / Confium::TC::Gg18) and returns
+# a 64-byte (r, s) signature verifiable under the quorum public key.
 #
 # Usage:
 #   coordinator = Confium::TC::Coordinator.new(quorum_id: "biml-root")
 #   session_id = coordinator.create_session(message: data,
-#                                           threshold: 5,
-#                                           unlock_window: 14400)
+#                                           threshold: 3,
+#                                           scheme: "CMP20-ECDSA-P256")
 #   coordinator.submit_commitment(session_id, signer_id, commitment_bytes)
 #   # ... wait for T commitments ...
 #   coordinator.submit_share(session_id, signer_id, share_bytes)
@@ -25,12 +27,20 @@ module Confium
         @sessions = {}
       end
 
-      def create_session(message:, threshold:, unlock_window: 14_400)
+      SCHEMES = {
+        'CMP20-ECDSA-P256' => ->(shares, threshold, message) { Cmp20.sign(shares, threshold, message) },
+        'GG18-ECDSA-P256' => ->(shares, threshold, message) { Gg18.sign(shares, threshold, message) }
+      }.freeze
+
+      def create_session(message:, threshold:, unlock_window: 14_400, scheme: 'CMP20-ECDSA-P256')
+        raise ArgumentError, "unknown scheme: #{scheme} (known: #{SCHEMES.keys.join(', ')})" unless SCHEMES.key?(scheme)
+
         session_id = "session-#{@sessions.length + 1}"
         @sessions[session_id] = {
           message: message,
           threshold: threshold,
           unlock_window: unlock_window,
+          scheme: scheme,
           state: :pending,
           commitments: [],
           shares: []
@@ -57,11 +67,14 @@ module Confium
 
       def aggregate(session_id)
         session = @sessions[session_id] or raise "Unknown session: #{session_id}"
-        raise 'Threshold not met' if session[:shares].length < session[:threshold]
+        raise ThresholdError, 'Threshold not met' if session[:shares].length < session[:threshold]
 
         session[:state] = :completed
-        # In real implementation, calls FFI to aggregate shares
-        session[:shares].map { |s| s[:bytes] }.join
+        SCHEMES.fetch(session[:scheme]).call(
+          session[:shares].map { |s| s[:bytes] },
+          session[:threshold],
+          session[:message]
+        )
       end
     end
   end

data/lib/confium/tc/network_coordinator.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'socket'
+require_relative 'coordinator'
+
+module Confium
+  module TC
+    # Networked threshold-signing coordinator service.
+    #
+    # Wraps Confium::TC::Coordinator (real CMP20/GG18 combine) behind
+    # a TCP socket so signers on separate machines submit commitments
+    # and shares from their own processes:
+    #
+    #   service = Confium::TC::NetworkCoordinator.new(quorum_id: 'root')
+    #   service.start                       # binds 127.0.0.1:<ephemeral>
+    #   client = Confium::TC::SignerClient.new(port: service.port)
+    #   sid = client.create_session(message: data, threshold: 3)
+    #   client.submit_share(sid, 'signer-1', share_blob)
+    #   client.aggregate(sid)               # => 64-byte signature
+    #
+    # Protocol: one JSON object per line (NDJSON); binary fields are
+    # hex-encoded. Unknown operations and Coordinator errors come
+    # back as {"error": ..., "message": ...} lines.
+    #
+    # Transport security: none yet — plain TCP intended for loopback
+    # or private networks. The upstream noise-transport session
+    # protocol replaces this wholesale (see
+    # TODO.full/01-multi-host-threshold-signing.md).
+    class NetworkCoordinator
+      HANDLERS = {
+        'create' => lambda do |coord, req|
+          session_id = coord.create_session(
+            message: [req.fetch('message_hex')].pack('H*'),
+            threshold: req.fetch('threshold'),
+            scheme: req['scheme'] || 'CMP20-ECDSA-P256'
+          )
+          { 'session_id' => session_id }
+        end,
+        'commitment' => lambda do |coord, req|
+          session_id = req.fetch('session_id')
+          coord.submit_commitment(
+            session_id, req.fetch('signer_id'),
+            [req.fetch('bytes_hex')].pack('H*')
+          )
+          { 'ok' => true, 'state' => coord.session_state(session_id).to_s }
+        end,
+        'share' => lambda do |coord, req|
+          coord.submit_share(
+            req.fetch('session_id'), req.fetch('signer_id'),
+            [req.fetch('bytes_hex')].pack('H*')
+          )
+          { 'ok' => true }
+        end,
+        'aggregate' => lambda do |coord, req|
+          signature = coord.aggregate(req.fetch('session_id'))
+          { 'signature_hex' => signature.unpack1('H*') }
+        end
+      }.freeze
+
+      class RequestError < StandardError; end
+
+      attr_reader :quorum_id, :port
+
+      def initialize(quorum_id:, host: '127.0.0.1', port: 0, coordinator: nil)
+        @quorum_id = quorum_id
+        @host = host
+        @port = port
+        @coordinator = coordinator || Coordinator.new(quorum_id: quorum_id)
+        @server = nil
+        @accept_thread = nil
+        @mutex = Mutex.new
+      end
+
+      def start
+        raise 'already started' if @server
+
+        # RBS socket lib lacks the (host, port) overload for new
+        @server = TCPServer.new(@host.to_s, @port) # steep:ignore
+        @port = @server.addr[1]
+        @accept_thread = Thread.new { accept_loop }
+        self
+      end
+
+      def stop
+        return unless @server
+
+        server = @server
+        @server = nil
+        server.close
+        @accept_thread&.join(5)
+        nil
+      end
+
+      def running?
+        !@server.nil?
+      end
+
+      private
+
+      def accept_loop
+        loop do
+          server = @server
+          break unless server
+
+          begin
+            socket = server.accept
+          rescue IOError, Errno::EBADF, Errno::EINVAL
+            break # listener closed by #stop
+          end
+          Thread.new(socket) { |conn| serve(conn) }
+        end
+      end
+
+      def serve(socket)
+        socket.each_line do |line|
+          request = JSON.parse(line)
+          response = @mutex.synchronize { dispatch(request) }
+          socket.write("#{JSON.generate(response)}\n")
+        end
+      rescue JSON::ParserError => e
+        write_error(socket, 'RequestError', "malformed JSON: #{e.message}")
+      rescue StandardError => e
+        write_error(socket, e.class.name, e.message)
+      ensure
+        socket.close
+      end
+
+      def dispatch(request)
+        op = request['op'] or raise RequestError, 'missing "op"'
+        handler = HANDLERS[op] or raise RequestError, "unknown op: #{op}"
+
+        handler.call(@coordinator, request)
+      end
+
+      def write_error(socket, klass, message)
+        socket.write("#{JSON.generate({ 'error' => klass, 'message' => message })}\n")
+      rescue IOError
+        nil
+      end
+    end
+
+    # Client side for NetworkCoordinator. One instance per signer
+    # process; each call opens its own connection, so signers never
+    # share state.
+    class SignerClient
+      class RemoteError < StandardError
+        attr_reader :remote_class
+
+        def initialize(remote_class, message)
+          @remote_class = remote_class
+          super("#{remote_class}: #{message}")
+        end
+      end
+
+      def initialize(port:, host: '127.0.0.1')
+        @host = host
+        @port = port
+      end
+
+      def create_session(message:, threshold:, scheme: 'CMP20-ECDSA-P256')
+        response = call(
+          'op' => 'create',
+          'message_hex' => message.to_s.unpack1('H*'),
+          'threshold' => threshold,
+          'scheme' => scheme
+        )
+        response.fetch('session_id')
+      end
+
+      def submit_commitment(session_id, signer_id, commitment_bytes)
+        call(
+          'op' => 'commitment',
+          'session_id' => session_id,
+          'signer_id' => signer_id,
+          'bytes_hex' => commitment_bytes.unpack1('H*')
+        ).fetch('ok')
+      end
+
+      def submit_share(session_id, signer_id, share_bytes)
+        call(
+          'op' => 'share',
+          'session_id' => session_id,
+          'signer_id' => signer_id,
+          'bytes_hex' => share_bytes.unpack1('H*')
+        ).fetch('ok')
+      end
+
+      def aggregate(session_id)
+        response = call('op' => 'aggregate', 'session_id' => session_id)
+        [response.fetch('signature_hex')].pack('H*')
+      end
+
+      private
+
+      def call(request)
+        TCPSocket.open(@host, @port) do |socket|
+          socket.write("#{JSON.generate(request)}\n")
+          line = socket.readline
+          response = JSON.parse(line)
+          raise RemoteError.new(response['error'], response['message']) if response['error']
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/confium/tc.rb

@@ -11,7 +11,14 @@
 # for the full interface specification.
 module Confium
   module TC
+    # The native extension defines Confium::TC; this namespace file is
+    # eager-required from confium.rb, so autoloads registered here do
+    # fire. Coordinator and ShareFile are pure Ruby and load with the
+    # namespace; Session wraps the engine via FFI and needs the
+    # external libconfium dylib, so it stays lazy.
     autoload :Session, 'confium/tc/session'
-    autoload :Coordinator, 'confium/tc/coordinator'
+    require_relative 'tc/coordinator'
+    require_relative 'tc/network_coordinator'
+    require_relative 'tc/share_file'
   end
 end

data/lib/confium/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Confium
-  VERSION = '0.3.4'
+  VERSION = '0.5.0'
 end