@oxy.so/core 1.18.1 → 3.0.0

package/dist/cjs/api/billing.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BillingApi = void 0;
+const SUBSCRIPTION_TTL = 2 * 60 * 1000;
+const WALLET_TTL = 60 * 1000;
+class BillingApi {
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    /** The signed-in user's payment history. Never cached. */
+    async payments() {
+        return this.ctx.request('GET', '/payments/user', undefined, { cache: false });
+    }
+    /** A user's subscription (default: the signed-in user's). */
+    async subscription(userId) {
+        const id = this.resolveUserId(userId);
+        return this.ctx.request('GET', `/subscription/${id}`, undefined, {
+            cache: true,
+            cacheTTL: SUBSCRIPTION_TTL,
+        });
+    }
+    /** A user's wallet (default: the signed-in user's). Cached briefly: the balance moves. */
+    async wallet(userId) {
+        const id = this.resolveUserId(userId);
+        return this.ctx.request('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(options = {}) {
+        const id = this.resolveUserId(options.userId);
+        const params = {};
+        if (options.limit)
+            params.limit = options.limit;
+        if (options.offset)
+            params.offset = options.offset;
+        return this.ctx.request('GET', `/wallet/transactions/${id}`, params, { cache: false });
+    }
+    resolveUserId(userId) {
+        const id = userId || this.ctx.oxy.session.userId;
+        if (!id)
+            throw new Error('User not authenticated');
+        return id;
+    }
+}
+exports.BillingApi = BillingApi;

package/dist/cjs/api/civic.js

@@ -0,0 +1,289 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CivicCredentialsApi = exports.CivicValidationApi = exports.CivicApi = void 0;
+const payloads_1 = require("../civic/payloads");
+const identity_1 = require("./identity");
+/** Short-TTL read cache for public civic reads. */
+const SHORT_TTL = 60 * 1000;
+/**
+ * Validity window of a real-life-attestation QR, matching the server's
+ * `REAL_LIFE_NONCE_MAX_AGE_MS` ceiling. The server is authoritative on
+ * freshness; this is the client-issued `exp`.
+ */
+const ATTEST_QR_TTL_MS = 10 * 60 * 1000;
+/** AtProto-style collections of the civic records. */
+const ATTEST_COLLECTION = 'app.oxy.attestation';
+const VALIDATION_COLLECTION = 'app.oxy.validation';
+const VOUCH_COLLECTION = 'app.oxy.vouch';
+/**
+ * Each credential is its own chain entry, so its `rkey` MUST be unique (a fresh
+ * nonce), unlike the one-per-subject vouch keyed on the subject DID.
+ */
+const CREDENTIAL_COLLECTION = 'app.oxy.credential';
+/**
+ * The W3C base VC type that MUST be present in every credential's `types`;
+ * prepended when the caller omits it (the server rejects a record lacking it).
+ */
+const CREDENTIAL_BASE_TYPE = 'VerifiableCredential';
+/** Every credential read (holder list + by-record verify) starts with this. */
+const CREDENTIAL_CACHE_PREFIX = 'GET:/civic/credentials/';
+/** Every personhood-status read starts with this. */
+const PERSONHOOD_CACHE_PREFIX = 'GET:/civic/personhood/';
+/**
+ * `GET /users/me`: a subject crossing the personhood threshold flips their
+ * mirrored `User.verified`, so a vouch / withdraw sweeps it.
+ */
+const USERS_ME_CACHE_PREFIX = 'GET:/users/me';
+class CivicApi {
+    constructor(ctx) {
+        this.ctx = ctx;
+        this.validation = new CivicValidationApi(ctx);
+        this.credentials = new CivicCredentialsApi(ctx);
+    }
+    /**
+     * A user's signed public Oxy ID card, with the Oxy attestation verified
+     * client-side. Public; short-TTL cached. A bad or absent signature does NOT
+     * reject — it yields `verified: false`.
+     */
+    async publicCard(userId) {
+        const signed = await this.ctx.request('GET', `/civic/${encodeURIComponent(userId)}/card`, undefined, {
+            cache: true,
+            cacheTTL: SHORT_TTL,
+        });
+        const verified = await (0, payloads_1.verifyPublicCardAttestation)(signed.card, signed.attestation);
+        return { card: signed.card, attestation: signed.attestation, verified };
+    }
+    /**
+     * The signed-in user's Oxy ID QR payload: `oxycommons://card?did=<did>&v=1`.
+     * Encodes ONLY the DID; a scanner resolves the signed card via `publicCard`.
+     * Throws when signed out.
+     */
+    idPayload() {
+        return `oxycommons://card?did=${this.myDid('build an Oxy ID payload')}&v=1`;
+    }
+    /**
+     * The real-life-attestation QR the signed-in user (A) shows to be attested by
+     * a counterparty (B):
+     * `oxycommons://attest?subject=<A.did>&ctx=<context>&nonce=<fresh>&exp=<now+10m>`.
+     * A fresh crypto-random nonce per call (single-use replay guard). Throws when
+     * signed out.
+     */
+    async buildAttestQrPayload(input) {
+        const subject = this.myDid('build an attestation QR');
+        const { SignatureService } = await Promise.resolve().then(() => __importStar(require('../crypto/internal')));
+        const nonce = await SignatureService.generateChallenge();
+        const exp = Date.now() + ATTEST_QR_TTL_MS;
+        const payload = `oxycommons://attest?subject=${subject}` +
+            `&ctx=${encodeURIComponent(input.context)}` +
+            `&nonce=${nonce}&exp=${exp}`;
+        return { payload, nonce, exp };
+    }
+    /**
+     * Submit a real-life counterparty attestation as the SCANNER (B): sign a
+     * self-issued `real_life_attestation` record on B's own chain referencing A via
+     * `record.about`, then `POST /civic/attestations`. The server enforces nonce
+     * single-use, freshness, graph-exclusion and the per-pair cooldown, then awards
+     * A the HIGH-weight points. NATIVE-ONLY.
+     */
+    async attest(input) {
+        const envelope = await (0, identity_1.signOwnChainRecord)(this.ctx, 'real_life_attestation', {
+            about: input.subjectDid,
+            context: input.context,
+            nonce: input.nonce,
+            exp: input.exp,
+            ...(input.geohash !== undefined ? { geohash: input.geohash } : {}),
+            ...(input.biometricOk !== undefined ? { biometricOk: input.biometricOk } : {}),
+        }, { collection: ATTEST_COLLECTION, rkey: input.nonce });
+        return this.ctx.request('POST', '/civic/attestations', envelope, { cache: false });
+    }
+    /**
+     * Vouch that another user is a real person as the VOUCHER (B): sign a
+     * self-issued `personhood_vouch` record (`{ about, stake? }`) on B's own chain,
+     * then `POST /civic/personhood/vouch`. The server enforces voucher eligibility
+     * and graph-exclusion, stakes B, and recomputes A's personhood. One vouch per
+     * subject (`rkey: <subjectDid>`, last-writer-wins). NATIVE-ONLY.
+     */
+    async vouch(input) {
+        const envelope = await (0, identity_1.signOwnChainRecord)(this.ctx, 'personhood_vouch', {
+            about: input.subjectDid,
+            ...(input.stakeAmount !== undefined ? { stake: input.stakeAmount } : {}),
+            ...(input.biometricOk !== undefined ? { biometricOk: input.biometricOk } : {}),
+        }, { collection: VOUCH_COLLECTION, rkey: input.subjectDid });
+        const result = await this.ctx.request('POST', '/civic/personhood/vouch', envelope, { cache: false });
+        this.sweepPersonhood();
+        return result;
+    }
+    /**
+     * Withdraw the signed-in user's active vouch for a subject. The subject is
+     * recomputed (which may demote them).
+     *
+     * @param subjectUserId - The subject's account id (NOT a DID).
+     */
+    async withdrawVouch(subjectUserId) {
+        const result = await this.ctx.request('DELETE', `/civic/personhood/vouch/${encodeURIComponent(subjectUserId)}`, undefined, { cache: false });
+        this.sweepPersonhood();
+        return result;
+    }
+    /**
+     * A user's public personhood status snapshot (default: the signed-in user's).
+     * A zeroed `unverified` shape when none exists yet. Short-TTL cached.
+     */
+    async personhood(userId) {
+        const id = userId ?? this.myUserId('resolve personhood status');
+        return this.ctx.request('GET', `/civic/personhood/${encodeURIComponent(id)}`, undefined, {
+            cache: true,
+            cacheTTL: SHORT_TTL,
+        });
+    }
+    /** A vouch / withdraw changes personhood reads and (via `verified`) `/users/me`. */
+    sweepPersonhood() {
+        this.ctx.http.invalidateCache({ prefixes: [PERSONHOOD_CACHE_PREFIX, USERS_ME_CACHE_PREFIX] });
+    }
+    myUserId(action) {
+        const userId = this.ctx.oxy.session.userId;
+        if (!userId) {
+            throw new Error(`No authenticated user — cannot ${action}.`);
+        }
+        return userId;
+    }
+    myDid(action) {
+        return (0, identity_1.buildUserDid)(this.myUserId(action));
+    }
+}
+exports.CivicApi = CivicApi;
+/** `oxy.civic.validation` — a randomly selected juror's duties. */
+class CivicValidationApi {
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    /** The signed-in user's pending jury duties. Never cached; `[]` when on no juries. */
+    async inbox() {
+        const res = await this.ctx.request('GET', '/civic/validations/inbox', undefined, {
+            cache: false,
+        });
+        return res.requests ?? [];
+    }
+    /**
+     * Cast a SIGNED verdict as a selected juror: a self-issued `validation_verdict`
+     * record bound to `requestId` + `payloadHash` (so it cannot be replayed onto a
+     * different request or an altered payload). NATIVE-ONLY.
+     *
+     * @param payloadHash - The request's canonical payload hash (from the inbox).
+     */
+    async vote(requestId, payloadHash, verdict) {
+        const envelope = await (0, identity_1.signOwnChainRecord)(this.ctx, 'validation_verdict', { requestId, payloadHash, verdict }, { collection: VALIDATION_COLLECTION, rkey: requestId });
+        return this.ctx.request('POST', `/civic/validations/${encodeURIComponent(requestId)}/vote`, envelope, { cache: false });
+    }
+    /** Recuse from a validation request: the juror leaves the jury and it is re-tallied. */
+    async deny(requestId) {
+        return this.ctx.request('POST', `/civic/validations/${encodeURIComponent(requestId)}/deny`, undefined, { cache: false });
+    }
+}
+exports.CivicValidationApi = CivicValidationApi;
+/** `oxy.civic.credentials` — verifiable credentials. */
+class CivicCredentialsApi {
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    /**
+     * Issue a verifiable credential as the ISSUER: sign a self-issued `credential`
+     * record on the caller's own chain whose `record.about` is the HOLDER's DID,
+     * then `POST /civic/credentials`. `'VerifiableCredential'` is ensured as the
+     * base type; an `expiresAt` ISO string becomes epoch ms. NATIVE-ONLY.
+     */
+    async issue(input) {
+        const types = input.types.includes(CREDENTIAL_BASE_TYPE) ? input.types : [CREDENTIAL_BASE_TYPE, ...input.types];
+        let expiresAtMs;
+        if (input.expiresAt !== undefined) {
+            const parsed = Date.parse(input.expiresAt);
+            if (Number.isNaN(parsed)) {
+                throw new Error('Invalid expiresAt — must be an ISO 8601 date string.');
+            }
+            expiresAtMs = parsed;
+        }
+        const record = {
+            about: input.holderDid,
+            types,
+            claims: input.claims,
+            ...(expiresAtMs !== undefined ? { expiresAt: expiresAtMs } : {}),
+        };
+        // A fresh crypto-random rkey: every credential is its own chain entry.
+        const { SignatureService } = await Promise.resolve().then(() => __importStar(require('../crypto/internal')));
+        const rkey = await SignatureService.generateChallenge();
+        const envelope = await (0, identity_1.signOwnChainRecord)(this.ctx, 'credential', record, { collection: CREDENTIAL_COLLECTION, rkey });
+        const result = await this.ctx.request('POST', '/civic/credentials', envelope, { cache: false });
+        this.sweep();
+        return result;
+    }
+    /**
+     * A holder's credentials, newest first (default holder: the signed-in user),
+     * optionally filtered by status. Public; short-TTL cached.
+     *
+     * @param holderUserId - The holder's account id (NOT a DID).
+     */
+    async list(holderUserId, opts = {}) {
+        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('GET', url, undefined, { cache: true, cacheTTL: SHORT_TTL });
+    }
+    /**
+     * Verify a credential by its signed-record id: the server re-checks the
+     * signature against a CURRENT verification method of the issuer DID, then
+     * that it is neither revoked nor expired. A failing credential yields
+     * `valid: false`, not a throw. Short-TTL cached.
+     */
+    async verify(recordId) {
+        return this.ctx.request('GET', `/civic/credentials/by-record/${encodeURIComponent(recordId)}/verify`, undefined, { cache: true, cacheTTL: SHORT_TTL });
+    }
+    /**
+     * Revoke a credential the signed-in user issued.
+     *
+     * @param id - The credential's id (the projection row id, NOT the record id).
+     */
+    async revoke(id) {
+        const result = await this.ctx.request('POST', `/civic/credentials/${encodeURIComponent(id)}/revoke`, undefined, { cache: false });
+        this.sweep();
+        return result;
+    }
+    sweep() {
+        this.ctx.http.invalidateCache({ prefixes: [CREDENTIAL_CACHE_PREFIX] });
+    }
+}
+exports.CivicCredentialsApi = CivicCredentialsApi;

package/dist/cjs/api/contacts.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContactsApi = void 0;
+class ContactsApi {
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    /**
+     * 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, hashedPhones) {
+        return this.ctx.request('POST', '/contacts/discover', { hashedEmails, hashedPhones }, { cache: false });
+    }
+}
+exports.ContactsApi = ContactsApi;