@oxy.so/core 4.5.0-oxy-one.1 → 4.5.0

package/src/api/follows.ts

@@ -128,7 +128,12 @@ export class FollowsApi {
 
   /** Follow a user. */
   async follow(userId: string): Promise<FollowMutationResult> {
-    const result = await this.ctx.request<FollowMutationResult>('POST', `/users/${userId}/follow`, undefined, { cache: false });
+    const result = await this.ctx.request<FollowMutationResult>(
+      'POST',
+      `/users/${userId}/follow`,
+      undefined,
+      { cache: false },
+    );
     this.invalidate([userId]);
     return result;
   }
@@ -136,14 +141,24 @@ export class FollowsApi {
   /** Follow many users in one request (the server caps it at 200). */
   async followMany(userIds: string[]): Promise<BulkFollowResult> {
     if (userIds.length === 0) return { results: [], followedCount: 0 };
-    const result = await this.ctx.request<BulkFollowResult>('POST', '/users/follow/bulk', { userIds }, { cache: false });
+    const result = await this.ctx.request<BulkFollowResult>(
+      'POST',
+      '/users/follow/bulk',
+      { userIds },
+      { cache: false },
+    );
     this.invalidate(userIds);
     return result;
   }
 
   /** Unfollow a user. */
   async unfollow(userId: string): Promise<FollowMutationResult> {
-    const result = await this.ctx.request<FollowMutationResult>('DELETE', `/users/${userId}/follow`, undefined, { cache: false });
+    const result = await this.ctx.request<FollowMutationResult>(
+      'DELETE',
+      `/users/${userId}/follow`,
+      undefined,
+      { cache: false },
+    );
     this.invalidate([userId]);
     return result;
   }
@@ -151,14 +166,22 @@ export class FollowsApi {
   /** Unfollow many users in one request (the server caps it at 200). */
   async unfollowMany(userIds: string[]): Promise<BulkUnfollowResult> {
     if (userIds.length === 0) return { results: [], unfollowedCount: 0 };
-    const result = await this.ctx.request<BulkUnfollowResult>('POST', '/users/unfollow/bulk', { userIds }, { cache: false });
+    const result = await this.ctx.request<BulkUnfollowResult>(
+      'POST',
+      '/users/unfollow/bulk',
+      { userIds },
+      { cache: false },
+    );
     this.invalidate(userIds);
     return result;
   }
 
   /** Whether the signed-in user follows `userId`. Cached 1 minute, busted by every write. */
   async status(userId: string): Promise<{ isFollowing: boolean }> {
-    return this.ctx.request('GET', `/users/${userId}/follow-status`, undefined, { cache: true, cacheTTL: STATUS_TTL });
+    return this.ctx.request('GET', `/users/${userId}/follow-status`, undefined, {
+      cache: true,
+      cacheTTL: STATUS_TTL,
+    });
   }
 
   /**
@@ -222,10 +245,15 @@ export class FollowsApi {
    * Signed out: `[]`. Cached 2 minutes.
    */
   async mutualIds(params?: { limit?: number }): Promise<string[]> {
-    const response = await this.ctx.request<{ data: string[] }>('GET', '/users/mutual-ids', buildPaginationParams(params ?? {}), {
-      cache: true,
-      cacheTTL: GRAPH_TTL,
-    });
+    const response = await this.ctx.request<{ data: string[] }>(
+      'GET',
+      '/users/mutual-ids',
+      buildPaginationParams(params ?? {}),
+      {
+        cache: true,
+        cacheTTL: GRAPH_TTL,
+      },
+    );
     return response.data || [];
   }
 
@@ -249,10 +277,15 @@ export class FollowsApi {
    * Cached 2 minutes; follow, block and restrict writes bust it.
    */
   async viewerGraph(): Promise<ViewerGraph> {
-    const response = await this.ctx.request<{ data: ViewerGraph }>('GET', '/users/me/graph', undefined, {
-      cache: true,
-      cacheTTL: GRAPH_TTL,
-    });
+    const response = await this.ctx.request<{ data: ViewerGraph }>(
+      'GET',
+      '/users/me/graph',
+      undefined,
+      {
+        cache: true,
+        cacheTTL: GRAPH_TTL,
+      },
+    );
     const graph = response.data;
     return {
       followingIds: graph?.followingIds || [],
@@ -284,9 +317,14 @@ export class FollowsApi {
    * 'disabled')`.) Idempotent: `removed: false` when already gone.
    */
   async unfollowTarget(relationshipId: string): Promise<UnfollowMutation> {
-    return this.ctx.request<UnfollowMutation>('DELETE', `/v2/follows/${encodeURIComponent(relationshipId)}`, undefined, {
-      cache: false,
-    });
+    return this.ctx.request<UnfollowMutation>(
+      'DELETE',
+      `/v2/follows/${encodeURIComponent(relationshipId)}`,
+      undefined,
+      {
+        cache: false,
+      },
+    );
   }
 
   /**
@@ -294,9 +332,14 @@ export class FollowsApi {
    * `effectiveState`; keep the other two for the explanation.
    */
   async targetStatus(targetId: string): Promise<FollowStatus> {
-    return this.ctx.request<FollowStatus>('GET', `/v2/follows/${encodeURIComponent(targetId)}/status`, undefined, {
-      cache: false,
-    });
+    return this.ctx.request<FollowStatus>(
+      'GET',
+      `/v2/follows/${encodeURIComponent(targetId)}/status`,
+      undefined,
+      {
+        cache: false,
+      },
+    );
   }
 
   /**
@@ -334,13 +377,20 @@ export class FollowsApi {
    * on the URI, so two applications describing the same thing reach ONE row.
    * `metadata` is a display snapshot refreshed only by the providing app.
    */
-  async ensureTarget(input: EnsureFollowTargetInput): Promise<{ id: string; uri: string; kind: string; created: boolean }> {
+  async ensureTarget(
+    input: EnsureFollowTargetInput,
+  ): Promise<{ id: string; uri: string; kind: string; created: boolean }> {
     return this.ctx.request('POST', '/v2/follow-targets', input, { cache: false });
   }
 
   /** Claim a namespace for the calling application (first come; idempotent for the holder). */
   async claimNamespace(namespace: string): Promise<{ namespace: string; created: boolean }> {
-    return this.ctx.request('POST', '/v2/follow-targets/namespaces', { namespace }, { cache: false });
+    return this.ctx.request(
+      'POST',
+      '/v2/follow-targets/namespaces',
+      { namespace },
+      { cache: false },
+    );
   }
 
   /**
@@ -348,9 +398,14 @@ export class FollowsApi {
    * registered in it. Idempotent (`released: false` when already unowned).
    */
   async releaseNamespace(namespace: string): Promise<{ namespace: string; released: boolean }> {
-    return this.ctx.request('DELETE', `/v2/follow-targets/namespaces/${encodeURIComponent(namespace)}`, undefined, {
-      cache: false,
-    });
+    return this.ctx.request(
+      'DELETE',
+      `/v2/follow-targets/namespaces/${encodeURIComponent(namespace)}`,
+      undefined,
+      {
+        cache: false,
+      },
+    );
   }
 
   /**
@@ -380,13 +435,15 @@ export class FollowsApi {
     path: string,
     params?: FollowGraphParams,
   ): Promise<{ data: User[]; total: number; hasMore: boolean }> {
-    const response = await this.ctx.request<{ data: User[]; pagination: { total: number; hasMore: boolean } }>(
-      'GET',
-      path,
-      buildQueryParams(params ?? {}),
-      { cache: true, cacheTTL: GRAPH_TTL },
-    );
-    return { data: response.data || [], total: response.pagination.total, hasMore: response.pagination.hasMore };
+    const response = await this.ctx.request<{
+      data: User[];
+      pagination: { total: number; hasMore: boolean };
+    }>('GET', path, buildQueryParams(params ?? {}), { cache: true, cacheTTL: GRAPH_TTL });
+    return {
+      data: response.data || [],
+      total: response.pagination.total,
+      hasMore: response.pagination.hasMore,
+    };
   }
 
   /**

package/src/api/identity.ts

@@ -192,10 +192,15 @@ export class IdentityApi {
    * document. Public (no auth required); short-TTL cached.
    */
   async resolveDid(userId: string): Promise<DidDocument> {
-    return this.ctx.request<DidDocument>('GET', `/u/${encodeURIComponent(userId)}/did.json`, undefined, {
-      cache: true,
-      cacheTTL: SHORT_TTL,
-    });
+    return this.ctx.request<DidDocument>(
+      'GET',
+      `/u/${encodeURIComponent(userId)}/did.json`,
+      undefined,
+      {
+        cache: true,
+        cacheTTL: SHORT_TTL,
+      },
+    );
   }
 
   /**
@@ -204,7 +209,10 @@ export class IdentityApi {
    * verification-method fragment.
    */
   async authMethods(): Promise<AuthMethodsResponse> {
-    return this.ctx.request<AuthMethodsResponse>('GET', '/auth/methods', undefined, { cache: true, cacheTTL: SHORT_TTL });
+    return this.ctx.request<AuthMethodsResponse>('GET', '/auth/methods', undefined, {
+      cache: true,
+      cacheTTL: SHORT_TTL,
+    });
   }
 
   /**
@@ -212,7 +220,9 @@ export class IdentityApi {
    * linked (self-custody), or the email of an account without a key.
    */
   async rootStatus(): Promise<IdentityRootStatus> {
-    return this.ctx.request<IdentityRootStatus>('GET', '/identity/root-status', undefined, { cache: false });
+    return this.ctx.request<IdentityRootStatus>('GET', '/identity/root-status', undefined, {
+      cache: false,
+    });
   }
 
   /**
@@ -250,11 +260,14 @@ export class IdentityApi {
       throw new Error('No authenticated user — sign in before rotating your key.');
     }
 
-    const { KeyManager, RecoveryPhraseService, SignatureService, signMessage } = await import('../crypto/internal');
+    const { KeyManager, RecoveryPhraseService, SignatureService, signMessage } = await import(
+      '../crypto/internal'
+    );
 
     // 1. The NEW identity (in memory only). The UI may pre-derive + pre-show
     //    it and pass it back here so the phrase shown === the phrase committed.
-    const pending = options.pendingIdentity ?? (await RecoveryPhraseService.derivePendingIdentity());
+    const pending =
+      options.pendingIdentity ?? (await RecoveryPhraseService.derivePendingIdentity());
     const newPublicKey = pending.publicKey;
 
     // 2. Resolve the OLD signing capability from the chosen proof mode.
@@ -271,16 +284,23 @@ export class IdentityApi {
     } else {
       const currentPublicKey = await KeyManager.getPublicKey();
       if (!currentPublicKey) {
-        throw new Error('No on-device identity found. Use the recovery-phrase option to rotate your key.');
+        throw new Error(
+          'No on-device identity found. Use the recovery-phrase option to rotate your key.',
+        );
       }
       oldPublicKey = currentPublicKey;
       signWithOldKey = (message) => SignatureService.sign(message);
     }
 
     // 3. Request a single-use rotate_key challenge (bearer).
-    const { challenge } = await this.ctx.request<RotateKeyChallengeResponse>('POST', '/auth/rotate/challenge', undefined, {
-      cache: false,
-    });
+    const { challenge } = await this.ctx.request<RotateKeyChallengeResponse>(
+      'POST',
+      '/auth/rotate/challenge',
+      undefined,
+      {
+        cache: false,
+      },
+    );
 
     // 4. Sign the rotation proofs. The OLD key proves control of the key being
     //    replaced; the NEW key proves possession of the key being rotated in.
@@ -406,7 +426,9 @@ export class IdentityApi {
    */
   private async rotationAlreadyApplied(userId: string, newPublicKey: string): Promise<boolean> {
     return this.ctx
-      .request<DidDocument>('GET', `/u/${encodeURIComponent(userId)}/did.json`, undefined, { cache: false })
+      .request<DidDocument>('GET', `/u/${encodeURIComponent(userId)}/did.json`, undefined, {
+        cache: false,
+      })
       .then((doc) =>
         doc.verificationMethod.some(
           (vm) =>
@@ -442,7 +464,9 @@ export class IdentityLinksApi {
    * The "Link Commons" panel shows its `qrPayload`; Commons scans it and signs with `sign`.
    */
   async create(): Promise<IdentityLinkCreateResponse> {
-    const res = await this.ctx.request<unknown>('POST', '/identity/link', undefined, { cache: false });
+    const res = await this.ctx.request<unknown>('POST', '/identity/link', undefined, {
+      cache: false,
+    });
     const parsed = safeParseContract(identityLinkCreateResponseSchema, res);
     if (!parsed) throw new Error('identity/link returned an unexpected response shape');
     return parsed;
@@ -450,10 +474,15 @@ export class IdentityLinksApi {
 
   /** Where a link request stands. Both devices poll it; it needs no session. */
   async get(linkId: string): Promise<IdentityLinkState> {
-    const res = await this.ctx.request<unknown>('GET', `/identity/link/${encodeURIComponent(linkId)}`, undefined, {
-      cache: false,
-      skipAuth: true,
-    });
+    const res = await this.ctx.request<unknown>(
+      'GET',
+      `/identity/link/${encodeURIComponent(linkId)}`,
+      undefined,
+      {
+        cache: false,
+        skipAuth: true,
+      },
+    );
     const parsed = safeParseContract(identityLinkStateSchema, res);
     if (!parsed) throw new Error('identity/link returned an unexpected response shape');
     return parsed;
@@ -464,9 +493,17 @@ export class IdentityLinksApi {
    * device's identity key and post it. NATIVE-ONLY. Resolves to the key and the
    * 6-digit code the other screen will show for it, for the person to compare.
    */
-  async sign(linkId: string, challenge: string): Promise<{ publicKey: string; code: string; username: string | null }> {
-    const { KeyManager, signIdentityProof, deriveIdentityLinkCode } = await import('../crypto/internal');
-    const [privateKey, publicKey] = await Promise.all([KeyManager.getPrivateKey(), KeyManager.getPublicKey()]);
+  async sign(
+    linkId: string,
+    challenge: string,
+  ): Promise<{ publicKey: string; code: string; username: string | null }> {
+    const { KeyManager, signIdentityProof, deriveIdentityLinkCode } = await import(
+      '../crypto/internal'
+    );
+    const [privateKey, publicKey] = await Promise.all([
+      KeyManager.getPrivateKey(),
+      KeyManager.getPublicKey(),
+    ]);
     if (!privateKey || !publicKey) {
       throw new Error('No identity on this device to link');
     }
@@ -492,7 +529,11 @@ export class IdentityLinksApi {
       { publicKey: root, proof },
       { cache: false, skipAuth: true },
     );
-    return { publicKey: root, code: deriveIdentityLinkCode(linkId, root), username: state.username };
+    return {
+      publicKey: root,
+      code: deriveIdentityLinkCode(linkId, root),
+      username: state.username,
+    };
   }
 
   /**
@@ -517,7 +558,12 @@ export class IdentityLinksApi {
 
   /** Withdraw a link request that has not completed. */
   async cancel(linkId: string): Promise<void> {
-    await this.ctx.request<unknown>('DELETE', `/identity/link/${encodeURIComponent(linkId)}`, undefined, { cache: false });
+    await this.ctx.request<unknown>(
+      'DELETE',
+      `/identity/link/${encodeURIComponent(linkId)}`,
+      undefined,
+      { cache: false },
+    );
   }
 }
 
@@ -534,7 +580,12 @@ export class IdentityDomainsApi {
    * `verify`.
    */
   async requestVerification(domain: string): Promise<DomainVerificationInstructions> {
-    return this.ctx.request<DomainVerificationInstructions>('POST', '/identity/domains', { domain }, { cache: false });
+    return this.ctx.request<DomainVerificationInstructions>(
+      'POST',
+      '/identity/domains',
+      { domain },
+      { cache: false },
+    );
   }
 
   /**
@@ -555,10 +606,15 @@ export class IdentityDomainsApi {
 
   /** The signed-in user's verified domains. */
   async list(): Promise<VerifiedDomain[]> {
-    const res = await this.ctx.request<{ domains?: VerifiedDomain[] }>('GET', '/identity/domains', undefined, {
-      cache: true,
-      cacheTTL: SHORT_TTL,
-    });
+    const res = await this.ctx.request<{ domains?: VerifiedDomain[] }>(
+      'GET',
+      '/identity/domains',
+      undefined,
+      {
+        cache: true,
+        cacheTTL: SHORT_TTL,
+      },
+    );
     return res.domains ?? [];
   }
 
@@ -649,7 +705,8 @@ export class IdentityBackupApi {
    * from SecureStore.
    */
   async create(phrase: string): Promise<BackupStatusResponse> {
-    const { KeyManager, RecoveryPhraseService, BACKUP_KDF_ENCRYPTION_INFO, encryptAead } = await import('../crypto/internal');
+    const { KeyManager, RecoveryPhraseService, BACKUP_KDF_ENCRYPTION_INFO, encryptAead } =
+      await import('../crypto/internal');
     const { backupKey, lookupId } = await RecoveryPhraseService.deriveBackupMaterial(phrase);
     const privateKey = await RecoveryPhraseService.derivePrivateKeyFromPhrase(phrase);
     const publicKey = KeyManager.derivePublicKey(privateKey);
@@ -672,7 +729,9 @@ export class IdentityBackupApi {
       lookupId,
     };
 
-    return this.ctx.request<BackupStatusResponse>('POST', '/identity/backup', body, { cache: false });
+    return this.ctx.request<BackupStatusResponse>('POST', '/identity/backup', body, {
+      cache: false,
+    });
   }
 
   /**
@@ -680,12 +739,16 @@ export class IdentityBackupApi {
    * and timestamp. Returns no ciphertext and no locator.
    */
   async status(): Promise<BackupStatusResponse> {
-    return this.ctx.request<BackupStatusResponse>('GET', '/identity/backup/status', undefined, { cache: false });
+    return this.ctx.request<BackupStatusResponse>('GET', '/identity/backup/status', undefined, {
+      cache: false,
+    });
   }
 
   /** Delete the signed-in user's stored backup. Idempotent. */
   async delete(): Promise<{ success: boolean }> {
-    return this.ctx.request<{ success: boolean }>('DELETE', '/identity/backup', undefined, { cache: false });
+    return this.ctx.request<{ success: boolean }>('DELETE', '/identity/backup', undefined, {
+      cache: false,
+    });
   }
 
   /**
@@ -718,7 +781,12 @@ export class IdentityBackupApi {
     }
 
     const aad = buildBackupAad(envelope.version, envelope.publicKeyHint);
-    const plaintext = decryptAead(backupKey, fromHex(envelope.nonce), fromHex(envelope.ciphertext), aad);
+    const plaintext = decryptAead(
+      backupKey,
+      fromHex(envelope.nonce),
+      fromHex(envelope.ciphertext),
+      aad,
+    );
     const payload = JSON.parse(new TextDecoder().decode(plaintext)) as BackupPayload;
 
     if (!payload.privateKey || !payload.publicKey) {

package/src/api/linkedAccounts.ts

@@ -37,7 +37,10 @@ export class LinkedAccountsApi {
    *   to be sent back to your app afterwards.
    * @returns The URL to open, and when the attempt expires (ten minutes).
    */
-  async start(network: LinkedAccountNetwork, options: StartLinkedAccountRequest): Promise<StartLinkedAccountResponse> {
+  async start(
+    network: LinkedAccountNetwork,
+    options: StartLinkedAccountRequest,
+  ): Promise<StartLinkedAccountResponse> {
     return this.ctx.request<StartLinkedAccountResponse>(
       'POST',
       `/linked-accounts/${encodeURIComponent(network)}/start`,
@@ -53,15 +56,25 @@ export class LinkedAccountsApi {
    * Repeating it within the code's five minutes returns the same link.
    */
   async complete(code: string): Promise<LinkedAccount> {
-    const res = await this.ctx.request<CompleteLinkedAccountResponse>('POST', '/linked-accounts/complete', { code }, {
-      cache: false,
-    });
+    const res = await this.ctx.request<CompleteLinkedAccountResponse>(
+      'POST',
+      '/linked-accounts/complete',
+      { code },
+      {
+        cache: false,
+      },
+    );
     return res.linkedAccount;
   }
 
   /** The current user's live linked accounts, oldest first. */
   async list(): Promise<LinkedAccount[]> {
-    const res = await this.ctx.request<LinkedAccountListResponse>('GET', '/linked-accounts', undefined, { cache: false });
+    const res = await this.ctx.request<LinkedAccountListResponse>(
+      'GET',
+      '/linked-accounts',
+      undefined,
+      { cache: false },
+    );
     return res.linkedAccounts;
   }
 
@@ -71,8 +84,13 @@ export class LinkedAccountsApi {
    * linked to another Oxy account.
    */
   async revoke(linkedAccountId: string): Promise<void> {
-    await this.ctx.request<void>('DELETE', `/linked-accounts/${encodeURIComponent(linkedAccountId)}`, undefined, {
-      cache: false,
-    });
+    await this.ctx.request<void>(
+      'DELETE',
+      `/linked-accounts/${encodeURIComponent(linkedAccountId)}`,
+      undefined,
+      {
+        cache: false,
+      },
+    );
   }
 }

package/src/api/nodes.ts

@@ -126,16 +126,23 @@ export class NodesApi {
 
   /** The signed-in user's node status, or `null` when they have none. Short-TTL cached. */
   async mine(): Promise<UserNodeStatus | null> {
-    const res = await this.ctx.request<{ node: UserNodeStatus | null }>('GET', '/nodes/me', undefined, {
-      cache: true,
-      cacheTTL: SHORT_TTL,
-    });
+    const res = await this.ctx.request<{ node: UserNodeStatus | null }>(
+      'GET',
+      '/nodes/me',
+      undefined,
+      {
+        cache: true,
+        cacheTTL: SHORT_TTL,
+      },
+    );
     return res.node ?? null;
   }
 
   /** Revoke the signed-in user's node registration. */
   async removeMine(): Promise<RemoveNodeResult> {
-    const res = await this.ctx.request<{ success: boolean }>('DELETE', '/nodes/me', undefined, { cache: false });
+    const res = await this.ctx.request<{ success: boolean }>('DELETE', '/nodes/me', undefined, {
+      cache: false,
+    });
     this.sweep();
     return { revoked: res.success === true };
   }
@@ -145,7 +152,12 @@ export class NodesApi {
    * user. Idempotent server-side; the owner comes from the session.
    */
   async provisionManagedVault(): Promise<UserNodeStatus> {
-    const res = await this.ctx.request<{ node: UserNodeStatus }>('POST', '/nodes/managed', undefined, { cache: false });
+    const res = await this.ctx.request<{ node: UserNodeStatus }>(
+      'POST',
+      '/nodes/managed',
+      undefined,
+      { cache: false },
+    );
     this.sweep();
     return res.node;
   }

package/src/api/notifications.ts

@@ -57,14 +57,24 @@ export class NotificationsApi {
 
   /** One page of the inbox, newest first, with the unread count across all pages. */
   async list(params: { page?: number; limit?: number } = {}): Promise<NotificationPage> {
-    return this.ctx.request<NotificationPage>('GET', '/notifications', buildQueryParams({ page: params.page, limit: params.limit }), {
-      cache: false,
-    });
+    return this.ctx.request<NotificationPage>(
+      'GET',
+      '/notifications',
+      buildQueryParams({ page: params.page, limit: params.limit }),
+      {
+        cache: false,
+      },
+    );
   }
 
   /** How many notifications are unread. */
   async unreadCount(): Promise<number> {
-    const res = await this.ctx.request<{ unreadCount: number }>('GET', '/notifications/unread-count', undefined, { cache: false });
+    const res = await this.ctx.request<{ unreadCount: number }>(
+      'GET',
+      '/notifications/unread-count',
+      undefined,
+      { cache: false },
+    );
     return res.unreadCount;
   }
 
@@ -90,7 +100,12 @@ export class NotificationsApi {
 
   /** Delete one notification. */
   async delete(notificationId: string): Promise<void> {
-    await this.ctx.request('DELETE', `/notifications/${encodeURIComponent(notificationId)}`, undefined, { cache: false });
+    await this.ctx.request(
+      'DELETE',
+      `/notifications/${encodeURIComponent(notificationId)}`,
+      undefined,
+      { cache: false },
+    );
   }
 
   // ── Push tokens ──────────────────────────────────────────────────────────
@@ -130,6 +145,11 @@ export class NotificationsApi {
    * no longer holds.
    */
   async unregisterPushToken(expoPushToken: string): Promise<void> {
-    await this.ctx.request('DELETE', '/notifications/push-token', { token: expoPushToken }, { cache: false });
+    await this.ctx.request(
+      'DELETE',
+      '/notifications/push-token',
+      { token: expoPushToken },
+      { cache: false },
+    );
   }
 }