@oxy.so/core 1.7.0 → 1.7.3

package/dist/esm/crypto/registrationPow.js

@@ -0,0 +1,50 @@
+/**
+ * Registration proof-of-work — the CLIENT half of the anti-automation nonce
+ * `register()` (`mixins/OxyServices.auth.ts`) submits alongside the
+ * registration signature. The message format, difficulty and the full design
+ * rationale (why 16 bits, why sequential nonces are fine, what this is and
+ * isn't a defense against) live in `@oxy.so/protocol`'s
+ * `auth/registrationPow.ts` — this file is only the solve loop.
+ */
+import './polyfill.js';
+import { sha256 } from '@noble/hashes/sha256';
+import { bytesToHex, utf8ToBytes } from '@noble/hashes/utils';
+import { meetsRegistrationPowDifficulty, registrationPowMessage, REGISTRATION_POW_DIFFICULTY_BITS, } from '@oxy.so/protocol';
+/**
+ * How many attempts the grind loop runs before yielding to the event loop.
+ *
+ * A synchronous hot loop long enough to matter (an average solve at 16 bits
+ * is 65,536 attempts) would otherwise block the JS thread for its entire
+ * duration — on a mobile app that means no touch response, no animation, for
+ * up to roughly a second. Yielding periodically keeps the UI responsive
+ * during the grind at the cost of a handful of event-loop round trips, which
+ * is imperceptible next to the grind itself.
+ */
+const YIELD_EVERY_N_ATTEMPTS = 2000;
+function yieldToEventLoop() {
+    return new Promise((resolve) => setTimeout(resolve, 0));
+}
+/**
+ * Grind a nonce for `publicKey`/`timestamp` that clears
+ * {@link REGISTRATION_POW_DIFFICULTY_BITS}, returned as a decimal counter.
+ *
+ * Hashes with `@noble/hashes/sha256` — pure JS, synchronous, identical output
+ * on web/Node/React Native with no native module and no per-attempt bridge
+ * crossing (see the difficulty constant's own doc for why that distinction is
+ * the whole point). Nonces are sequential (0, 1, 2, …) rather than random: the
+ * candidate space a hash function spreads solutions across is dense either
+ * way, so a counter finds one exactly as reliably as randomness would, without
+ * needing a randomness source at all.
+ */
+export async function solveRegistrationPow(publicKey, timestamp) {
+    for (let nonce = 0;; nonce += 1) {
+        const candidate = String(nonce);
+        const digest = bytesToHex(sha256(utf8ToBytes(registrationPowMessage(publicKey, timestamp, candidate))));
+        if (meetsRegistrationPowDifficulty(digest, REGISTRATION_POW_DIFFICULTY_BITS)) {
+            return candidate;
+        }
+        if (nonce % YIELD_EVERY_N_ATTEMPTS === YIELD_EVERY_N_ATTEMPTS - 1) {
+            await yieldToEventLoop();
+        }
+    }
+}

package/dist/esm/mixins/OxyServices.auth.js

@@ -2,6 +2,7 @@ import { loginResultSchema, safeParseContract } from '@oxy.so/contracts';
 export { getCommonsApprovalBlockingReason, parseCommonsApprovalExpiresAt, } from '../utils/commonsApproval.js';
 import { OxyAuthenticationError } from '../OxyServices.errors.js';
 import { KeyManager } from '../crypto/keyManager.js';
+import { solveRegistrationPow } from '../crypto/registrationPow.js';
 import { SignatureService } from '../crypto/signatureService.js';
 import { loadNodeCrypto } from '@oxy.so/protocol';
 import { logger } from '../logger/index.js';
@@ -258,10 +259,10 @@ export function OxyServicesAuthMixin(Base) {
         /**
          * Whether this process can prove what it is (ADR 0026).
          *
-         * The check and the module that performs it are loaded LAZILY and only on a
-         * Node host. `@oxy.so/core`'s root barrel reaches React Native and Expo, and
-         * `server/workloadIdentity` imports `node:crypto` — a static import here
-         * would pull it into every mobile bundle for a path a phone can never take.
+         * The internal package subpath selects a client implementation for native
+         * and browser bundlers, and the signer only for Node hosts. The runtime
+         * Node guard avoids calling attestation on clients; the module boundary
+         * keeps node:crypto out of their bundle graphs (a guard alone cannot).
          *
          * @internal
          */
@@ -269,7 +270,7 @@ export function OxyServicesAuthMixin(Base) {
             if (typeof process === 'undefined' || !process.versions?.node)
                 return false;
             try {
-                const { canAttestWorkloadIdentity } = await import('../server/workloadIdentity');
+                const { canAttestWorkloadIdentity } = await import('@oxy.so/core/internal/workload-identity');
                 return canAttestWorkloadIdentity();
             }
             catch {
@@ -297,7 +298,7 @@ export function OxyServicesAuthMixin(Base) {
                 return entry.token;
             if (entry?.pending)
                 return entry.pending;
-            const { requestWorkloadServiceToken } = await import('../server/workloadIdentity');
+            const { requestWorkloadServiceToken } = await import('@oxy.so/core/internal/workload-identity');
             const seeded = entry ?? {
                 token: '',
                 expiresAt: 0,
@@ -432,10 +433,15 @@ export function OxyServicesAuthMixin(Base) {
          */
         async register(publicKey, signature, timestamp) {
             try {
+                // Advisory for now (server soft-enforces — see
+                // `SessionController.register`), but solved unconditionally so every
+                // client is already sending it once the server starts requiring it.
+                const powNonce = await solveRegistrationPow(publicKey, timestamp);
                 const res = await this.makeRequest('POST', '/auth/register', {
                     publicKey,
                     signature,
                     timestamp,
+                    powNonce,
                 }, { cache: false, skipAuth: true });
                 if (!res || (typeof res === 'object' && Object.keys(res).length === 0)) {
                     throw new OxyAuthenticationError('Registration failed', 'REGISTER_FAILED', 400);

package/dist/esm/mixins/OxyServices.identityBackup.js

@@ -118,7 +118,7 @@ export function OxyServicesIdentityBackupMixin(Base) {
          *
          * NATIVE-ONLY persistence: `KeyManager.importKeyPair` throws on web. It also
          * refuses to clobber a DIFFERENT existing on-device identity unless
-         * `overwrite: true` — the {@link import('../crypto/keyManager').IdentityAlreadyExistsError}
+         * `overwrite: true` — the {@link import('../crypto/keyManager.js').IdentityAlreadyExistsError}
          * propagates to the caller (never swallowed) so the UI can confirm before
          * overwriting.
          *

package/dist/esm/server/workloadIdentity.client.js

@@ -0,0 +1,7 @@
+/** Workload attestation belongs to a Node host, never a browser or device. */
+export function canAttestWorkloadIdentity() {
+    return false;
+}
+export async function requestWorkloadServiceToken(_options) {
+    throw new Error('Workload identity is only available on a Node host');
+}