diff --git a/dsm_client/frontend/src/components/screens/__tests__/ContactsTabScreen.pairingLine.test.tsx b/dsm_client/frontend/src/components/screens/__tests__/ContactsTabScreen.pairingLine.test.tsx
new file mode 100644
index 000000000..b323bc59c
--- /dev/null
+++ b/dsm_client/frontend/src/components/screens/__tests__/ContactsTabScreen.pairingLine.test.tsx
@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+//! The pairing line states where pairing stands as Rust states it on each
+//! contact. The screen used to infer it from raw radio events, and showed
+//! "Paired!" when a phone's identity was read, before pairing had completed.
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import React from 'react';
+import { act, fireEvent, render, screen } from '@testing-library/react';
+
+import ContactsTabScreen from '../ContactsTabScreen';
+import { bridgeEvents } from '../../../bridge/bridgeEvents';
+
+jest.mock('../../../utils/identity', () => ({
+ hasIdentity: jest.fn().mockResolvedValue(false),
+}));
+
+jest.mock('../../../hooks/useTransactions', () => ({
+ useTransactions: () => ({ transactions: [], refresh: jest.fn() }),
+}));
+
+const mockContacts: any[] = [];
+jest.mock('../../../contexts/ContactsContext', () => ({
+ useContacts: () => ({ contacts: mockContacts, refreshContacts: async () => {}, isLoading: false }),
+}));
+
+function contact(alias: string, pairing: string, bleAddress?: string) {
+ return { alias, deviceId: `${alias.toUpperCase()}1D`, genesisHash: 'GENES1S', signingPublicKey: 'KEY', genesisVerifiedOnline: true, pairing, bleAddress };
+}
+
+async function mount() {
+ (globalThis as any).requestAnimationFrame = () => 0;
+ await act(async () => {
+ render(
);
+ await Promise.resolve();
+ });
+}
+
+describe('ContactsTabScreen pairing line', () => {
+ beforeEach(() => {
+ mockContacts.length = 0;
+ });
+
+ it('states the furthest a pairing has got, and raw radio events change nothing', async () => {
+ mockContacts.push(contact('ann', 'paired', 'AA:BB:CC:DD:EE:01'), contact('bob', 'connected'), contact('cy', 'searching'));
+ await mount();
+ expect(screen.getByText('Connected')).toBeTruthy();
+
+ await act(async () => {
+ bridgeEvents.emit('ble.deviceFound', { address: 'AA:BB:CC:DD:EE:02', name: 'x', rssi: -40 });
+ bridgeEvents.emit('ble.deviceDisconnected', { address: 'AA:BB:CC:DD:EE:02' });
+ bridgeEvents.emit('contact.bleMapped', { address: 'AA:BB:CC:DD:EE:02', deviceId: 'BOB1D' });
+ });
+ expect(screen.getByText('Connected')).toBeTruthy();
+ expect(screen.queryByText('Paired!')).toBeNull();
+ expect(screen.queryByText('Peer Found')).toBeNull();
+ });
+
+ it('shows searching for a contact Rust is still looking for, or retrying', async () => {
+ mockContacts.push(contact('dee', 'retrying'));
+ await mount();
+ expect(screen.getByText('Scanning for Peers')).toBeTruthy();
+ });
+
+ it('shows no line when no pairing is under way', async () => {
+ mockContacts.push(contact('eve', 'paired', 'AA:BB:CC:DD:EE:05'), contact('fay', 'idle'));
+ await mount();
+ expect(screen.queryByText('Scanning for Peers')).toBeNull();
+ expect(screen.queryByText('Connected')).toBeNull();
+ fireEvent.click(screen.getByText('eve'));
+ expect(screen.getByText('BLE PAIRED')).toBeTruthy();
+ });
+});
diff --git a/dsm_client/frontend/src/components/tour/practiceMode.ts b/dsm_client/frontend/src/components/tour/practiceMode.ts
index 437ce21e6..47b6ff606 100644
--- a/dsm_client/frontend/src/components/tour/practiceMode.ts
+++ b/dsm_client/frontend/src/components/tour/practiceMode.ts
@@ -61,6 +61,8 @@ function freshState(): PracticeState {
deviceId: practiceId('PRACT1CEA11CE'),
genesisHash: practiceId('PRACT1CEA11CEGENES1S'),
signingPublicKey: practiceId('PRACT1CEA11CEKEY'),
+ // Practice contacts are never paired over BLE.
+ pairing: 'idle',
genesisVerifiedOnline: true,
sendReady: true,
sendCheckState: 'ready',
@@ -194,6 +196,7 @@ function simulations(state: PracticeState, emit: (event: PracticeEvent) => void)
genesisHash: typeof input.genesisHash === 'string' ? input.genesisHash : practiceId('PRACT1CEGENES1S'),
deviceId: typeof input.deviceId === 'string' ? input.deviceId : practiceId('PRACT1CEDEV1CE'),
signingPublicKey: practiceId('PRACT1CEKEY'),
+ pairing: 'idle',
genesisVerifiedOnline: true,
sendReady: true,
sendCheckState: 'ready',
diff --git a/dsm_client/frontend/src/domain/__tests__/mappers.test.ts b/dsm_client/frontend/src/domain/__tests__/mappers.test.ts
index f47d08c80..8574a50d6 100644
--- a/dsm_client/frontend/src/domain/__tests__/mappers.test.ts
+++ b/dsm_client/frontend/src/domain/__tests__/mappers.test.ts
@@ -15,6 +15,7 @@ describe('domain mappers', () => {
publicKey: new Uint8Array(64).fill(3),
genesisVerifiedOnline: true,
bleAddress,
+ pairing: bleAddress ? 'paired' as const : 'idle' as const,
});
// The address is Rust's: the contact carries it as Rust holds it, and none
diff --git a/dsm_client/frontend/src/domain/mappers.ts b/dsm_client/frontend/src/domain/mappers.ts
index fe96a389a..d7fc8d9d7 100644
--- a/dsm_client/frontend/src/domain/mappers.ts
+++ b/dsm_client/frontend/src/domain/mappers.ts
@@ -74,6 +74,7 @@ export function mapContactList(list: BilateralRelationshipDTO[]): DomainContact[
chainTip: c.chainTip ? toBase32Crockford(c.chainTip) : undefined,
// The address Rust holds for the contact: pairing confirmed it.
bleAddress: c.bleAddress,
+ pairing: c.pairing,
genesisVerifiedOnline: c.genesisVerifiedOnline,
signingPublicKey: toBase32Crockford(c.publicKey),
sendReady: sendStatus?.sendReady,
diff --git a/dsm_client/frontend/src/domain/types.ts b/dsm_client/frontend/src/domain/types.ts
index 9a8c10080..28b21f508 100644
--- a/dsm_client/frontend/src/domain/types.ts
+++ b/dsm_client/frontend/src/domain/types.ts
@@ -21,12 +21,16 @@ export type DomainRelationshipSendStatus = {
sendBlockMessage?: string;
};
+/** Where BLE pairing with a contact stands, as Rust's pairing loop has it. */
+export type ContactPairing = 'paired' | 'idle' | 'searching' | 'connected' | 'retrying';
+
export type DomainContact = {
alias: string;
deviceId: string;
genesisHash: string;
chainTip?: string;
bleAddress?: string;
+ pairing: ContactPairing;
genesisVerifiedOnline: boolean;
signingPublicKey: string; // base32 Crockford encoded
sendReady?: boolean;
diff --git a/dsm_client/frontend/src/dsm/__tests__/contacts.test.ts b/dsm_client/frontend/src/dsm/__tests__/contacts.test.ts
index c4a25373b..d7150eb4a 100644
--- a/dsm_client/frontend/src/dsm/__tests__/contacts.test.ts
+++ b/dsm_client/frontend/src/dsm/__tests__/contacts.test.ts
@@ -47,6 +47,7 @@ describe('contacts.ts', () => {
signingPublicKey: signingPk as any,
genesisHash: { v: gh } as any,
bleAddress: 'AA:BB:CC:DD:EE:FF',
+ pairing: pb.ContactPairingPhase.PAIRED,
genesisVerifiedOnline: true,
}),
],
@@ -62,6 +63,7 @@ describe('contacts.ts', () => {
expect(result.contacts[0].deviceId).toEqual(deviceId);
expect(result.contacts[0].publicKey).toEqual(signingPk);
expect(result.contacts[0].bleAddress).toBe('AA:BB:CC:DD:EE:FF');
+ expect(result.contacts[0].pairing).toBe('paired');
expect(result.contacts[0].genesisVerifiedOnline).toBe(true);
});
@@ -91,6 +93,7 @@ describe('contacts.ts', () => {
alias: 'Alice',
signingPublicKey: new Uint8Array(64).fill(0x02),
genesisHash: { v: new Uint8Array(32).fill(0x03) },
+ pairing: pb.ContactPairingPhase.IDLE,
};
(getContactsStrictBridge as jest.Mock).mockResolvedValue(answer(new pb.ContactAddResponse({})));
@@ -110,6 +113,40 @@ describe('contacts.ts', () => {
answer(new pb.ContactAddResponse({ ...complete, alias: '' } as any)),
);
await expect(getContacts()).rejects.toThrow(/STRICT.*without its alias/);
+
+ // Where pairing stands is Rust's to state; a phase the wire does not
+ // name is not read as any other.
+ (getContactsStrictBridge as jest.Mock).mockResolvedValue(
+ answer(new pb.ContactAddResponse({ ...complete, pairing: pb.ContactPairingPhase.UNSPECIFIED } as any)),
+ );
+ await expect(getContacts()).rejects.toThrow(/STRICT.*pairing phase the wire does not name/);
+ });
+
+ test('each contact carries the pairing phase Rust states', async () => {
+ const phases: Array<[pb.ContactPairingPhase, string]> = [
+ [pb.ContactPairingPhase.PAIRED, 'paired'],
+ [pb.ContactPairingPhase.IDLE, 'idle'],
+ [pb.ContactPairingPhase.SEARCHING, 'searching'],
+ [pb.ContactPairingPhase.CONNECTED, 'connected'],
+ [pb.ContactPairingPhase.RETRYING, 'retrying'],
+ ];
+ (getContactsStrictBridge as jest.Mock).mockResolvedValue(frameEnvelope(new pb.Envelope({
+ version: 3,
+ payload: {
+ case: 'contactsListResponse',
+ value: new pb.ContactsListResponse({
+ contacts: phases.map(([pairing], i) => new pb.ContactAddResponse({
+ deviceId: new Uint8Array(32).fill(i + 1) as any,
+ alias: `c${i}`,
+ signingPublicKey: new Uint8Array(64).fill(2) as any,
+ genesisHash: { v: new Uint8Array(32).fill(3) } as any,
+ pairing,
+ })),
+ }),
+ },
+ })));
+ const result = await getContacts();
+ expect(result.contacts.map((c) => c.pairing)).toEqual(phases.map(([, name]) => name));
});
test('throws on empty response bytes', async () => {
@@ -163,6 +200,7 @@ describe('contacts.ts', () => {
signingPublicKey: new Uint8Array(64).fill(0x05) as any,
genesisHash: { v: new Uint8Array(32).fill(0x06) } as any,
chainTip: { v: tipHash } as any,
+ pairing: pb.ContactPairingPhase.IDLE,
}),
],
}),
diff --git a/dsm_client/frontend/src/dsm/contacts.ts b/dsm_client/frontend/src/dsm/contacts.ts
index ee9337b48..fcd335798 100644
--- a/dsm_client/frontend/src/dsm/contacts.ts
+++ b/dsm_client/frontend/src/dsm/contacts.ts
@@ -9,6 +9,15 @@ import {
requestBlePermissions as bridgeRequestBlePermissions,
} from './WebViewBridge';
import { ContactsList, AddContactArgs, AddContactResult, BilateralRelationshipDTO, ContactCard } from './types';
+import type { ContactPairing } from '../domain/types';
+
+const PAIRING: Partial
> = {
+ [pb.ContactPairingPhase.PAIRED]: 'paired',
+ [pb.ContactPairingPhase.IDLE]: 'idle',
+ [pb.ContactPairingPhase.SEARCHING]: 'searching',
+ [pb.ContactPairingPhase.CONNECTED]: 'connected',
+ [pb.ContactPairingPhase.RETRYING]: 'retrying',
+};
/** A contact as contacts.list states it; a contact missing what Rust always writes is refused. */
function mapContactToDTO(c: pb.ContactAddResponse): BilateralRelationshipDTO {
@@ -29,6 +38,10 @@ function mapContactToDTO(c: pb.ContactAddResponse): BilateralRelationshipDTO {
if (chainTip !== undefined && chainTip.length !== 32) {
throw new Error(`STRICT: contacts.list answered a contact with a ${chainTip.length}-byte tip`);
}
+ const pairing = PAIRING[c.pairing];
+ if (!pairing) {
+ throw new Error(`STRICT: contacts.list answered a contact in a pairing phase the wire does not name (${c.pairing})`);
+ }
return {
deviceId: c.deviceId,
publicKey: c.signingPublicKey,
@@ -37,6 +50,7 @@ function mapContactToDTO(c: pb.ContactAddResponse): BilateralRelationshipDTO {
chainTip,
// The wire's empty string is "no address".
bleAddress: c.bleAddress || undefined,
+ pairing,
genesisVerifiedOnline: c.genesisVerifiedOnline,
sendStatus: c.sendStatus,
};
diff --git a/dsm_client/frontend/src/dsm/types.ts b/dsm_client/frontend/src/dsm/types.ts
index 602dc9ac1..ca61a91d6 100644
--- a/dsm_client/frontend/src/dsm/types.ts
+++ b/dsm_client/frontend/src/dsm/types.ts
@@ -2,6 +2,7 @@
// Lightweight shared types for DSM UI flows and events
import * as pb from '../proto/dsm_app_pb';
+import type { ContactPairing } from '../domain/types';
/**
* A contact as `contacts.list` states it (pb-aligned, binary). Rust writes the
@@ -15,6 +16,7 @@ export interface BilateralRelationshipDTO {
/** The relationship's tip, once it has one. */
chainTip?: Uint8Array; // 32 bytes
bleAddress?: string; // BLE MAC address for offline bilateral transfers
+ pairing: ContactPairing; // where BLE pairing stands, as Rust's pairing loop has it
genesisVerifiedOnline: boolean; // genesis hash verified via storage node
sendStatus?: pb.RelationshipSendStatus;
}
diff --git a/dsm_client/frontend/src/proto/dsm_app_pb.ts b/dsm_client/frontend/src/proto/dsm_app_pb.ts
index af0412235..a2e1a2a5d 100644
--- a/dsm_client/frontend/src/proto/dsm_app_pb.ts
+++ b/dsm_client/frontend/src/proto/dsm_app_pb.ts
@@ -838,6 +838,62 @@ proto3.util.setEnumType(ValueCapabilityV1, "dsm.ValueCapabilityV1", [
{ no: 3, name: "VALUE_CAPABILITY_V1_UNKNOWN" },
]);
+/**
+ * Where BLE pairing with a contact stands, as the SDK's pairing loop has it.
+ *
+ * @generated from enum dsm.ContactPairingPhase
+ */
+export enum ContactPairingPhase {
+ /**
+ * @generated from enum value: CONTACT_PAIRING_PHASE_UNSPECIFIED = 0;
+ */
+ UNSPECIFIED = 0,
+
+ /**
+ * The contact holds the BLE address pairing confirmed.
+ *
+ * @generated from enum value: CONTACT_PAIRING_PHASE_PAIRED = 1;
+ */
+ PAIRED = 1,
+
+ /**
+ * Not paired, and no pairing session is under way.
+ *
+ * @generated from enum value: CONTACT_PAIRING_PHASE_IDLE = 2;
+ */
+ IDLE = 2,
+
+ /**
+ * A pairing session waits for the phone to be seen over BLE.
+ *
+ * @generated from enum value: CONTACT_PAIRING_PHASE_SEARCHING = 3;
+ */
+ SEARCHING = 3,
+
+ /**
+ * The phone was seen; the pairing exchange is under way.
+ *
+ * @generated from enum value: CONTACT_PAIRING_PHASE_CONNECTED = 4;
+ */
+ CONNECTED = 4,
+
+ /**
+ * The last attempt did not complete; the pairing loop tries again.
+ *
+ * @generated from enum value: CONTACT_PAIRING_PHASE_RETRYING = 5;
+ */
+ RETRYING = 5,
+}
+// Retrieve enum metadata with: proto3.getEnumType(ContactPairingPhase)
+proto3.util.setEnumType(ContactPairingPhase, "dsm.ContactPairingPhase", [
+ { no: 0, name: "CONTACT_PAIRING_PHASE_UNSPECIFIED" },
+ { no: 1, name: "CONTACT_PAIRING_PHASE_PAIRED" },
+ { no: 2, name: "CONTACT_PAIRING_PHASE_IDLE" },
+ { no: 3, name: "CONTACT_PAIRING_PHASE_SEARCHING" },
+ { no: 4, name: "CONTACT_PAIRING_PHASE_CONNECTED" },
+ { no: 5, name: "CONTACT_PAIRING_PHASE_RETRYING" },
+]);
+
/**
* @generated from enum dsm.SdkEventKind
*/
@@ -20015,6 +20071,13 @@ export class ContactAddResponse extends Message {
*/
sendStatus?: RelationshipSendStatus;
+ /**
+ * Where BLE pairing with the contact stands; set on contacts.list.
+ *
+ * @generated from field: dsm.ContactPairingPhase pairing = 14;
+ */
+ pairing = ContactPairingPhase.UNSPECIFIED;
+
constructor(data?: PartialMessage) {
super();
proto3.util.initPartial(data, this);
@@ -20033,6 +20096,7 @@ export class ContactAddResponse extends Message {
{ no: 11, name: "ble_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 12, name: "signing_public_key", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 13, name: "send_status", kind: "message", T: RelationshipSendStatus },
+ { no: 14, name: "pairing", kind: "enum", T: proto3.getEnumType(ContactPairingPhase) },
]);
static fromBinary(bytes: Uint8Array, options?: Partial): ContactAddResponse {
diff --git a/dsm_client/frontend/src/tests/E2E.offlineBleExchange.test.ts b/dsm_client/frontend/src/tests/E2E.offlineBleExchange.test.ts
index 0f2901586..f2e6b25f9 100644
--- a/dsm_client/frontend/src/tests/E2E.offlineBleExchange.test.ts
+++ b/dsm_client/frontend/src/tests/E2E.offlineBleExchange.test.ts
@@ -90,6 +90,7 @@ describe('E2E: Offline BLE exchange -> wallet refresh', () => {
genesisHash: new pb.Hash32({ v: BOB_GENESIS } as any),
chainTip: new pb.Hash32({ v: BOB_TIP } as any),
bleAddress: 'AA:BB:CC:DD:EE:FF',
+ pairing: pb.ContactPairingPhase.PAIRED,
},
],
} as any);
diff --git a/dsm_client/frontend/src/tests/E2E.transferProof.test.ts b/dsm_client/frontend/src/tests/E2E.transferProof.test.ts
index 945e53596..7803b4d46 100644
--- a/dsm_client/frontend/src/tests/E2E.transferProof.test.ts
+++ b/dsm_client/frontend/src/tests/E2E.transferProof.test.ts
@@ -98,6 +98,7 @@ function makeContactsFramedEnvelope(bleAddress?: string): Uint8Array {
genesisHash: new pb.Hash32({ v: COUNTERPARTY_GENESIS }),
chainTip: new pb.Hash32({ v: COUNTERPARTY_TIP }),
bleAddress: bleAddress || 'AA:BB:CC:DD:EE:FF',
+ pairing: pb.ContactPairingPhase.PAIRED,
} as any);
const resp = new pb.ContactsListResponse({ contacts: [contact] });
const env = new pb.Envelope({
diff --git a/proto/dsm_app.proto b/proto/dsm_app.proto
index 71d0aafc9..323b00255 100644
--- a/proto/dsm_app.proto
+++ b/proto/dsm_app.proto
@@ -3099,6 +3099,23 @@ message ContactAddResponse {
string ble_address = 11; // BLE MAC address for offline bilateral transfers
bytes signing_public_key = 12 [(dsm_fixed_len)=64]; // SPHINCS+ SPX256s public key for bilateral verification
RelationshipSendStatus send_status = 13;
+ // Where BLE pairing with the contact stands; set on contacts.list.
+ ContactPairingPhase pairing = 14;
+}
+
+// Where BLE pairing with a contact stands, as the SDK's pairing loop has it.
+enum ContactPairingPhase {
+ CONTACT_PAIRING_PHASE_UNSPECIFIED = 0;
+ // The contact holds the BLE address pairing confirmed.
+ CONTACT_PAIRING_PHASE_PAIRED = 1;
+ // Not paired, and no pairing session is under way.
+ CONTACT_PAIRING_PHASE_IDLE = 2;
+ // A pairing session waits for the phone to be seen over BLE.
+ CONTACT_PAIRING_PHASE_SEARCHING = 3;
+ // The phone was seen; the pairing exchange is under way.
+ CONTACT_PAIRING_PHASE_CONNECTED = 4;
+ // The last attempt did not complete; the pairing loop tries again.
+ CONTACT_PAIRING_PHASE_RETRYING = 5;
}
// ======================== Faucet Operations =========================
diff --git a/specs/requirements/CONFORMANCE_GAPS.md b/specs/requirements/CONFORMANCE_GAPS.md
index 70e277e29..23f058cc7 100644
--- a/specs/requirements/CONFORMANCE_GAPS.md
+++ b/specs/requirements/CONFORMANCE_GAPS.md
@@ -1035,6 +1035,7 @@ Owner request: integrate the frontend with the storage nodes properly, working f
| frontend · dsm/transactions.ts `offlineSend`, components/screens/wallet/SendTab.tsx, dsm/resolution.ts, domain/mappers.ts `mapContactList`, stores/contactsStore.ts, dsm/WebViewBridge/ble.ts; Kotlin · bridge/SinglePathWebViewBridge.kt, UnifiedContactBridge.kt, Unified.kt, UnifiedNativeApi.kt; `dsm_sdk` · handlers/wallet_routes.rs `wallet.sendOffline`, bluetooth/bilateral_ble_handler.rs (the prepare), jni/state.rs, jni/unified_protobuf_bridge.rs; `proto` · `BilateralPrepareRequest` 6 and 11–14, `OfflineTransferRequest` | The frontend chose where an offline send went. The send form resolved the recipient's BLE address — the one the contact showed, else a cache of its own, else a bridge round trip to a native map — and refused a contact it found none for before Rust was asked. `offlineSend` sent the address inside a `BilateralPrepareRequest`, the device-to-device prepare, whose intent fields (11–14) existed only for this route and whose `ble_address` (6) no receiver read; the route also took a caller-authored operation (`operation_data`) in place of authoring one. The contacts mapper filled a missing address from the frontend's cache and dropped one that was not MAC-shaped. The prepare builder looked an address up only to fill field 6, and when the contact had none it wrote the session's address into the contact — the mark that ends the pairing loop — outside the pairing confirm. `recordPeerIdentity` wrote into the session map the last 32 bytes of any identity payload, unverified, and nothing called it. | `wallet.sendOffline` takes `OfflineTransferRequest`: the counterparty, token, amount and memo, as the user gave them. The SDK resolves the address (`bluetooth::peer_address`): the one the contact holds, else the one its identity, checked against the contact's genesis, was seen at this session; a phone it has not met is refused, saying so. It authors the operation from the intent, and no caller supplies one. `BilateralPrepareRequest` 6 and 11–14 are reserved and the builder looks up no address. The session map moved from `jni::state` to `bluetooth::peer_address`, host-compiled and tested. Deleted: the frontend resolver module with its cache and normalizer, the `resolveBleAddressForDeviceId` RPC with its Kotlin arm, wrapper and JNI export, `recordPeerIdentity`, and `resolve_ble_address`, which nothing called. The contact carries the address Rust holds, as Rust holds it. |
| frontend · components/screens/ContactsTabScreen.tsx, dsm/WebViewBridge/ble.ts; Kotlin · bridge/SinglePathWebViewBridge.kt, Unified.kt, UnifiedNativeApi.kt, UnifiedContactBridge.kt; `dsm_sdk` · sdk/session_manager.rs, bluetooth/mod.rs, handlers/contacts_routes.rs, jni/helpers.rs, storage/client_db/contacts.rs `has_unpaired_contacts` | The contacts screen ran BLE pairing: it started the loop when it counted more unpaired contacts than before and stopped it when it unmounted, so pairing ran only while that screen was open. Kotlin's start arm asked for Bluetooth permissions and created the BLE coordinator on the way. `hasUnpairedContacts` answered false when the database could not be read, and nothing called it. | Pairing follows the session, as the lock does: Rust starts the loop when the facts Kotlin reports say the app is in the foreground with Bluetooth on and permitted and there is an identity to pair as (`SessionManager::pairing_may_run`), and stops it when they say otherwise; the loop still ends by itself once no contact is unpaired. Adding a contact wakes or starts the loop when the session lets it run. Kotlin creates the BLE coordinator the loop drives when the identity's BLE service starts, before the facts that let pairing run go out, as the start arm did. Deleted: the screen's start and stop, the `startPairingAll` and `stopPairingAll` RPCs with their Kotlin arms, wrappers and JNI exports, and the `hasUnpairedContacts` chain down to its query. The start and stop are compile-checked Android code, not run: a device run is what shows pairing starts in the foreground and stops in the background. |
| frontend · dsm/transactions.ts `offlineSend` | A BLE transaction error frame ended the send in flight as failed. Kotlin raises that frame for any failed connection to any address — a failed identity read, a failed GATT connect, a failed connection-state call — so a pairing attempt with another phone could fail a send, and a lost link, which is liveness, was reported as a failed transfer while the step stayed open. | The listener is deleted: the send ends on Rust's word, its events or its pending list, and a screen that stops waiting reports the step open. |
+| `dsm_sdk` · bluetooth/pairing_orchestrator.rs (`handle_pairing_confirm`, `finalize_scanner_pairing_by_address`, `handle_identity_observed`, `handle_peer_disconnected`), handlers/contacts_routes.rs `contacts.list`, sdk/contact_sdk.rs; `proto` · `ContactAddResponse.pairing`, `ContactPairingPhase`; frontend · components/screens/ContactsTabScreen.tsx, dsm/contacts.ts, domain/mappers.ts | Both pairing completions marked the session Complete, and told the screen the contact was paired, when storing its address failed. The loop never revisits a Complete session, so such a contact stayed unpaired until the process restarted — among them a phone paired before it was added as a contact, whose store fails for want of the contact. The loop reported only "scanning", so the contacts screen inferred progress from raw radio events about any phone: "Peer Found" on any DSM advertisement, and "Paired!" when a phone's identity was read, before pairing had completed. A dropped link set the session's state twice. | A session completes only once the address is stored; a failed store fails the session, and the loop retries it. The loop reports each transition, and the contact list states each contact's phase from the loop's sessions — paired, idle, searching, connected or retrying (`ContactPairingPhase`; the frontend refuses a phase the wire does not name). The screen's line renders those phases and no longer listens to raw radio events; a pairing event re-reads the list. The orchestrator's database tests set their own storage directory: they passed only when an earlier test had set one. |
Tests: `dsm_sdk::handlers::storage_routes::tests::storage_status_reports_the_pinned_set_and_each_members_own_answer` (the router's answer over real nodes on Postgres; then one member stops serving), `dsm_sdk::sdk::storage_node_sdk::tests::a_members_latest_bytecommit_is_its_own_or_there_is_none`, `dsm_sdk::storage::client_db::tests::a_database_that_does_not_exist_has_no_size`; frontend `dsm/__tests__/storage.test.ts` and `components/storage/__tests__/StorageNodePanels.test.tsx`. Mutation controls, each red on its named test: another member's ByteCommit accepted as this member's (`a_members_latest_bytecommit_is_its_own_or_there_is_none`); a missing database file reported as 0 bytes (`a_database_that_does_not_exist_has_no_size`); a member that did not answer reported as "no cycle" (`storage_status_reports_the_pinned_set_and_each_members_own_answer`); the frontend inventing an answer for a member that carries none (`a member that carries no answer is refused, never given one`); every member counted as answering (`shows the set and counts only the members that gave an answer`).
@@ -1084,11 +1085,13 @@ Tests for pairing: `dsm_sdk::sdk::session_manager::tests::pairing_runs_only_in_t
Tests for transport errors: frontend `dsm/__tests__/offlineSend.test.ts` · `a BLE transport error fails no send; the send ends on Rust's word`. Mutation control, red on its named test: the listener restored.
+Tests for pairing status: `dsm_sdk::bluetooth::pairing_orchestrator::tests::a_confirm_that_cannot_store_the_address_does_not_complete`, `a_scanner_finalize_that_cannot_store_the_address_does_not_complete`, `a_contacts_pairing_phase_is_the_sdks_own`; `dsm_sdk::handlers::contacts_routes::pairing_phase_tests::the_contact_list_states_where_pairing_stands` (two devices on the fleet: idle, then searching, then paired); frontend `dsm/__tests__/contacts.test.ts` · `each contact carries the pairing phase Rust states`, `a contact without what Rust always writes is refused, never filled in` (a phase the wire does not name); `components/screens/__tests__/ContactsTabScreen.pairingLine.test.tsx`. Mutation controls, each red on its named test: either completion completing when the store fails; a retrying session stated as idle; the list stating no session; an unnamed phase read as idle; the line inferring "Paired!" from a raw event; a retrying contact shown as nothing.
+
**Open**
- frontend · dsm/EventBridge.ts: `dsm-biometric-result` and `ble-dev-automation` are still dispatched as window events with no listener in the frontend; whether device automation or the biometric flow reads them from outside the bundle is a device question, so they stay until a device run says. `bluetooth-permissions` went with its producer, the `BLUETOOTH_PERMISSIONS` host event.
-- frontend · components/screens/ContactsTabScreen.tsx: the BLE status line (scanning, found, connected, paired) is inferred from raw BLE events and from whether contacts show an address, while Rust's pairing loop reports only "scanning" (`emit_pairing_status`); the states the loop's sessions pass through are Rust's to report. The screen also re-reads the contact list every 5 s on a timer.
+- frontend · components/screens/ContactsTabScreen.tsx: re-reads the contact list every 5 s on a timer, beside the events that announce a change.
- Kotlin · UnifiedContactBridge.kt `removeContact`, `hasContactForDeviceId`, with their `Unified` functions, externals and JNI exports: nothing calls them. A contacts pass.
- Kotlin · bridge/ble/BleCoordinator.kt `resolveSession`: when the address a transfer names is not a live session and no identity matches it, the transfer goes to the one ready peer, whichever phone that is. A prepare for one contact can reach another phone; the fallback picks a destination the SDK did not choose. A transport pass.
- Kotlin · AndroidManifest.xml `PicoSelfTestActivity`: a bench self-test its own comment calls debug bring-up only, exported and launched on USB attach in the production manifest. The hardware track's.
From c8cdfb0b3c9cd96ac4cb68e67abc4251aa9c43e8 Mon Sep 17 00:00:00 2001
From: Cryptskii <47649969+cryptskii@users.noreply.github.com>
Date: Sat, 26 Sep 2026 14:15:13 -0400
Subject: [PATCH 07/11] docs(ble): say device, never phone; the offline help no
longer asks for the wallet screen
DSM runs on devices, and offline goes appliance to appliance. The BLE
work said "phone" in comments, test names, the offline send's refusal
("the devices have not met over BLE" now), the pairing hint and the
conformance rows.
The send screen's help told both people to stay on the wallet screen. That
screen no longer runs the radio: the device advertises while it has an
identity, and the incoming-transfer prompt is mounted for the whole app.
The help now says the recipient accepts in the app.
---
.../dsm_sdk/src/bluetooth/peer_address.rs | 10 +++++-----
.../dsm_sdk/src/handlers/contacts_routes.rs | 2 +-
.../dsm_sdk/src/handlers/wallet_routes.rs | 12 ++++++------
.../dsm_sdk/src/jni/state.rs | 2 +-
.../src/components/screens/ContactsTabScreen.tsx | 4 ++--
.../__tests__/ContactsTabScreen.pairingLine.test.tsx | 2 +-
.../__tests__/EnhancedWalletScreen.events.test.tsx | 2 +-
.../src/components/screens/wallet/SendTab.tsx | 8 ++++----
.../wallet/__tests__/SendTab.offline.test.tsx | 8 ++++----
.../frontend/src/dsm/__tests__/offlineSend.test.ts | 2 +-
dsm_client/frontend/src/dsm/transactions.ts | 4 ++--
dsm_client/frontend/src/proto/dsm_app_pb.ts | 6 +++---
.../frontend/src/tests/E2E.transferProof.test.ts | 8 ++++----
proto/dsm_app.proto | 6 +++---
specs/requirements/CONFORMANCE_GAPS.md | 12 ++++++------
15 files changed, 44 insertions(+), 44 deletions(-)
diff --git a/dsm_client/deterministic_state_machine/dsm_sdk/src/bluetooth/peer_address.rs b/dsm_client/deterministic_state_machine/dsm_sdk/src/bluetooth/peer_address.rs
index 311044f75..715de679e 100644
--- a/dsm_client/deterministic_state_machine/dsm_sdk/src/bluetooth/peer_address.rs
+++ b/dsm_client/deterministic_state_machine/dsm_sdk/src/bluetooth/peer_address.rs
@@ -1,13 +1,13 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
-//! Where a contact's phone is over BLE, for an offline send to it.
+//! Where a contact's device is over BLE, for an offline send to it.
//!
//! Two sources, in this order. The address the contact holds: persisted once
//! pairing confirmed it, and again whenever the contact's identity is seen at
//! a new one. Else the address its identity was seen at this session, before
//! pairing persisted one. Only a contact's identity, checked against the
//! contact's genesis, records an address here. BLE addresses rotate; the
-//! native dispatch matches an address to the phone's current one by the
+//! native dispatch matches an address to the device's current one by the
//! identity it was seen with.
use std::collections::HashMap;
@@ -50,7 +50,7 @@ fn seen_this_session(device_id: &[u8; 32]) -> Option {
}
/// Where an offline send to `device_id` goes: the address its contact holds,
-/// else the one its identity was seen at this session. `None` when the phones
+/// else the one its identity was seen at this session. `None` when the devices
/// have not met over BLE.
pub fn counterparty_address(device_id: &[u8; 32]) -> Result, DsmError> {
let held = crate::storage::client_db::get_contact_by_device_id(device_id)
@@ -137,11 +137,11 @@ mod tests {
);
}
- /// A phone never seen over BLE has no address, and an empty sighting
+ /// A device never seen over BLE has no address, and an empty sighting
/// records none.
#[test]
#[serial]
- fn a_phone_never_seen_has_no_address() {
+ fn a_device_never_seen_has_no_address() {
init_test_db();
let device_id = [0x63; 32];
add_contact(device_id);
diff --git a/dsm_client/deterministic_state_machine/dsm_sdk/src/handlers/contacts_routes.rs b/dsm_client/deterministic_state_machine/dsm_sdk/src/handlers/contacts_routes.rs
index 3ebd4da9b..9b05ef5dc 100644
--- a/dsm_client/deterministic_state_machine/dsm_sdk/src/handlers/contacts_routes.rs
+++ b/dsm_client/deterministic_state_machine/dsm_sdk/src/handlers/contacts_routes.rs
@@ -335,7 +335,7 @@ mod pairing_phase_tests {
/// The contact list states where BLE pairing with each contact stands, as
/// the SDK's pairing loop has it. The contacts screen used to infer it from
- /// raw radio events, and showed "Paired!" when a phone's identity was read.
+ /// raw radio events, and showed "Paired!" when a device's identity was read.
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
#[serial_test::serial]
async fn the_contact_list_states_where_pairing_stands() {
diff --git a/dsm_client/deterministic_state_machine/dsm_sdk/src/handlers/wallet_routes.rs b/dsm_client/deterministic_state_machine/dsm_sdk/src/handlers/wallet_routes.rs
index 5b254148c..c1f6f08fe 100644
--- a/dsm_client/deterministic_state_machine/dsm_sdk/src/handlers/wallet_routes.rs
+++ b/dsm_client/deterministic_state_machine/dsm_sdk/src/handlers/wallet_routes.rs
@@ -788,7 +788,7 @@ impl AppRouterImpl {
)
}
};
- // Where the counterparty's phone is over BLE is the SDK's to know:
+ // Where the counterparty's device is over BLE is the SDK's to know:
// the address its contact holds, else the one its identity was
// seen at this session.
let ble_address = match crate::bluetooth::peer_address::counterparty_address(
@@ -797,7 +797,7 @@ impl AppRouterImpl {
Ok(Some(address)) => address,
Ok(None) => {
return err("wallet.sendOffline: no BLE address is known for the \
- counterparty: the phones have not met over BLE"
+ counterparty: the devices have not met over BLE"
.into())
}
Err(e) => return err(format!("wallet.sendOffline: {e}")),
@@ -1672,13 +1672,13 @@ mod send_offline_tests {
}
}
- /// Where the counterparty's phone is over BLE is the SDK's to know; the
- /// request names no address. A send to a contact whose phone the SDK has
+ /// Where the counterparty's device is over BLE is the SDK's to know; the
+ /// request names no address. A send to a contact whose device the SDK has
/// not met is refused, saying so; once the contact holds an address, the
/// send goes past that refusal.
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
#[serial_test::serial]
- async fn an_offline_send_goes_where_the_sdk_has_seen_the_phone() {
+ async fn an_offline_send_goes_where_the_sdk_has_seen_the_device() {
let device = crate::test_support::one_device::Device::start(0x75).await;
let peer = [0x76u8; 32];
store_contact(&ContactRecord {
@@ -1701,7 +1701,7 @@ mod send_offline_tests {
let refused = send_offline(&device.router, peer)
.await
- .expect_err("the phones have not met");
+ .expect_err("the devices have not met");
assert!(
refused.contains("no BLE address is known for the counterparty"),
"{refused}"
diff --git a/dsm_client/deterministic_state_machine/dsm_sdk/src/jni/state.rs b/dsm_client/deterministic_state_machine/dsm_sdk/src/jni/state.rs
index 3e04eb47d..2bdfe89e9 100644
--- a/dsm_client/deterministic_state_machine/dsm_sdk/src/jni/state.rs
+++ b/dsm_client/deterministic_state_machine/dsm_sdk/src/jni/state.rs
@@ -3,7 +3,7 @@
//! # JNI Global State
//!
//! Process-global flags shared across JNI entry points: whether the bilateral
-//! poll has started. Where a contact's phone is over BLE is
+//! poll has started. Where a contact's device is over BLE is
//! `crate::bluetooth::peer_address`; `SDK_READY` is `sdk::session_manager`.
#[cfg(all(target_os = "android", feature = "bluetooth"))]
diff --git a/dsm_client/frontend/src/components/screens/ContactsTabScreen.tsx b/dsm_client/frontend/src/components/screens/ContactsTabScreen.tsx
index b9e9ba459..739246c74 100644
--- a/dsm_client/frontend/src/components/screens/ContactsTabScreen.tsx
+++ b/dsm_client/frontend/src/components/screens/ContactsTabScreen.tsx
@@ -163,7 +163,7 @@ const ContactsTabScreen: React.FC = ({ eraTokenSrc = 'images/logos/era_to
// stands is Rust's too: each contact carries its phase from the pairing
// loop, and the line shows the furthest a pairing has got. This screen used
// to start and stop pairing itself, and to infer its progress from raw radio
- // events, showing "Paired!" when a phone's identity was read.
+ // events, showing "Paired!" when a device's identity was read.
const pairingLine: 'connected' | 'searching' | null = contacts.some((c) => c.pairing === 'connected')
? 'connected'
: contacts.some((c) => c.pairing === 'searching' || c.pairing === 'retrying')
@@ -331,7 +331,7 @@ const ContactsTabScreen: React.FC = ({ eraTokenSrc = 'images/logos/era_to
{pairingLine === 'connected' && 'Connected'}
- {pairingLine === 'searching' && 'Keep both phones open in the app, near each other'}
+ {pairingLine === 'searching' && 'Keep both devices open in the app, near each other'}
{pairingLine === 'connected' && 'Exchanging identity...'}