@otskit/client 0.6.0 → 0.7.0

package/dist/browser.d.ts

@@ -31,6 +31,12 @@ declare class OpenTimestampsBrowserClient {
     constructor(options?: BrowserClientOptions);
     /** hash: 32-byte Uint8Array or 64-char hex. Returns the pending .ots as Uint8Array. */
     stamp(hash: Uint8Array | string): Promise<Uint8Array>;
+    /**
+     * proof: a pending .ots as bytes. Queries the calendars it references (allowlisted) and returns
+     * the upgraded .ots. Throws UpgradeError if no calendar has confirmed the timestamp yet, which is
+     * the normal state until Bitcoin mines the commitment (typically an hour or more after stamping).
+     */
+    upgrade(proof: Uint8Array): Promise<Uint8Array>;
 }
 
 export { BROWSER_CALENDARS, type BrowserClientOptions, OpenTimestampsBrowserClient, bytesToHex, hashBlob, hashBytes };

package/dist/browser.js

@@ -20,6 +20,8 @@ var StampError = class extends OpenTimestampsClientError {
     this.failedSubmissions = failed;
   }
 };
+var UpgradeError = class extends OpenTimestampsClientError {
+};
 var NetworkError = class extends OpenTimestampsClientError {
   /** HTTP status code when the failure originates from an HTTP response. */
   status;
@@ -653,6 +655,63 @@ async function orchestrateStamp(hash, calendars, networkLayer, validateCalendarU
   return detached.serializeToBytes();
 }
 
+// src/core/upgrade-core.ts
+import { DetachedTimestampFile as DetachedTimestampFile2 } from "@otskit/core";
+function bytesEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) {
+    diff |= a[i] ^ b[i];
+  }
+  return diff === 0;
+}
+async function upgradeProofBytes(incompleteProof, networkLayer, logger, signal) {
+  let detached;
+  try {
+    detached = DetachedTimestampFile2.deserialize(incompleteProof);
+  } catch (error) {
+    throw new ValidationError("Invalid .ots proof format", {
+      /* v8 ignore next */
+      ...error instanceof Error ? { cause: error } : {}
+    });
+  }
+  if (detached.timestamp.isTimestampComplete()) {
+    logger?.info("Proof already complete; nothing to upgrade");
+    return incompleteProof;
+  }
+  const before = detached.serializeToBytes();
+  for (const subStamp of detached.timestamp.directlyVerified()) {
+    if (subStamp.isTimestampComplete()) continue;
+    for (const att of subStamp.attestations) {
+      if (att.kind !== "pending") continue;
+      if (!DEFAULT_CALENDAR_WHITELIST.contains(att.uri)) {
+        logger?.warn(`Ignoring attestation from non-whitelisted calendar ${att.uri}`);
+        continue;
+      }
+      try {
+        const upgraded = await new CalendarClient(att.uri, networkLayer, logger).getTimestamp(
+          subStamp.getDigest(),
+          signal
+        );
+        subStamp.merge(upgraded);
+      } catch (err) {
+        if (err instanceof CommitmentNotFoundError) {
+          logger?.debug(`Calendar ${att.uri} has not confirmed yet`);
+          continue;
+        }
+        logger?.warn(
+          `Failed to query ${att.uri}: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  }
+  const after = detached.serializeToBytes();
+  if (bytesEqual(before, after)) {
+    throw new UpgradeError("No calendar has confirmed the timestamp yet (Bitcoin not yet mined)");
+  }
+  return after;
+}
+
 // src/security/ssrf-web.ts
 async function assertSafeCalendarUrlStructural(url) {
   let parsed;
@@ -732,6 +791,14 @@ var OpenTimestampsBrowserClient = class {
       this.minSubs
     );
   }
+  /**
+   * proof: a pending .ots as bytes. Queries the calendars it references (allowlisted) and returns
+   * the upgraded .ots. Throws UpgradeError if no calendar has confirmed the timestamp yet, which is
+   * the normal state until Bitcoin mines the commitment (typically an hour or more after stamping).
+   */
+  upgrade(proof) {
+    return upgradeProofBytes(proof, this.layer, this.logger);
+  }
 };
 export {
   BROWSER_CALENDARS,

package/dist/index.cjs

@@ -738,13 +738,20 @@ async function orchestrateStamp(hash, calendars, networkLayer, validateCalendarU
   return detached.serializeToBytes();
 }
 
-// src/core/upgrade.ts
+// src/core/upgrade-core.ts
 var import_core4 = require("@otskit/core");
-var bytesEqFast = (a, b) => Buffer.compare(Buffer.from(a), Buffer.from(b)) === 0;
-async function orchestrateUpgrade(incompleteProof, _calendars, networkLayer, logger, signal) {
+function bytesEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) {
+    diff |= a[i] ^ b[i];
+  }
+  return diff === 0;
+}
+async function upgradeProofBytes(incompleteProof, networkLayer, logger, signal) {
   let detached;
   try {
-    detached = import_core4.DetachedTimestampFile.deserialize(new Uint8Array(incompleteProof));
+    detached = import_core4.DetachedTimestampFile.deserialize(incompleteProof);
   } catch (error) {
     throw new ValidationError("Invalid .ots proof format", {
       /* v8 ignore next */
@@ -753,7 +760,7 @@ async function orchestrateUpgrade(incompleteProof, _calendars, networkLayer, log
   }
   if (detached.timestamp.isTimestampComplete()) {
     logger?.info("Proof already complete; nothing to upgrade");
-    return Buffer.from(incompleteProof);
+    return incompleteProof;
   }
   const before = detached.serializeToBytes();
   for (const subStamp of detached.timestamp.directlyVerified()) {
@@ -782,10 +789,21 @@ async function orchestrateUpgrade(incompleteProof, _calendars, networkLayer, log
     }
   }
   const after = detached.serializeToBytes();
-  if (bytesEqFast(before, after)) {
+  if (bytesEqual(before, after)) {
     throw new UpgradeError("No calendar has confirmed the timestamp yet (Bitcoin not yet mined)");
   }
-  return Buffer.from(after);
+  return after;
+}
+
+// src/core/upgrade.ts
+async function orchestrateUpgrade(incompleteProof, _calendars, networkLayer, logger, signal) {
+  const upgraded = await upgradeProofBytes(
+    new Uint8Array(incompleteProof),
+    networkLayer,
+    logger,
+    signal
+  );
+  return Buffer.from(upgraded);
 }
 
 // src/core/verify.ts
@@ -885,10 +903,18 @@ var EsploraClient = class {
     this.#logger?.debug(`Esplora raw header ${hash}`);
     const response = await this.#networkLayer.request(
       this.#url,
-      { url: `${this.#url}/block/${hash}/header`, method: "GET", headers: { Accept: "application/octet-stream" } },
+      { url: `${this.#url}/block/${hash}/header`, method: "GET", headers: { Accept: "text/plain" } },
       signal
     );
-    const data = response.data;
+    const hex = this.#decode(response.data).trim();
+    let data;
+    try {
+      data = hexToBytes(hex);
+    } catch (cause) {
+      throw new EsploraResponseError("esplora returned a non-hex raw block header", {
+        ...cause instanceof Error ? { cause } : {}
+      });
+    }
     if (data.length !== RAW_HEADER_SIZE) {
       throw new EsploraResponseError(
         `raw block header must be ${RAW_HEADER_SIZE} bytes; got ${data.length}`
@@ -997,12 +1023,7 @@ async function orchestrateVerify(proof, networkLayer, originalDataHash, logger,
   for (const { msg, attestation } of bitcoinAtts) {
     if (attestation.kind !== "bitcoin") continue;
     try {
-      const blockTime = await verifyTimestampAttestation(
-        Uint8Array.from(msg).reverse(),
-        attestation,
-        explorer,
-        signal
-      );
+      const blockTime = await verifyTimestampAttestation(msg, attestation, explorer, signal);
       logger?.info(`Verified against Bitcoin block ${attestation.height}`);
       return { status: "verified", blockHeight: attestation.height, blockTime };
     } catch (err) {

package/dist/index.js

@@ -688,13 +688,20 @@ async function orchestrateStamp(hash, calendars, networkLayer, validateCalendarU
   return detached.serializeToBytes();
 }
 
-// src/core/upgrade.ts
+// src/core/upgrade-core.ts
 import { DetachedTimestampFile as DetachedTimestampFile2 } from "@otskit/core";
-var bytesEqFast = (a, b) => Buffer.compare(Buffer.from(a), Buffer.from(b)) === 0;
-async function orchestrateUpgrade(incompleteProof, _calendars, networkLayer, logger, signal) {
+function bytesEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) {
+    diff |= a[i] ^ b[i];
+  }
+  return diff === 0;
+}
+async function upgradeProofBytes(incompleteProof, networkLayer, logger, signal) {
   let detached;
   try {
-    detached = DetachedTimestampFile2.deserialize(new Uint8Array(incompleteProof));
+    detached = DetachedTimestampFile2.deserialize(incompleteProof);
   } catch (error) {
     throw new ValidationError("Invalid .ots proof format", {
       /* v8 ignore next */
@@ -703,7 +710,7 @@ async function orchestrateUpgrade(incompleteProof, _calendars, networkLayer, log
   }
   if (detached.timestamp.isTimestampComplete()) {
     logger?.info("Proof already complete; nothing to upgrade");
-    return Buffer.from(incompleteProof);
+    return incompleteProof;
   }
   const before = detached.serializeToBytes();
   for (const subStamp of detached.timestamp.directlyVerified()) {
@@ -732,10 +739,21 @@ async function orchestrateUpgrade(incompleteProof, _calendars, networkLayer, log
     }
   }
   const after = detached.serializeToBytes();
-  if (bytesEqFast(before, after)) {
+  if (bytesEqual(before, after)) {
     throw new UpgradeError("No calendar has confirmed the timestamp yet (Bitcoin not yet mined)");
   }
-  return Buffer.from(after);
+  return after;
+}
+
+// src/core/upgrade.ts
+async function orchestrateUpgrade(incompleteProof, _calendars, networkLayer, logger, signal) {
+  const upgraded = await upgradeProofBytes(
+    new Uint8Array(incompleteProof),
+    networkLayer,
+    logger,
+    signal
+  );
+  return Buffer.from(upgraded);
 }
 
 // src/core/verify.ts
@@ -835,10 +853,18 @@ var EsploraClient = class {
     this.#logger?.debug(`Esplora raw header ${hash}`);
     const response = await this.#networkLayer.request(
       this.#url,
-      { url: `${this.#url}/block/${hash}/header`, method: "GET", headers: { Accept: "application/octet-stream" } },
+      { url: `${this.#url}/block/${hash}/header`, method: "GET", headers: { Accept: "text/plain" } },
       signal
     );
-    const data = response.data;
+    const hex = this.#decode(response.data).trim();
+    let data;
+    try {
+      data = hexToBytes(hex);
+    } catch (cause) {
+      throw new EsploraResponseError("esplora returned a non-hex raw block header", {
+        ...cause instanceof Error ? { cause } : {}
+      });
+    }
     if (data.length !== RAW_HEADER_SIZE) {
       throw new EsploraResponseError(
         `raw block header must be ${RAW_HEADER_SIZE} bytes; got ${data.length}`
@@ -947,12 +973,7 @@ async function orchestrateVerify(proof, networkLayer, originalDataHash, logger,
   for (const { msg, attestation } of bitcoinAtts) {
     if (attestation.kind !== "bitcoin") continue;
     try {
-      const blockTime = await verifyTimestampAttestation(
-        Uint8Array.from(msg).reverse(),
-        attestation,
-        explorer,
-        signal
-      );
+      const blockTime = await verifyTimestampAttestation(msg, attestation, explorer, signal);
       logger?.info(`Verified against Bitcoin block ${attestation.height}`);
       return { status: "verified", blockHeight: attestation.height, blockTime };
     } catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@otskit/client",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Official client SDK for OpenTimestamps calendars with resilience patterns",
   "author": "alexalves87",
   "license": "MIT",