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

package/src/api/billing.ts

@@ -1,4 +1,9 @@
-import { personalPlanCheckoutRequestSchema, personalPlanCheckoutResultSchema, type PersonalPlanCheckoutRequest, type PersonalPlanCheckoutResult } from '@oxy.so/contracts';
+import {
+  personalPlanCheckoutRequestSchema,
+  personalPlanCheckoutResultSchema,
+  type PersonalPlanCheckoutRequest,
+  type PersonalPlanCheckoutResult,
+} from '@oxy.so/contracts';
 /**
  * `oxy.billing` — the signed-in user's subscription, wallet and payment history.
  *
@@ -11,15 +16,20 @@ import { personalPlanCheckoutRequestSchema, personalPlanCheckoutResultSchema, ty
  * arrive as ISO-8601 strings.
  */
 import { personalPlanCatalogueSchema, type PersonalPlanCatalogue } from '@oxy.so/contracts';
-import { type SubjectProductAccess,
-	type SubjectProductAccessQuery,
-	subjectProductAccessQuerySchema, subjectProductAccessSchema, } from '@oxy.so/contracts';
 import {
-	type ProductSubscriptionSummary, type SubscriptionCreditGrant, type ProductSubscriptionCancellationResult,
+  type SubjectProductAccess,
+  type SubjectProductAccessQuery,
+  subjectProductAccessQuerySchema,
+  subjectProductAccessSchema,
+} from '@oxy.so/contracts';
+import {
+  type ProductSubscriptionSummary,
+  type SubscriptionCreditGrant,
+  type ProductSubscriptionCancellationResult,
   productSubscriptionCancellationResultSchema,
-	cancelProductSubscriptionSchema,
-	productSubscriptionsResponseSchema,
-	subscriptionCreditGrantsResponseSchema,
+  cancelProductSubscriptionSchema,
+  productSubscriptionsResponseSchema,
+  subscriptionCreditGrantsResponseSchema,
 } from '@oxy.so/contracts';
 import type { OxyContext } from '../client/context';
 
@@ -117,76 +127,108 @@ export interface WalletTransactionsPage {
 export class BillingApi {
   constructor(protected readonly ctx: OxyContext) {}
 
-  async startPersonalPlanCheckout(request: PersonalPlanCheckoutRequest): Promise<PersonalPlanCheckoutResult> {
-    return personalPlanCheckoutResultSchema.parse(await this.ctx.request<unknown>('POST', '/billing/checkout/personal-plan',
-      personalPlanCheckoutRequestSchema.parse(request), { cache: false }));
+  async startPersonalPlanCheckout(
+    request: PersonalPlanCheckoutRequest,
+  ): Promise<PersonalPlanCheckoutResult> {
+    return personalPlanCheckoutResultSchema.parse(
+      await this.ctx.request<unknown>(
+        'POST',
+        '/billing/checkout/personal-plan',
+        personalPlanCheckoutRequestSchema.parse(request),
+        { cache: false },
+      ),
+    );
   }
 
   /** Public versioned personal plans. Discovery never proves customer access. */
   async personalPlans(): Promise<PersonalPlanCatalogue> {
-    return personalPlanCatalogueSchema.parse(await this.ctx.request<unknown>(
-      'GET', '/billing/personal-plans', undefined, { cache: false }));
+    return personalPlanCatalogueSchema.parse(
+      await this.ctx.request<unknown>('GET', '/billing/personal-plans', undefined, {
+        cache: false,
+      }),
+    );
   }
 
   /** Product rights only; requires a production application-bound user session. Never cached. */
   async productAccess(query: SubjectProductAccessQuery): Promise<SubjectProductAccess> {
     const parsed = subjectProductAccessQuerySchema.parse(query);
-    const response = await this.ctx.request<unknown>('GET',
+    const response = await this.ctx.request<unknown>(
+      'GET',
       `/v1/products/${encodeURIComponent(parsed.productId)}/access/${encodeURIComponent(parsed.subjectAccountId)}`,
-      undefined, { cache: false });
+      undefined,
+      { cache: false },
+    );
     return subjectProductAccessSchema.parse(response);
   }
 
-	/** Named commercial sources for the current subject; no inferred plan collapse. */
-	async productSubscriptions(expectedSubjectAccountId?: string): Promise<ProductSubscriptionSummary[]> {
-		return productSubscriptionsResponseSchema.parse(
-			await this.ctx.request<unknown>(
-				"GET",
-				expectedSubjectAccountId ? `/billing/product-subscriptions?expectedSubjectAccountId=${encodeURIComponent(expectedSubjectAccountId)}` : "/billing/product-subscriptions",
-				undefined,
-				{ cache: false },
-			),
-		).subscriptions;
-	}
-
-	/** Per-grant credit provenance; no interpretation of the historical mixed balance. */
-	async creditGrants(): Promise<SubscriptionCreditGrant[]> {
-		return subscriptionCreditGrantsResponseSchema.parse(
-			await this.ctx.request<unknown>(
-				"GET",
-				"/billing/credit-grants",
-				undefined,
-				{ cache: false },
-			),
-		).grants;
-	}
-
-	/** Payer-only named-source cancellation. Resolves on provider acceptance, including pending local reconciliation. Use cancelProductSubscriptionWithStatus for detailed completion state. */
-	async cancelProductSubscription(sourceId: string, expectedSubjectAccountId?: string, actionId?:string): Promise<void> {
-		await this.ctx.request(
-			"POST",
-			"/billing/product-subscriptions/cancel",
-			cancelProductSubscriptionSchema.parse({ sourceId, ...(actionId?{actionId}:{}), ...(expectedSubjectAccountId ? { expectedSubjectAccountId } : {}) }),
-			{ cache: false },
-		);
-	}
+  /** Named commercial sources for the current subject; no inferred plan collapse. */
+  async productSubscriptions(
+    expectedSubjectAccountId?: string,
+  ): Promise<ProductSubscriptionSummary[]> {
+    return productSubscriptionsResponseSchema.parse(
+      await this.ctx.request<unknown>(
+        'GET',
+        expectedSubjectAccountId
+          ? `/billing/product-subscriptions?expectedSubjectAccountId=${encodeURIComponent(expectedSubjectAccountId)}`
+          : '/billing/product-subscriptions',
+        undefined,
+        { cache: false },
+      ),
+    ).subscriptions;
+  }
 
-  /** Provider acceptance versus completed local cancellation, for user-facing flows. */
-  async cancelProductSubscriptionWithStatus(sourceId: string, expectedSubjectAccountId?: string, actionId?:string): Promise<ProductSubscriptionCancellationResult> {
-    return productSubscriptionCancellationResultSchema.parse(await this.ctx.request<unknown>(
-      'POST', '/billing/product-subscriptions/cancel',
-      cancelProductSubscriptionSchema.parse({ sourceId, ...(actionId?{actionId}:{}), ...(expectedSubjectAccountId ? { expectedSubjectAccountId } : {}) }),
+  /** Per-grant credit provenance; no interpretation of the historical mixed balance. */
+  async creditGrants(): Promise<SubscriptionCreditGrant[]> {
+    return subscriptionCreditGrantsResponseSchema.parse(
+      await this.ctx.request<unknown>('GET', '/billing/credit-grants', undefined, { cache: false }),
+    ).grants;
+  }
+
+  /** Payer-only named-source cancellation. Resolves on provider acceptance, including pending local reconciliation. Use cancelProductSubscriptionWithStatus for detailed completion state. */
+  async cancelProductSubscription(
+    sourceId: string,
+    expectedSubjectAccountId?: string,
+    actionId?: string,
+  ): Promise<void> {
+    await this.ctx.request(
+      'POST',
+      '/billing/product-subscriptions/cancel',
+      cancelProductSubscriptionSchema.parse({
+        sourceId,
+        ...(actionId ? { actionId } : {}),
+        ...(expectedSubjectAccountId ? { expectedSubjectAccountId } : {}),
+      }),
       { cache: false },
-    ));
+    );
+  }
+
+  /** Provider acceptance versus completed local cancellation, for user-facing flows. */
+  async cancelProductSubscriptionWithStatus(
+    sourceId: string,
+    expectedSubjectAccountId?: string,
+    actionId?: string,
+  ): Promise<ProductSubscriptionCancellationResult> {
+    return productSubscriptionCancellationResultSchema.parse(
+      await this.ctx.request<unknown>(
+        'POST',
+        '/billing/product-subscriptions/cancel',
+        cancelProductSubscriptionSchema.parse({
+          sourceId,
+          ...(actionId ? { actionId } : {}),
+          ...(expectedSubjectAccountId ? { expectedSubjectAccountId } : {}),
+        }),
+        { cache: false },
+      ),
+    );
   }
 
-	/** The signed-in user's payment history. Never cached. */
-	async payments(): Promise<Payment[]> {
+  /** The signed-in user's payment history. Never cached. */
+  async payments(): Promise<Payment[]> {
     return this.ctx.request<Payment[]>('GET', '/payments/user', undefined, { cache: false });
   }
 
-	/** A user's subscription (default: the signed-in user's). */
-	async subscription(userId?: string): Promise<Subscription> {
+  /** A user's subscription (default: the signed-in user's). */
+  async subscription(userId?: string): Promise<Subscription> {
     const id = this.resolveUserId(userId);
     return this.ctx.request<Subscription>('GET', `/subscription/${id}`, undefined, {
       cache: true,
@@ -194,24 +236,29 @@ export class BillingApi {
     });
   }
 
-	/** A user's wallet (default: the signed-in user's). Cached briefly: the balance moves. */
-	async wallet(userId?: string): Promise<Wallet> {
+  /** A user's wallet (default: the signed-in user's). Cached briefly: the balance moves. */
+  async wallet(userId?: string): Promise<Wallet> {
     const id = this.resolveUserId(userId);
-    return this.ctx.request<Wallet>('GET', `/wallet/${id}`, undefined, { cache: true, cacheTTL: WALLET_TTL });
+    return this.ctx.request<Wallet>('GET', `/wallet/${id}`, undefined, {
+      cache: true,
+      cacheTTL: WALLET_TTL,
+    });
   }
 
-	/** A page of a user's wallet transactions (default: the signed-in user's). Never cached. */
-	async walletTransactions(
+  /** A page of a user's wallet transactions (default: the signed-in user's). Never cached. */
+  async walletTransactions(
     options: { userId?: string; limit?: number; offset?: number } = {},
   ): Promise<WalletTransactionsPage> {
     const id = this.resolveUserId(options.userId);
     const params: Record<string, number> = {};
     if (options.limit) params.limit = options.limit;
     if (options.offset) params.offset = options.offset;
-    return this.ctx.request<WalletTransactionsPage>('GET', `/wallet/transactions/${id}`, params, { cache: false });
+    return this.ctx.request<WalletTransactionsPage>('GET', `/wallet/transactions/${id}`, params, {
+      cache: false,
+    });
   }
 
-	private resolveUserId(userId?: string): string {
+  private resolveUserId(userId?: string): string {
     const id = userId || this.ctx.oxy.session.userId;
     if (!id) throw new Error('User not authenticated');
     return id;

package/src/api/civic.ts

@@ -162,10 +162,15 @@ export class CivicApi {
    * reject — it yields `verified: false`.
    */
   async publicCard(userId: string): Promise<CivicCardResult> {
-    const signed = await this.ctx.request<SignedPublicCard>('GET', `/civic/${encodeURIComponent(userId)}/card`, undefined, {
-      cache: true,
-      cacheTTL: SHORT_TTL,
-    });
+    const signed = await this.ctx.request<SignedPublicCard>(
+      'GET',
+      `/civic/${encodeURIComponent(userId)}/card`,
+      undefined,
+      {
+        cache: true,
+        cacheTTL: SHORT_TTL,
+      },
+    );
     const verified = await verifyPublicCardAttestation(signed.card, signed.attestation);
     return { card: signed.card, attestation: signed.attestation, verified };
   }
@@ -219,7 +224,9 @@ export class CivicApi {
       },
       { collection: ATTEST_COLLECTION, rkey: input.nonce },
     );
-    return this.ctx.request<RealLifeAttestationResult>('POST', '/civic/attestations', envelope, { cache: false });
+    return this.ctx.request<RealLifeAttestationResult>('POST', '/civic/attestations', envelope, {
+      cache: false,
+    });
   }
 
   /**
@@ -240,7 +247,12 @@ export class CivicApi {
       },
       { collection: VOUCH_COLLECTION, rkey: input.subjectDid },
     );
-    const result = await this.ctx.request<VouchResult>('POST', '/civic/personhood/vouch', envelope, { cache: false });
+    const result = await this.ctx.request<VouchResult>(
+      'POST',
+      '/civic/personhood/vouch',
+      envelope,
+      { cache: false },
+    );
     this.sweepPersonhood();
     return result;
   }
@@ -268,10 +280,15 @@ export class CivicApi {
    */
   async personhood(userId?: string): Promise<PersonhoodStatusResult> {
     const id = userId ?? this.myUserId('resolve personhood status');
-    return this.ctx.request<PersonhoodStatusResult>('GET', `/civic/personhood/${encodeURIComponent(id)}`, undefined, {
-      cache: true,
-      cacheTTL: SHORT_TTL,
-    });
+    return this.ctx.request<PersonhoodStatusResult>(
+      'GET',
+      `/civic/personhood/${encodeURIComponent(id)}`,
+      undefined,
+      {
+        cache: true,
+        cacheTTL: SHORT_TTL,
+      },
+    );
   }
 
   /** A vouch / withdraw changes personhood reads and (via `verified`) `/users/me`. */
@@ -298,9 +315,14 @@ export class CivicValidationApi {
 
   /** The signed-in user's pending jury duties. Never cached; `[]` when on no juries. */
   async inbox(): Promise<ValidationRequestSummary[]> {
-    const res = await this.ctx.request<{ requests?: ValidationRequestSummary[] }>('GET', '/civic/validations/inbox', undefined, {
-      cache: false,
-    });
+    const res = await this.ctx.request<{ requests?: ValidationRequestSummary[] }>(
+      'GET',
+      '/civic/validations/inbox',
+      undefined,
+      {
+        cache: false,
+      },
+    );
     return res.requests ?? [];
   }
 
@@ -311,7 +333,11 @@ export class CivicValidationApi {
    *
    * @param payloadHash - The request's canonical payload hash (from the inbox).
    */
-  async vote(requestId: string, payloadHash: string, verdict: ValidationVerdict): Promise<ValidationVoteResult> {
+  async vote(
+    requestId: string,
+    payloadHash: string,
+    verdict: ValidationVerdict,
+  ): Promise<ValidationVoteResult> {
     const envelope = await signOwnChainRecord(
       this.ctx,
       'validation_verdict',
@@ -348,7 +374,9 @@ export class CivicCredentialsApi {
    * base type; an `expiresAt` ISO string becomes epoch ms. NATIVE-ONLY.
    */
   async issue(input: IssueCredentialInput): Promise<CredentialIssueResult> {
-    const types = input.types.includes(CREDENTIAL_BASE_TYPE) ? input.types : [CREDENTIAL_BASE_TYPE, ...input.types];
+    const types = input.types.includes(CREDENTIAL_BASE_TYPE)
+      ? input.types
+      : [CREDENTIAL_BASE_TYPE, ...input.types];
 
     let expiresAtMs: number | undefined;
     if (input.expiresAt !== undefined) {
@@ -369,8 +397,16 @@ export class CivicCredentialsApi {
     // A fresh crypto-random rkey: every credential is its own chain entry.
     const { SignatureService } = await import('../crypto/internal');
     const rkey = await SignatureService.generateChallenge();
-    const envelope = await signOwnChainRecord(this.ctx, 'credential', record, { collection: CREDENTIAL_COLLECTION, rkey });
-    const result = await this.ctx.request<CredentialIssueResult>('POST', '/civic/credentials', envelope, { cache: false });
+    const envelope = await signOwnChainRecord(this.ctx, 'credential', record, {
+      collection: CREDENTIAL_COLLECTION,
+      rkey,
+    });
+    const result = await this.ctx.request<CredentialIssueResult>(
+      'POST',
+      '/civic/credentials',
+      envelope,
+      { cache: false },
+    );
     this.sweep();
     return result;
   }
@@ -381,14 +417,20 @@ export class CivicCredentialsApi {
    *
    * @param holderUserId - The holder's account id (NOT a DID).
    */
-  async list(holderUserId?: string, opts: { status?: CredentialStatus } = {}): Promise<CredentialListResult> {
+  async list(
+    holderUserId?: string,
+    opts: { status?: CredentialStatus } = {},
+  ): Promise<CredentialListResult> {
     const holder = holderUserId ?? this.ctx.oxy.session.userId;
     if (!holder) {
       throw new Error('No authenticated user — cannot list credentials.');
     }
     const base = `/civic/credentials/${encodeURIComponent(holder)}`;
     const url = opts.status ? `${base}?status=${encodeURIComponent(opts.status)}` : base;
-    return this.ctx.request<CredentialListResult>('GET', url, undefined, { cache: true, cacheTTL: SHORT_TTL });
+    return this.ctx.request<CredentialListResult>('GET', url, undefined, {
+      cache: true,
+      cacheTTL: SHORT_TTL,
+    });
   }
 
   /**

package/src/api/contacts.ts

@@ -30,7 +30,10 @@ export class ContactsApi {
    * Which of these hashed contacts are on Oxy. Either list may be empty, not
    * both; at most 200 hashes per list per call (batch larger books).
    */
-  async discover(hashedEmails: string[], hashedPhones: string[]): Promise<ContactDiscoveryResponse> {
+  async discover(
+    hashedEmails: string[],
+    hashedPhones: string[],
+  ): Promise<ContactDiscoveryResponse> {
     return this.ctx.request<ContactDiscoveryResponse>(
       'POST',
       '/contacts/discover',

package/src/api/devices.ts

@@ -57,7 +57,6 @@ export interface SecurityInfo {
   recoveryEmail: string | null;
 }
 
-
 /**
  * The server's `401 account_not_on_device` for a PINNED mint: the requested
  * `accountId` is not (or is no longer) a live account of this device session.
@@ -72,10 +71,11 @@ export class AccountNotOnDeviceError extends Error {
   override readonly name = 'AccountNotOnDeviceError';
   /** HTTP status of the originating response; mirrors the ApiError shape. */
   readonly status = 401;
-  constructor(readonly accountId: string, readonly cause?: unknown) {
-    super(
-      `account_not_on_device: ${accountId} is not a live account of this device session`,
-    );
+  constructor(
+    readonly accountId: string,
+    readonly cause?: unknown,
+  ) {
+    super(`account_not_on_device: ${accountId} is not a live account of this device session`);
   }
 }
 
@@ -94,7 +94,6 @@ function isAccountNotOnDevice(error: unknown): boolean {
   return typeof message === 'string' && message.includes('account_not_on_device');
 }
 
-
 /**
  * The bridge calls share their transport rules with the mint: no bearer
  * (`skipAuth`, so a 401 surfaces directly), one attempt, and never parked
@@ -148,10 +147,15 @@ export class DevicesApi {
    */
   async sessions(sessionId: string): Promise<DeviceLinkedSession[]> {
     // Cache disabled by default to ensure fresh session data
-    return this.ctx.request<DeviceLinkedSession[]>('GET', `/session/device/sessions/${sessionId}`, undefined, {
-      cache: false, // Don't cache sessions - always get fresh data
-      deduplicate: true, // Deduplicate concurrent requests for same sessionId
-    });
+    return this.ctx.request<DeviceLinkedSession[]>(
+      'GET',
+      `/session/device/sessions/${sessionId}`,
+      undefined,
+      {
+        cache: false, // Don't cache sessions - always get fresh data
+        deduplicate: true, // Deduplicate concurrent requests for same sessionId
+      },
+    );
   }
 
   /**
@@ -161,11 +165,20 @@ export class DevicesApi {
    * @param excludeCurrent - Whether to exclude the current session
    * @returns Logout result
    */
-  async logoutAll(sessionId: string, deviceId?: string, excludeCurrent?: boolean): Promise<DeviceLinkedSessionLogoutResponse> {
+  async logoutAll(
+    sessionId: string,
+    deviceId?: string,
+    excludeCurrent?: boolean,
+  ): Promise<DeviceLinkedSessionLogoutResponse> {
     const urlParams: Record<string, string> = {};
     if (deviceId) urlParams.deviceId = deviceId;
     if (excludeCurrent) urlParams.excludeCurrent = 'true';
-    return this.ctx.request<DeviceLinkedSessionLogoutResponse>('POST', `/session/device/logout-all/${sessionId}`, urlParams, { cache: false });
+    return this.ctx.request<DeviceLinkedSessionLogoutResponse>(
+      'POST',
+      `/session/device/logout-all/${sessionId}`,
+      urlParams,
+      { cache: false },
+    );
   }
 
   /**
@@ -174,8 +187,16 @@ export class DevicesApi {
    * @param deviceName - New device name
    * @returns Updated device object
    */
-  async rename(sessionId: string, deviceName: string): Promise<{ success: boolean; message: string; deviceName: string }> {
-    return this.ctx.request('PUT', `/session/device/name/${sessionId}`, { deviceName }, { cache: false });
+  async rename(
+    sessionId: string,
+    deviceName: string,
+  ): Promise<{ success: boolean; message: string; deviceName: string }> {
+    return this.ctx.request(
+      'PUT',
+      `/session/device/name/${sessionId}`,
+      { deviceName },
+      { cache: false },
+    );
   }
 
   /**
@@ -198,7 +219,7 @@ export class DevicesApi {
   async securityActivity(
     limit?: number,
     offset?: number,
-    eventType?: SecurityEventType
+    eventType?: SecurityEventType,
   ): Promise<SecurityActivityResponse> {
     const params: Record<string, unknown> = {};
     if (limit !== undefined) params.limit = limit;
@@ -236,12 +257,16 @@ export class DevicesApi {
         'POST',
         '/security/activity/private-key-exported',
         { deviceId },
-        { cache: false }
+        { cache: false },
       );
     } catch (error) {
       // Don't throw - logging failures shouldn't break user flow, but surface
       // for monitoring via the shared logger sink.
-      logger.warn('[OxyServices] Failed to log private key exported event', { component: 'oxy.devices' }, error);
+      logger.warn(
+        '[OxyServices] Failed to log private key exported event',
+        { component: 'oxy.devices' },
+        error,
+      );
     }
   }
 
@@ -256,12 +281,16 @@ export class DevicesApi {
         'POST',
         '/security/activity/backup-created',
         { deviceId },
-        { cache: false }
+        { cache: false },
       );
     } catch (error) {
       // Don't throw - logging failures shouldn't break user flow, but surface
       // for monitoring via the shared logger sink.
-      logger.warn('[OxyServices] Failed to log backup created event', { component: 'oxy.devices' }, error);
+      logger.warn(
+        '[OxyServices] Failed to log backup created event',
+        { component: 'oxy.devices' },
+        error,
+      );
     }
   }
 
@@ -347,7 +376,12 @@ export class DevicesApi {
    * carries `invalid_device_secret`.
    */
   async requestJoinCode(request: DeviceJoinCodeRequest): Promise<DeviceJoinCodeResponse> {
-    return bridgeRequest(this.ctx, '/session/device/join-code', request, deviceJoinCodeResponseSchema);
+    return bridgeRequest(
+      this.ctx,
+      '/session/device/join-code',
+      request,
+      deviceJoinCodeResponseSchema,
+    );
   }
 
   /**
@@ -434,5 +468,4 @@ export class DevicesApi {
       throw error;
     }
   }
-
 }