@oxy.so/protocol 1.1.4 → 1.2.0

package/dist/esm/index.js

@@ -37,4 +37,4 @@ export { isAuthorizedKey } from './identity/resolver.js';
 // Platform — runtime predicates + lazy crypto/storage loaders
 // ---------------------------------------------------------------------------
 export { isReactNative, isNodeJS } from './platform/platform.js';
-export { loadNodeCrypto, loadExpoCrypto, loadSecureStore, loadAsyncStorage, getRandomBytesRN, loadSharedIdentityBridge, } from './platform/crypto.js';
+export { loadNodeCrypto, loadExpoCrypto, loadSecureStore, loadAsyncStorage, getRandomBytesRN, loadCommonsIdentityBridge, } from './platform/crypto.js';

package/dist/esm/platform/crypto.js

@@ -128,13 +128,10 @@ export async function loadAsyncStorage() {
 // `@oxy.so/protocol/random` entry without evaluating any crypto library first.
 export { getRandomBytesRN } from './random.js';
 // ---------------------------------------------------------------------------
-// Shared identity bridge — `@oxy.so/expo-oxy-identity` (native-only).
+// Commons identity bridge — the `OxyIdentity` native module (native-only).
 //
-// The default (web / Node) variant has no cross-app identity channel, so this
-// always resolves to `null`. `@oxy.so/core`'s `KeyManager` treats `null` as "no
-// bridge" and falls back to its package-private store — which is correct on web
-// (there is no shared identity there).
+// Web and Node have no Commons to ask, so this always resolves to `null`.
 // ---------------------------------------------------------------------------
-export function loadSharedIdentityBridge() {
+export function loadCommonsIdentityBridge() {
     return Promise.resolve(null);
 }

package/dist/esm/platform/crypto.native.js

@@ -123,41 +123,71 @@ export async function loadAsyncStorage() {
 // any crypto library first. The explicit `.native` specifier keeps tsc and
 // Metro pointed at the same file.
 export { getRandomBytesRN } from './random.native.js';
-// ---------------------------------------------------------------------------
-// Shared identity bridge — `@oxy.so/expo-oxy-identity` (native-only, OPTIONAL).
-//
-// `@oxy.so/expo-oxy-identity` is the in-repo Expo module autolinked into the
-// identity apps (Commons + the reader RPs). We resolve its NATIVE module
-// directly via expo-modules-core's `requireOptionalNativeModule('OxyIdentity')`
-// — a static import Metro always resolves — instead of dynamically importing the
-// module's JS wrapper. A runtime-computed `import(moduleName)` compiled to a
-// `require(variable)` in the CJS build, which Metro cannot resolve in a consuming
-// repo (the bridge silently resolved `null` there — the cross-app SSO bug). Since
-// the native module is what actually holds the shared identity, going through the
-// native registry is both correct and Metro-safe. `requireOptionalNativeModule`
-// returns `null` (never throws) when the module is not autolinked (web, or apps
-// that don't ship it), so `@oxy.so/core`'s `KeyManager` cleanly falls back to its
-// package-private store.
-// ---------------------------------------------------------------------------
-let sharedIdentityBridgePromise = null;
-export function loadSharedIdentityBridge() {
-    if (!sharedIdentityBridgePromise) {
-        sharedIdentityBridgePromise = Promise.resolve().then(() => {
+const LOWER_HEX = /^[0-9a-f]+$/;
+function record(value) {
+    return typeof value === 'object' && value !== null ? value : null;
+}
+function hexField(value, length) {
+    if (typeof value !== 'string' || !LOWER_HEX.test(value))
+        return null;
+    if (length !== undefined && value.length !== length)
+        return null;
+    return value;
+}
+function narrowDescription(value) {
+    const r = record(value);
+    const publicKey = hexField(r?.publicKey, 130);
+    const v = typeof r?.v === 'number' ? r.v : Number(r?.v);
+    if (!publicKey || !Number.isInteger(v))
+        return null;
+    return { v, publicKey };
+}
+function narrowProof(value) {
+    const r = record(value);
+    const publicKey = hexField(r?.publicKey, 130);
+    const signature = hexField(r?.signature);
+    const timestamp = typeof r?.timestamp === 'number' ? r.timestamp : Number(r?.timestamp);
+    if (!publicKey || !signature || !Number.isSafeInteger(timestamp) || timestamp <= 0)
+        return null;
+    return { publicKey, signature, timestamp };
+}
+function narrowSocialReceive(value) {
+    const r = record(value);
+    const signature = hexField(r?.signature);
+    const publicKey = hexField(r?.publicKey, 66);
+    if (!signature || !publicKey)
+        return null;
+    return { signature, publicKey };
+}
+/** Run one native call; a rejection or an unexpected shape is `null`. */
+async function ask(call, narrow) {
+    try {
+        return narrow(await call());
+    }
+    catch {
+        return null;
+    }
+}
+let commonsIdentityBridgePromise = null;
+export function loadCommonsIdentityBridge() {
+    if (!commonsIdentityBridgePromise) {
+        commonsIdentityBridgePromise = Promise.resolve().then(() => {
             const native = requireOptionalNativeModule('OxyIdentity');
-            if (native &&
-                typeof native.getShared === 'function' &&
-                typeof native.putShared === 'function' &&
-                typeof native.hasShared === 'function' &&
-                typeof native.clearShared === 'function') {
-                return {
-                    getShared: native.getShared.bind(native),
-                    putShared: native.putShared.bind(native),
-                    hasShared: native.hasShared.bind(native),
-                    clearShared: native.clearShared.bind(native),
-                };
+            if (!native ||
+                typeof native.describe !== 'function' ||
+                typeof native.proveIdentity !== 'function' ||
+                typeof native.deriveScopedSeed !== 'function' ||
+                typeof native.signSocialReceive !== 'function') {
+                return null;
             }
-            return null;
+            const m = native;
+            return {
+                describe: () => ask(() => m.describe(), narrowDescription),
+                proveIdentity: (challenge) => ask(() => m.proveIdentity(challenge), narrowProof),
+                deriveScopedSeed: (info) => ask(() => m.deriveScopedSeed(info), (v) => hexField(v, 64)),
+                signSocialReceive: (index, digest) => ask(() => m.signSocialReceive(index, digest), narrowSocialReceive),
+            };
         });
     }
-    return sharedIdentityBridgePromise;
+    return commonsIdentityBridgePromise;
 }

package/dist/esm/secp256k1.js

@@ -127,6 +127,29 @@ export function verifySecp256k1Digest(publicKeyHex, digestHex, signatureDerHex)
         lowS: false,
     });
 }
+/**
+ * `(privateKey + tweak) mod n`, the scalar step of BIP32 non-hardened child
+ * derivation (`CKDpriv`: the tweak is `IL`, the left half of the HMAC-SHA512).
+ *
+ * Throws, as BIP32 requires, when the tweak is not below the curve order or
+ * the sum is zero: that child is invalid and the caller must not use it.
+ */
+export function tweakAddSecp256k1PrivateKey(privateKeyHex, tweakHex) {
+    const n = secp256k1.Point.Fn.ORDER;
+    const key = BigInt(`0x${normalizeSecp256k1PrivateKey(privateKeyHex)}`);
+    if (typeof tweakHex !== "string" || tweakHex.length !== 64 || !HEX.test(tweakHex)) {
+        throw new Error("secp256k1 tweak must be exactly 32 bytes of hexadecimal data");
+    }
+    const tweak = BigInt(`0x${tweakHex}`);
+    if (tweak >= n) {
+        throw new Error("secp256k1 tweak is not below the curve order");
+    }
+    const child = (key + tweak) % n;
+    if (child === 0n) {
+        throw new Error("secp256k1 tweaked private key is zero");
+    }
+    return child.toString(16).padStart(64, "0");
+}
 /** Derive the fixed-width 32-byte ECDH x-coordinate shared secret. */
 export function deriveSecp256k1SharedSecret(privateKeyHex, publicKeyHex) {
     const encodedPoint = secp256k1.getSharedSecret(parsePrivateKey(privateKeyHex), parsePublicKey(publicKeyHex), true);