@novasamatech/handoff-service 0.8.4 → 0.8.5

package/dist/crypto/index.d.ts

@@ -2,3 +2,4 @@ export type { FileEncryption } from './encryption.js';
 export { createFileEncryption } from './encryption.js';
 export type { FileTicket } from './ticket.js';
 export { deriveEncryptionKey, derivePublicKey, deriveSigningKeypair, deriveSigningSeed, generateTicket, signWithTicket, } from './ticket.js';
+export { HopSigningPayloads } from './signingPayloads.js';

package/dist/crypto/index.js

@@ -1,2 +1,3 @@
 export { createFileEncryption } from './encryption.js';
 export { deriveEncryptionKey, derivePublicKey, deriveSigningKeypair, deriveSigningSeed, generateTicket, signWithTicket, } from './ticket.js';
+export { HopSigningPayloads } from './signingPayloads.js';

package/dist/crypto/signingPayloads.d.ts

@@ -0,0 +1,5 @@
+export declare const HopSigningPayloads: {
+    submit(data: Uint8Array, submitTimestampMs: bigint): Uint8Array;
+    claim(hash: Uint8Array): Uint8Array;
+    ack(hash: Uint8Array): Uint8Array;
+};

package/dist/crypto/signingPayloads.js

@@ -0,0 +1,49 @@
+import { blake2b } from '@noble/hashes/blake2.js';
+/**
+ * Domain-separated 32-byte payloads that the HOP node verifies for
+ * submit/claim/ack. Byte layouts must remain identical to
+ * `substrate/client/hop/src/types.rs` — `signing_payload` and
+ * `submit_signing_payload` — and match the Android client
+ * (`HopSigningPayloads` in `feature_chats_impl.data.hop`).
+ *
+ * Without this domain separation, the HOP server rejects the signature and
+ * surfaces the failure as "Data not found" (the server doesn't reveal that
+ * the data is present but the signature didn't verify).
+ */
+const textEncoder = new TextEncoder();
+const SUBMIT_CONTEXT = textEncoder.encode('hop-submit-v1:');
+const CLAIM_CONTEXT = textEncoder.encode('hop-claim-v1:');
+const ACK_CONTEXT = textEncoder.encode('hop-ack-v1:');
+function concat(...parts) {
+    const total = parts.reduce((n, p) => n + p.length, 0);
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const p of parts) {
+        out.set(p, offset);
+        offset += p.length;
+    }
+    return out;
+}
+function blake2b256(data) {
+    return blake2b(data, { dkLen: 32 });
+}
+function u64LeBytes(value) {
+    const out = new Uint8Array(8);
+    let v = value;
+    for (let i = 0; i < 8; i++) {
+        out[i] = Number(v & 0xffn);
+        v >>= 8n;
+    }
+    return out;
+}
+export const HopSigningPayloads = {
+    submit(data, submitTimestampMs) {
+        return blake2b256(concat(SUBMIT_CONTEXT, blake2b256(data), u64LeBytes(submitTimestampMs)));
+    },
+    claim(hash) {
+        return blake2b256(concat(CLAIM_CONTEXT, hash));
+    },
+    ack(hash) {
+        return blake2b256(concat(ACK_CONTEXT, hash));
+    },
+};

package/dist/fileLoader/fileLoader.js

@@ -2,7 +2,7 @@ import { blake2b } from '@noble/hashes/blake2.js';
 import { mergeUint8 } from '@polkadot-api/utils';
 import { errAsync, okAsync } from 'neverthrow';
 import { UploadedFile } from '../codec.js';
-import { createFileEncryption, deriveEncryptionKey, derivePublicKey, generateTicket, signWithTicket, } from '../crypto/index.js';
+import { HopSigningPayloads, createFileEncryption, deriveEncryptionKey, derivePublicKey, generateTicket, signWithTicket, } from '../crypto/index.js';
 const DEFAULT_CHUNK_SIZE = 2_000_000;
 function hash256(data) {
     return blake2b(data, { dkLen: 32 });
@@ -48,13 +48,28 @@ export function uploadFile(params) {
         });
     });
 }
+// Sign the canonical claim payload (`blake2b256("hop-claim-v1:" || hash)`)
+// instead of the raw hash — the HOP server validates the signature against
+// this exact payload, identical to Android's `HopSigningPayloads.claim`.
+// Signing the raw hash was the previous behaviour; the server then rejected
+// the signature and returned the error as "Data not found", indistinguishable
+// from an actually-missing entry.
+function signClaimPayload(claimTicket, hash) {
+    return signWithTicket(claimTicket, HopSigningPayloads.claim(hash));
+}
 export function downloadFile(params) {
     const { identifier, claimTicket, hopClient, onProgress } = params;
     const encryptionKey = deriveEncryptionKey(claimTicket);
     const encryption = createFileEncryption(encryptionKey);
-    const metadataSignature = signWithTicket(claimTicket, identifier);
-    return hopClient
-        .claim(identifier, metadataSignature)
+    const claim = (hash) => {
+        // Skip ack — claim already evicts the entry server-side, and firing a
+        // fire-and-forget ack on the same WSS during chunk loops can stall the
+        // next claim's response (observed in practice). Android calls ack
+        // explicitly per claim, but it's not required for the receive to
+        // complete; the server keeps cleanup paths idempotent.
+        return hopClient.claim(hash, signClaimPayload(claimTicket, hash));
+    };
+    return claim(identifier)
         .andThen(encryptedMetadata => {
         try {
             const metadataBytes = encryption.decrypt(encryptedMetadata);
@@ -72,8 +87,7 @@ export function downloadFile(params) {
         for (let i = 0; i < totalChunks; i++) {
             const chunkHash = chunkHashes[i];
             result = result.andThen(decryptedChunks => {
-                const chunkSignature = signWithTicket(claimTicket, chunkHash);
-                return hopClient.claim(chunkHash, chunkSignature).andThen(encryptedChunk => {
+                return claim(chunkHash).andThen(encryptedChunk => {
                     try {
                         const chunk = encryption.decrypt(encryptedChunk);
                         onProgress?.(i + 1, totalChunks);

package/dist/fileLoader/fileLoader.spec.js

@@ -32,6 +32,7 @@ function createMockHopClient() {
     const client = {
         submit: submitMock,
         claim: claimMock,
+        ack: vi.fn(() => okAsync(null)),
         poolStatus: vi.fn(() => okAsync({ entryCount: 0, totalBytes: 0, maxBytes: 10_000_000 })),
     };
     return { client, submitMock, claimMock, submittedEntries };

package/dist/rpc/client.d.ts

@@ -3,6 +3,7 @@ import type { PoolStatus, RequestFn } from './types.js';
 export type HopClient = {
     submit(data: Uint8Array, recipients: Uint8Array[]): ResultAsync<PoolStatus, Error>;
     claim(hash: Uint8Array, signature: Uint8Array): ResultAsync<Uint8Array, Error>;
+    ack(hash: Uint8Array, signature: Uint8Array): ResultAsync<null, Error>;
     poolStatus(): ResultAsync<PoolStatus, Error>;
 };
 export declare function createHopClient(requestFn: RequestFn): HopClient;

package/dist/rpc/client.js

@@ -22,6 +22,12 @@ export function createHopClient(requestFn) {
         claim(hash, signature) {
             return fromPromise(requestFn('hop_claim', [toHexString(hash), encodeSr25519Signature(signature)]).then(hex => fromHex(hex)), toError);
         },
+        ack(hash, signature) {
+            // hop_ack acknowledges a successful claim so the server can evict the
+            // entry. Android calls this after every successful claim; failure is
+            // non-fatal for the receiver (best-effort cleanup).
+            return fromPromise(requestFn('hop_ack', [toHexString(hash), encodeSr25519Signature(signature)]).then(() => null), toError);
+        },
         poolStatus() {
             return fromPromise(requestFn('hop_poolStatus', []), toError);
         },

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/handoff-service",
   "type": "module",
-  "version": "0.8.4",
+  "version": "0.8.5",
   "description": "HOP (Handoff Pool) file transfer service for P2P chat",
   "license": "Apache-2.0",
   "repository": {