@derec-alliance/react-native 0.0.5 → 0.0.7

package/lib/types.js

@@ -2,11 +2,14 @@
 // SPDX-License-Identifier: Apache-2.0
 // Copyright (c) 2026 DeRec Alliance. All rights reserved.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FlowKind = exports.ContactMode = exports.SenderKind = void 0;
+exports.StatusEnum = exports.FlowKind = exports.ContactMode = exports.SenderKind = void 0;
 exports.channelFilterMatches = channelFilterMatches;
 exports.advertisedEndpoints = advertisedEndpoints;
+exports.protocol_version = protocol_version;
+exports.generate_replica_id = generate_replica_id;
 exports.sequentialFailover = sequentialFailover;
 exports.singleEndpointTransport = singleEndpointTransport;
+const native_1 = require("./native");
 /**
  * Whether a channel or member with these attributes survives `filter`.
  *
@@ -37,13 +40,6 @@ function channelFilterMatches(filter, id, status, role) {
 /**
  * The endpoints a peer-supplied message advertises, in the peer's own order.
  *
- * Yields `supported_transports` when it is non-empty, and otherwise the
- * singular `transport_protocol` — which is how every implementation predating
- * the offer list advertises, and the reason this is a function rather than a
- * field read. Reading `transport_protocol` directly is a bug: its meaning
- * narrowed to "one entry of a list, and possibly absent", so a peer that has
- * moved past it looks unreachable to a reader that was correct before 0.0.3.
- *
  * Reports what was advertised, not what is acceptable — nothing here is
  * validated, and the protocol still applies its own transport policy to
  * whatever it records.
@@ -51,10 +47,23 @@ function channelFilterMatches(filter, id, status, role) {
 function advertisedEndpoints(message) {
     if (!message)
         return [];
-    const offers = message.supported_transports ?? [];
-    if (offers.length > 0)
-        return offers;
-    return message.transport_protocol ? [message.transport_protocol] : [];
+    return message.supported_transports ?? [];
+}
+/**
+ * The DeRec protocol version this build speaks — the `protocolVersionMajor` /
+ * `protocolVersionMinor` it writes into every envelope it produces. Not the
+ * package version.
+ */
+function protocol_version() {
+    return (0, native_1.getNative)().version();
+}
+/**
+ * A fresh, random replica id — never `0`. Generate it once per device,
+ * persist it, and pass the same value to
+ * `DeRecProtocolBuilder.withReplicaId` on every init.
+ */
+function generate_replica_id() {
+    return (0, native_1.getNative)().generate_replica_id();
 }
 /**
  * Builds a {@link Transport} that tries each endpoint in the order the peer
@@ -126,7 +135,7 @@ var SenderKind;
  *   the scanner must fetch the actual keys over the wire via the `PrePair`
  *   round-trip and verify them against the commitment before pairing.
  * - `NoKeys`: no key material and no commitment. The contact carries only
- *   `channel_id`, `nonce`, and `transport_protocol` — small enough to be
+ *   `channel_id`, `nonce`, and `supported_transports` — small enough to be
  *   hand-typed or dictated. Keys are generated on the fly by the contact
  *   creator when the `PrePairRequest` arrives; the scanner accepts them
  *   without cryptographic verification. Trust rests entirely on the OOB
@@ -168,3 +177,24 @@ var FlowKind;
      *  string so ids above 2^53 survive JS number handling. */
     FlowKind[FlowKind["UnpairReplica"] = 8] = "UnpairReplica";
 })(FlowKind || (exports.FlowKind = FlowKind = {}));
+/** Result status carried in every protocol response (`result.proto`). Passed
+ *  to `reject()` to say why an inbound request was refused. */
+var StatusEnum;
+(function (StatusEnum) {
+    StatusEnum[StatusEnum["Ok"] = 0] = "Ok";
+    StatusEnum[StatusEnum["Partial"] = 1] = "Partial";
+    StatusEnum[StatusEnum["Fail"] = 2] = "Fail";
+    StatusEnum[StatusEnum["SizeLimitExceeded"] = 3] = "SizeLimitExceeded";
+    StatusEnum[StatusEnum["TooFrequent"] = 4] = "TooFrequent";
+    StatusEnum[StatusEnum["UnknownSecretId"] = 5] = "UnknownSecretId";
+    StatusEnum[StatusEnum["UnknownShareVersion"] = 6] = "UnknownShareVersion";
+    StatusEnum[StatusEnum["DecryptionFailed"] = 7] = "DecryptionFailed";
+    StatusEnum[StatusEnum["VerificationFailed"] = 8] = "VerificationFailed";
+    StatusEnum[StatusEnum["FormatError"] = 9] = "FormatError";
+    StatusEnum[StatusEnum["Rejected"] = 10] = "Rejected";
+    StatusEnum[StatusEnum["IncompatibleParameterRange"] = 11] = "IncompatibleParameterRange";
+    StatusEnum[StatusEnum["UnsupportedTransportProtocol"] = 12] = "UnsupportedTransportProtocol";
+    StatusEnum[StatusEnum["VersionConflict"] = 13] = "VersionConflict";
+    StatusEnum[StatusEnum["ReplicaIdConflict"] = 14] = "ReplicaIdConflict";
+    StatusEnum[StatusEnum["RequestToClose"] = 99] = "RequestToClose";
+})(StatusEnum || (exports.StatusEnum = StatusEnum = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@derec-alliance/react-native",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "React Native bindings for derec-library, the Rust SDK for the DeRec protocol.",
   "license": "Apache-2.0",
   "repository": {

package/src/errors.ts

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // Copyright (c) 2026 DeRec Alliance. All rights reserved.
 
+import type { DeRecEvent } from './types';
+
 /**
  * Every category name `derec_error_category_name` can return, and no others.
  *
@@ -42,4 +44,19 @@ export interface DeRecError {
   memo?: string;
   expected?: number;
   got?: number;
+  /**
+   * Present only when `code` is `"restore_conflict"`: the channels already
+   * living at the recovered canonical ids, as decimal strings — the same
+   * field `@derec-alliance/nodejs` carries on its restore conflict error.
+   * Clear exactly these and retry `restore`.
+   */
+  channel_ids?: string[];
+  /** The channel the failing inbound message arrived on, when `process()` could tell. */
+  channel_id?: string;
+  /**
+   * On a failed `process()`: the events it produced before failing, such as
+   * sharing-round and unpair timeouts. They are not reported again, so
+   * handle them as you would a successful call's events.
+   */
+  events?: DeRecEvent[];
 }

package/src/native.ts

@@ -6,7 +6,8 @@
  * surface passes `ArrayBuffer`s that TurboModule specs cannot express.
  */
 export interface DeRecNative {
-  version(): string;
+  version(): { major: number; minor: number };
+  generate_replica_id(): bigint;
 }
 
 /**

package/src/primitives.ts

@@ -55,6 +55,7 @@ import type {
   PrePairResponseExtractResult,
   PrePairResponseMessage,
   ProcessPrePairResult,
+  ProducePrePairNoKeysResult,
   ProducePrePairResult,
   ProduceResult,
   RecoverResult,
@@ -94,22 +95,17 @@ function replyTo(value: TransportProtocol[] | undefined): Uint8Array {
 }
 
 /**
- * `ContactMessage` keeps its own dedicated codec rather than going through
- * the generic message codec: `encode_contact_message` /
- * `decode_contact_message` also enforce the mode/field invariant — an
- * `InlineKeys` contact must carry keys, a `HashedKeys` one must carry only
- * the commitment — so a malformed contact is rejected here rather than
- * travelling.
+ * Every contact crossing the native seam goes through the core's contact
+ * codec, which also refuses a contact that violates the invariants of its
+ * contact mode. Delegates to `pairing.request.encode_contact` /
+ * `decode_contact`, defined below.
  */
 function encodeContact(contact_message: ContactMessage): Uint8Array {
-  return bytes(
-    call('encode_contact_message', jsonToBytes(plainMessage(contact_message))),
-  );
+  return pairing.request.encode_contact(contact_message);
 }
 
 function decodeContact(wire: Uint8Array | ArrayBuffer): ContactMessage {
-  const json = call('decode_contact_message', wire) as ArrayBuffer;
-  return reviveMessage(jsonFromBytes(json)) as ContactMessage;
+  return pairing.request.decode_contact(wire);
 }
 
 const discovery = {
@@ -247,22 +243,24 @@ function decodeTransportList(framed: Uint8Array | ArrayBuffer): TransportProtoco
 
 const pairing = {
   request: {
+    /** Creates an out-of-band `ContactMessage`. `nonce` omitted or `null`
+     *  lets the library draw a random one; `ContactMode.NoKeys` requires the
+     *  caller to supply it. */
     create_contact(
       channel_id: bigint,
       contact_mode: ContactMode | number,
       transport_protocols: TransportProtocol[],
+      nonce?: bigint | number | null,
     ): CreateContactResult {
-      // The C entry point also accepts a caller-supplied nonce behind a
-      // presence flag. `@derec-alliance/nodejs` has no such parameter, so the
-      // flag is 0 and the library generates one — the same behaviour, not a
-      // default invented here.
+      // The C entry point carries `Option<u64>` as a presence flag plus a
+      // value; an absent nonce clears the flag and the library draws one.
       const result = call(
         'create_contact_message',
         channel_id,
         contact_mode,
         encodeTransportList(transport_protocols),
-        0,
-        0n,
+        nonce == null ? 0 : 1,
+        nonce ?? 0n,
       ) as { contact_wire_bytes: ArrayBuffer; secret_key_material: ArrayBuffer };
       return {
         contact_message: decodeContact(result.contact_wire_bytes),
@@ -270,13 +268,22 @@ const pairing = {
       };
     },
 
-    /** Proto-encodes a `ContactMessage`. Rejects a contact that violates the
-     *  mode/field invariant rather than serializing it. */
-    encode_contact: encodeContact,
+    /** Serializes a `ContactMessage` to the bytes delivered out of band.
+     *  Refuses a contact that violates the invariants of its contact mode or
+     *  advertises no endpoint. */
+    encode_contact(contact_message: ContactMessage): Uint8Array {
+      return bytes(
+        call('encode_contact_message', jsonToBytes(plainMessage(contact_message))),
+      );
+    },
 
-    /** Decodes proto `ContactMessage` bytes. Rejects a contact that violates
-     *  the mode/field invariant rather than returning it. */
-    decode_contact: decodeContact,
+    /** Parses out-of-band contact bytes back into a `ContactMessage`.
+     *  Refuses bytes that are not a contact, or a contact that violates the
+     *  invariants of its contact mode. */
+    decode_contact(bytes: Uint8Array | ArrayBuffer): ContactMessage {
+      const json = call('decode_contact_message', bytes) as ArrayBuffer;
+      return reviveMessage(jsonFromBytes(json)) as ContactMessage;
+    },
 
     produce(
       kind: SenderKind,
@@ -306,8 +313,17 @@ const pairing = {
       };
     },
 
-    extract(envelope_bytes: Uint8Array, secret_key: Uint8Array): { request: PairRequestMessage } {
-      const result = call('extract_pair_request', envelope_bytes, secret_key) as {
+    extract(
+      envelope_bytes: Uint8Array,
+      secret_key: Uint8Array,
+      parameter_range: ParameterRange | null,
+    ): { request: PairRequestMessage } {
+      const result = call(
+        'extract_pair_request',
+        envelope_bytes,
+        secret_key,
+        encodeOptionalMessage(MessageKind.ParameterRange, parameter_range),
+      ) as {
         request_proto_bytes: ArrayBuffer;
       };
       return {
@@ -393,12 +409,14 @@ const pairing = {
       contact_message: ContactMessage,
       response: PairResponseMessage,
       secret_key: Uint8Array,
+      parameter_range: ParameterRange | null,
     ): PairingProcessResult {
       const result = call(
         'process_pair_response_message',
         encodeContact(contact_message),
         encodeMessage(MessageKind.PairResponse, response),
         secret_key,
+        encodeOptionalMessage(MessageKind.ParameterRange, parameter_range),
       ) as { shared_key: ArrayBuffer; channel_id: bigint };
       return { shared_key: bytes(result.shared_key), channel_id: result.channel_id };
     },
@@ -448,6 +466,45 @@ const pairing = {
         nonce: result.nonce,
       };
     },
+
+    produce_pre_pair_no_keys(
+      channel_id: bigint,
+      request: PrePairRequestMessage,
+    ): ProducePrePairNoKeysResult {
+      const result = call(
+        'produce_pre_pair_no_keys_response_message',
+        channel_id,
+        encodeMessage(MessageKind.PrePairRequest, request),
+      ) as { envelope_wire_bytes: ArrayBuffer; secret_key_material: ArrayBuffer };
+      return {
+        envelope: bytes(result.envelope_wire_bytes),
+        secret_key_material: bytes(result.secret_key_material),
+      };
+    },
+
+    process_pre_pair_no_keys(
+      contact_message: ContactMessage,
+      response: PrePairResponseMessage,
+    ): ProcessPrePairResult {
+      const result = call(
+        'process_pre_pair_no_keys_response_message',
+        encodeContact(contact_message),
+        encodeMessage(MessageKind.PrePairResponse, response),
+      ) as {
+        mlkem_encapsulation_key: ArrayBuffer;
+        ecies_public_key: ArrayBuffer;
+        nonce: bigint;
+      };
+      return {
+        mlkem_encapsulation_key: bytes(result.mlkem_encapsulation_key),
+        ecies_public_key: bytes(result.ecies_public_key),
+        nonce: result.nonce,
+      };
+    },
+  },
+
+  fingerprint(shared_key: Uint8Array): string {
+    return call('pairing_fingerprint', shared_key) as string;
   },
 };