@envarai/envarpay 0.1.0-alpha.3 → 0.2.0-alpha.10

package/dist/commerce/pricing.js

@@ -0,0 +1,60 @@
+import { randomUUID } from 'node:crypto';
+import { Ajv2020 } from 'ajv/dist/2020.js';
+import addFormatsImport from 'ajv-formats';
+import { atomic, currencyOf, digest, serviceTermsDigest } from './config.js';
+import { CommerceError } from './types.js';
+const addFormats = addFormatsImport;
+export function buildQuote(config, args) {
+    if (!args.caller || !args.messageId || args.messageId.length > 128)
+        throw new CommerceError('invalid_identity', 'Authenticated caller and stable message ID are required');
+    const service = config.services.find(s => s.id === args.serviceId);
+    const offer = service?.offers.find(o => o.id === args.offerId);
+    if (!service || !offer)
+        throw new CommerceError('offer_not_found', 'Service offer not found');
+    const ajv = new Ajv2020({ strict: true });
+    addFormats(ajv);
+    const validate = ajv.compile(service.contract.inputSchema);
+    if (!validate(args.input))
+        throw new CommerceError('invalid_input', ajv.errorsText(validate.errors));
+    let amount = 0n;
+    if (offer.pricing.kind === 'fixed')
+        amount = atomic(offer.pricing.amount);
+    if (offer.pricing.kind === 'quantity') {
+        let current = args.input;
+        for (const part of offer.pricing.quantity.pointer.slice(1).split('/')) {
+            const key = part.replace(/~1/g, '/').replace(/~0/g, '~');
+            current = current && typeof current === 'object' && Object.hasOwn(current, key) ? current[key] : undefined;
+        }
+        const q = offer.pricing.quantity;
+        if (!Array.isArray(current) || current.length < q.min || current.length > q.max)
+            throw new CommerceError('invalid_quantity', 'Input quantity outside the purchased range');
+        amount = atomic(offer.pricing.unitAmount) * BigInt(current.length);
+    }
+    if (amount >= 2n ** 256n)
+        throw new CommerceError('invalid_amount', 'Quoted amount is too large');
+    const profile = offer.paymentProfile ? config.paymentProfiles[offer.paymentProfile] : null;
+    const recipient = profile?.adapter === 'x402' ? profile.payTo : profile ? args.stripeRecipient : null;
+    if (profile?.adapter === 'mpp' && !recipient)
+        throw new CommerceError('merchant_not_ready', 'Resolve and verify the Stripe merchant before quoting');
+    const now = args.now ?? new Date();
+    const ttl = args.ttlSeconds ?? 600;
+    if (!Number.isInteger(ttl) || ttl < 1 || ttl > 3600 || !Number.isFinite(now.getTime()))
+        throw new CommerceError('invalid_expiry', 'Quote lifetime must be 1–3600 seconds');
+    const quote = {
+        quoteVersion: 1, quoteId: randomUUID(), caller: args.caller, serviceId: service.id,
+        serviceRevision: service.revision, offerId: offer.id, messageId: args.messageId,
+        inputDigest: digest(args.input), termsDigest: serviceTermsDigest(config.configVersion, service, offer, profile),
+        issuedAt: now.toISOString(), expiresAt: new Date(now.getTime() + ttl * 1000).toISOString(),
+        amount: amount.toString(), currency: profile ? currencyOf(profile) : null,
+        recipient: recipient ?? null, paymentProfile: profile ? structuredClone(profile) : null,
+    };
+    if (quote.paymentProfile)
+        Object.freeze(quote.paymentProfile);
+    return Object.freeze(quote);
+}
+export function assertQuoteRequest(quote, caller, messageId, input, now = new Date()) {
+    if (quote.caller !== caller || quote.messageId !== messageId || quote.inputDigest !== digest(input))
+        throw new CommerceError('quote_mismatch', 'Request differs from the frozen quote');
+    if (!Number.isFinite(now.getTime()) || !Number.isFinite(Date.parse(quote.expiresAt)) || now.getTime() >= Date.parse(quote.expiresAt))
+        throw new CommerceError('quote_expired', 'Review a new quote before payment');
+}

package/dist/commerce/runtime.d.ts

@@ -0,0 +1,10 @@
+/** Node.js service APIs. Keep node:sqlite out of the portable contracts entry. */
+export * from './store.js';
+export * from './server.js';
+export * from './upstream.js';
+export * from './skill-gate.js';
+export * from './native-skills.js';
+export * from './http.js';
+export * from './x402.js';
+export * from './vault.js';
+export * from './chain.js';

package/dist/commerce/runtime.js

@@ -0,0 +1,10 @@
+/** Node.js service APIs. Keep node:sqlite out of the portable contracts entry. */
+export * from './store.js';
+export * from './server.js';
+export * from './upstream.js';
+export * from './skill-gate.js';
+export * from './native-skills.js';
+export * from './http.js';
+export * from './x402.js';
+export * from './vault.js';
+export * from './chain.js';

package/dist/commerce/server.d.ts

@@ -0,0 +1,61 @@
+import { AgentCard, Task, SendMessageRequest } from '@a2a-js/sdk';
+import { ServerCallContext } from '@a2a-js/sdk/server';
+import { CommerceStore, type OrderRecord, type ContinuationRecord, type RemoteTaskReference } from './store.js';
+import { type CommerceConfig, type Input, type Service } from './types.js';
+export interface ExecuteOrder {
+    (order: OrderRecord, service: Service): AsyncIterable<Task>;
+    assertSkill?: (service: Service) => unknown;
+    skillCard?: () => AgentCard;
+    continue?: (order: OrderRecord, service: Service, continuation: ContinuationRecord, remote: RemoteTaskReference) => AsyncIterable<Task>;
+    recover?: (order: OrderRecord, service: Service, remote: RemoteTaskReference) => Promise<Task>;
+    remoteInterface?: (task: Task) => string | undefined;
+}
+export interface CommerceServerOptions {
+    config: CommerceConfig;
+    origin: string;
+    store: CommerceStore;
+    authenticate: (request: Request) => Promise<string | null>;
+    execute: ExecuteOrder;
+    paymentGate?: {
+        handle(request: Request, order: OrderRecord): Promise<{
+            response: Response;
+        } | {
+            headers: Record<string, string>;
+        }>;
+    };
+    stripeRecipientFor?: (accountRef: string) => string | undefined;
+    ownershipChallenges?: Readonly<Record<string, string>>;
+    onError?: (code: string, orderId?: string) => void;
+}
+export declare function bearerAuthenticator(tokens: Readonly<Record<string, string>>): (request: Request) => Promise<string | null>;
+/** HTTP handler + one durable worker. Recovery only reads the original upstream Task. */
+export declare class CommerceServer {
+    private options;
+    private currentConfig;
+    get config(): CommerceConfig;
+    readonly store: CommerceStore;
+    private routes;
+    private running;
+    private kickPending;
+    private stopped;
+    private workerFailed;
+    private waiters;
+    private activeOrders;
+    private recoveries;
+    constructor(options: CommerceServerOptions);
+    /** Atomically replace active routes while retaining immutable history and original Tasks. */
+    applyConfig(value: CommerceConfig): void;
+    private activeRevision;
+    private context;
+    quote(service: Service, offerId: string, caller: string, messageId: string, input: Input): Readonly<import("./types.js").PriceQuote>;
+    handle(request: Request): Promise<Response>;
+    continueTask(params: SendMessageRequest, input: Input, service: Service, offerId: string, context: ServerCallContext): Promise<Task>;
+    recoverTask(taskId: string, context: ServerCallContext): Promise<Task>;
+    private project;
+    schedule(): void;
+    private drain;
+    waitForTask(taskId: string, context: ServerCallContext): Promise<Task>;
+    private wake;
+    stop(): void;
+    get isRunning(): boolean;
+}