@supercuts-walrus/backend 0.1.0 → 0.1.2

package/dist/seller-scaffold.js

@@ -0,0 +1,35 @@
+import { chmodSync, mkdirSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { fail } from "./errors.js";
+const idPattern = /^[a-z0-9][a-z0-9._-]{1,127}$/;
+export function scaffoldSeller(input) {
+    const home = typeof input.home === "string" ? resolve(input.home) : fail("ARGUMENT_REQUIRED", "seller scaffold requires --home");
+    const output = typeof input.output === "string" ? resolve(input.output) : fail("ARGUMENT_REQUIRED", "seller scaffold requires --output");
+    const capabilityId = String(input["capability-id"] ?? ""), capability = String(input.capability ?? ""), description = String(input.description ?? ""), origin = String(input.origin ?? ""), price = String(input.price ?? "");
+    if (!idPattern.test(capabilityId) || !idPattern.test(capability))
+        fail("SELLER_SCAFFOLD_INVALID", "capability identifiers must use 2..128 lowercase letters, digits, dot, underscore, or dash");
+    if (!description || description.length > 512 || !/^[1-9][0-9]*$/.test(price))
+        fail("SELLER_SCAFFOLD_INVALID", "description and positive MIST --price are required");
+    const url = new URL(origin);
+    if (url.protocol !== "https:" && !(url.protocol === "http:" && ["localhost", "127.0.0.1", "::1"].includes(url.hostname)) || url.username || url.password || url.pathname !== "/" || url.search || url.hash)
+        fail("SELLER_SCAFFOLD_INVALID", "origin must be an HTTPS or loopback HTTP origin without path or credentials");
+    const rails = String(input.rails ?? "x402").split(",").map((rail) => rail.trim()).filter(Boolean);
+    if (!rails.length || rails.some((rail) => rail !== "x402" && rail !== "shielded") || new Set(rails).size !== rails.length)
+        fail("SELLER_SCAFFOLD_INVALID", "--rails must be x402, shielded, or x402,shielded");
+    const days = Number(input["expires-in-days"] ?? "30");
+    if (!Number.isSafeInteger(days) || days < 1 || days > 365)
+        fail("SELLER_SCAFFOLD_INVALID", "--expires-in-days must be 1..365");
+    const listenPort = Number(input["listen-port"] ?? (url.protocol === "http:" && url.port ? url.port : "8788"));
+    if (!Number.isSafeInteger(listenPort) || listenPort < 1 || listenPort > 65535)
+        fail("SELLER_SCAFFOLD_INVALID", "--listen-port must be 1..65535");
+    mkdirSync(output, { recursive: false, mode: 0o700 });
+    chmodSync(output, 0o700);
+    const specPath = resolve(output, "capability.json"), handlerPath = resolve(output, "handler.mjs"), registrationPath = resolve(output, "registration.json"), servicePath = resolve(output, "seller-service.json");
+    const spec = { capabilityId, capability, description, inputSchema: { type: "object", required: ["task"], properties: { task: { type: "string", minLength: 1, maxLength: 4096 } }, additionalProperties: false }, outputSchema: { type: "object", required: ["kind"], properties: { kind: { const: capability } }, additionalProperties: false }, supportedRails: rails, priceBand: { minimum: price, maximum: price }, asset: "0x2::sui::SUI", endpoint: `${url.origin}/v2/resource/${capabilityId}`, expiresAt: Date.now() + days * 86_400_000 };
+    const handler = `export async function handle(request) {\n  const result = { kind: ${JSON.stringify(capability)}, task: request.input.task, message: "Replace this template with your seller implementation." };\n  return { artifact: Buffer.from(JSON.stringify(result)), contentType: "application/json", metadata: { kind: ${JSON.stringify(capability)} } };\n}\n`;
+    const service = { origin: url.origin, listenHost: "127.0.0.1", listenPort, ...(rails.includes("x402") ? { facilitatorUrlEnv: "X402_FACILITATOR_URL", facilitatorKeyEnv: "FACILITATOR_SHARED_KEY" } : {}), capabilities: [{ registrationFile: registrationPath, handler: handlerPath }] };
+    writeFileSync(specPath, `${JSON.stringify(spec, null, 2)}\n`, { mode: 0o600, flag: "wx" });
+    writeFileSync(handlerPath, handler, { mode: 0o600, flag: "wx" });
+    writeFileSync(servicePath, `${JSON.stringify(service, null, 2)}\n`, { mode: 0o600, flag: "wx" });
+    return { home, output, specFile: specPath, handlerFile: handlerPath, registrationFile: registrationPath, serviceFile: servicePath, expiresAt: spec.expiresAt, nextCommands: [`supercuts-seller-register ${JSON.stringify(home)} ${JSON.stringify(specPath)} ${JSON.stringify(registrationPath)}`, `supercuts-seller-live ${JSON.stringify(home)} ${JSON.stringify(servicePath)}`], note: "Review and replace the generated handler before serving production work." };
+}

package/dist/seller-service.d.ts

@@ -18,7 +18,7 @@ export declare class SellerService {
         facilitatorUrl: string;
         facilitatorKey: string;
         allowedBuyers: ReadonlySet<string>;
-        claudeKey: string;
+        claudeKey?: string;
         directoryAggregator?: string;
     }): Promise<SellerService>;
     private artifact;

package/dist/seller-service.js

@@ -4,7 +4,6 @@ import { createServer } from "node:http";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { BoundedClaude } from "./claude.js";
 import { decodeSuiPrivateKey } from "@mysten/sui/cryptography";
 import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
 import { isValidPersonalMessageSignature } from "@mysten/sui/verify";
@@ -35,10 +34,9 @@ export class SellerService {
     #v2 = new Map();
     #v2BySeller = new Map();
     #root = mkdtempSync(join(tmpdir(), "supercuts-sellers-"));
-    #claude;
     #queue = Promise.resolve();
     #healthy = true;
-    constructor(db, snapshotKey, origin, facilitatorUrl, facilitatorKey, allowedBuyers, claudeKey, directoryAggregator) {
+    constructor(db, snapshotKey, origin, facilitatorUrl, facilitatorKey, allowedBuyers, directoryAggregator) {
         this.db = db;
         this.snapshotKey = snapshotKey;
         this.origin = origin;
@@ -46,10 +44,9 @@ export class SellerService {
         this.facilitatorKey = facilitatorKey;
         this.allowedBuyers = allowedBuyers;
         this.directoryAggregator = directoryAggregator;
-        this.#claude = new BoundedClaude({ apiKey: claudeKey });
     }
     static async create(config) {
-        const service = new SellerService(config.db, config.snapshotKey, config.origin, config.facilitatorUrl, config.facilitatorKey, config.allowedBuyers, config.claudeKey, config.directoryAggregator);
+        const service = new SellerService(config.db, config.snapshotKey, config.origin, config.facilitatorUrl, config.facilitatorKey, config.allowedBuyers, config.directoryAggregator);
         const rows = (await config.db.listCatalog()).filter((row) => !(isV2(row) && row.manifest.expiresAt <= Date.now()));
         for (const row of rows) {
             validateCapabilityManifest(row.manifest);
@@ -182,7 +179,13 @@ export class SellerService {
         try {
             const url = new URL(request.url ?? "/", this.origin);
             if (request.method === "GET" && url.pathname === "/health")
-                return this.reply(response, this.#healthy ? 200 : 503, { ok: this.#healthy, service: "supercuts-sellers" });
+                return this.reply(response, this.#healthy ? 200 : 503, { ok: this.#healthy, service: "supercuts-sellers", buyerAccess: this.allowedBuyers.size ? "restricted" : "open" });
+            if (request.method === "GET" && url.pathname === "/v1/access") {
+                const buyerAddress = String(url.searchParams.get("buyerAddress") ?? "").toLowerCase();
+                if (!/^0x[0-9a-f]{64}$/.test(buyerAddress))
+                    fail("SELLER_REQUEST_INVALID", "buyerAddress is invalid");
+                return this.reply(response, 200, { buyerAddress, allowed: this.allowedBuyers.size === 0 || this.allowedBuyers.has(buyerAddress), mode: this.allowedBuyers.size ? "restricted" : "open" });
+            }
             if (request.method === "GET" && url.pathname === "/v2/directory/health") {
                 if (!this.directoryAggregator)
                     return this.reply(response, 503, { ok: false, service: "supercuts-directory", reason: "aggregator not configured" });
@@ -241,7 +244,7 @@ export class SellerService {
                     const sessionId = validId(input.sessionId, "sessionId"), runId = validId(input.runId, "runId"), buyerAddress = String(input.buyerAddress ?? ""), buyerPublicKey = String(input.buyerPublicKey ?? ""), ciphertext = String(input.ciphertext ?? ""), buyerSignature = String(input.buyerSignature ?? "");
                     if (!/^0x[0-9a-f]{64}$/.test(buyerAddress) || buyerPublicKey.length > 1024 || ciphertext.length > 16384 || !ciphertext || !buyerSignature)
                         fail("SELLER_REQUEST_INVALID", "buyer identity or encrypted offer is invalid");
-                    if (!this.allowedBuyers.has(buyerAddress))
+                    if (this.allowedBuyers.size > 0 && !this.allowedBuyers.has(buyerAddress))
                         fail("SELLER_BUYER_FORBIDDEN", "buyer is outside the seller service allowlist");
                     const signedBytes = Buffer.from(`${sessionId}:${capabilityId}:${buyerPublicKey}:${sha256(Buffer.from(ciphertext, "base64"))}`);
                     if (!(await isValidPersonalMessageSignature(signedBytes, buyerSignature, { address: buyerAddress })))
@@ -265,10 +268,6 @@ export class SellerService {
                     const opening = BigInt(String(offer.opening ?? "0")), maximum = BigInt(String(offer.maximum ?? "0")), minimum = BigInt(row.manifest.priceBand.minimum), briefHash = typeof offer.briefHash === "string" ? offer.briefHash : undefined;
                     if (opening <= 0n || opening > maximum || maximum < minimum || maximum > BigInt(row.manifest.priceBand.maximum) || briefHash !== undefined && !/^[0-9a-f]{64}$/.test(briefHash))
                         fail("NEGOTIATION_BOUNDS_INVALID", "buyer offer exceeds approved price bounds");
-                    const task = String(offer.task ?? "").slice(0, 512);
-                    const decision = await this.#claude.decide({ system: "You are a bounded research seller. Present only the fixed price and service terms approved by Supercuts.", task, candidates: [{ action: "counteroffer", capabilityId, amount: minimum.toString() }], schema: { name: "respond_to_private_offer", description: "Present the approved exact price.", properties: { action: { type: "string", enum: ["counteroffer"] } }, required: ["action"] } });
-                    if (decision.action.action !== "counteroffer")
-                        fail("SELLER_DECISION_INVALID", "seller did not choose the approved response");
                     const reply = { capabilityId, amount: minimum.toString(), asset: row.manifest.asset, railOptions: row.manifest.supportedRails, accepted: true };
                     const replyCiphertext = encryptSessionMessage(key, sessionId, `${sessionId}:seller:2`, Buffer.from(JSON.stringify(reply)));
                     const requestBlobId = await this.publishCiphertext(slot, ciphertext), replyBlobId = await this.publishCiphertext(slot, replyCiphertext);
@@ -285,7 +284,7 @@ export class SellerService {
                         this.#healthy = false;
                         throw error;
                     }
-                    await this.db.addEvent({ run_id: runId, seller_id: slot.sellerId, stage: "negotiation", status: "complete", details: { capabilityId, sessionId, requestBlobId, replyBlobId, transcriptHash, model: decision.model } });
+                    await this.db.addEvent({ run_id: runId, seller_id: slot.sellerId, stage: "negotiation", status: "complete", details: { capabilityId, sessionId, requestBlobId, replyBlobId, transcriptHash, decision: "policy-validated-fixed-price" } });
                     return this.reply(response, 200, { sessionId, capabilityId, ciphertext: replyCiphertext, signature, requestBlobId, replyBlobId, transcriptHash });
                 });
             }
@@ -310,9 +309,6 @@ export class SellerService {
                     const prior = slot.app.store.db.prepare("SELECT operation_id AS operationId,capability_id AS capabilityId,amount,artifact_key AS artifactKey,run_id AS runId FROM remote_quotes WHERE request_id=?").get(requestId);
                     if (prior && JSON.stringify(prior) !== JSON.stringify({ operationId, capabilityId, amount: quote.amount, artifactKey: quote.artifactKey, runId }))
                         fail("SELLER_QUOTE_CONFLICT", "request ID identifies another quote");
-                    const decision = await this.#claude.decide({ system: "You are a bounded seller agent. You may present only the fixed approved quote.", task: String(input.task ?? "Sui market brief").slice(0, 512), candidates: [{ action: "present_quote", capabilityId, amount: quote.amount }], schema: { name: "respond_to_buyer", description: "Present the approved exact price.", properties: { action: { type: "string", enum: ["present_quote"] } }, required: ["action"] } });
-                    if (decision.action.action !== "present_quote")
-                        fail("SELLER_DECISION_INVALID", "seller did not choose the approved quote");
                     slot.app.store.db.prepare("INSERT OR IGNORE INTO remote_quotes(request_id,operation_id,capability_id,amount,artifact_key,run_id) VALUES(?,?,?,?,?,?)").run(requestId, operationId, capabilityId, quote.amount, quote.artifactKey, runId);
                     const artifact = this.artifact(slot, quote.artifactKey), registration = this.resource(slot, row).register(requestId, operationId, artifact);
                     try {
@@ -322,7 +318,7 @@ export class SellerService {
                         this.#healthy = false;
                         throw error;
                     }
-                    await this.db.addEvent({ run_id: runId, seller_id: slot.sellerId, stage: "quote", status: "complete", details: { capabilityId, amount: quote.amount, model: decision.model } });
+                    await this.db.addEvent({ run_id: runId, seller_id: slot.sellerId, stage: "quote", status: "complete", details: { capabilityId, amount: quote.amount, decision: "manifest-fixed-price" } });
                     return this.reply(response, 200, { capabilityId, sellerId: slot.sellerId, amount: quote.amount, asset: row.manifest.asset, requestId, operationId, resourceUrl: registration.url, artifactSha256: registration.artifactSha256 });
                 });
             }
@@ -350,9 +346,6 @@ export class SellerService {
                     const prior = slot.app.store.db.prepare("SELECT capability_id AS capabilityId,artifact_key AS artifactKey,delivery_public_key AS deliveryPublicKey,run_id AS runId FROM remote_deliveries WHERE session_id=?").get(sessionId);
                     if (prior && JSON.stringify(prior) !== JSON.stringify({ capabilityId, artifactKey, deliveryPublicKey, runId }))
                         fail("AGREEMENT_SESSION_CONFLICT", "session identifies another delivery");
-                    const decision = await this.#claude.decide({ system: "You are a bounded seller agent. Sign only the backend-verified agreement.", task: `Respond to accepted competitor analysis request for ${capabilityId}.`, candidates: [{ action: "sign_approved_agreement", capabilityId }], schema: { name: "respond_to_private_offer", description: "Approve the backend-verified agreement.", properties: { action: { type: "string", enum: ["sign_approved_agreement"] } }, required: ["action"] } });
-                    if (decision.action.action !== "sign_approved_agreement")
-                        fail("SELLER_DECISION_INVALID", "seller did not choose the approved agreement");
                     const signed = await executeMandated(slot.app, loadMandate(slot.home), "offer.counter", { "operation-id": `remote-counter-${sessionId}`, session: sessionId, agreement: encoded });
                     slot.app.store.db.prepare("INSERT OR IGNORE INTO remote_deliveries(session_id,capability_id,artifact_key,delivery_public_key,run_id) VALUES(?,?,?,?,?)").run(sessionId, capabilityId, artifactKey, deliveryPublicKey, runId);
                     try {
@@ -362,7 +355,7 @@ export class SellerService {
                         this.#healthy = false;
                         throw error;
                     }
-                    await this.db.addEvent({ run_id: runId, seller_id: slot.sellerId, stage: "agreement", status: "complete", details: { capabilityId, sessionId, model: decision.model, dealCommitment: signed.dealCommitment } });
+                    await this.db.addEvent({ run_id: runId, seller_id: slot.sellerId, stage: "agreement", status: "complete", details: { capabilityId, sessionId, decision: "backend-verified-agreement", dealCommitment: signed.dealCommitment } });
                     return this.reply(response, 200, { sessionId, capabilityId, agreement: signed.agreement, dealCommitment: signed.dealCommitment, artifactSha256 });
                 });
             }
@@ -410,7 +403,7 @@ if (process.argv[1] && import.meta.url.endsWith(process.argv[1])) {
     const required = (key) => process.env[key] ?? fail("SELLER_CONFIG_MISSING", `${key} is required`);
     const port = Number(process.env.PORT ?? "3000");
     const origin = required("SELLER_ORIGIN");
-    SellerService.create({ db: new SellerDatabase(required("SUPABASE_URL"), required("SUPABASE_SERVICE_ROLE_KEY")), snapshotKey: required("SELLER_STATE_KEY"), origin, facilitatorUrl: required("FACILITATOR_URL"), facilitatorKey: required("FACILITATOR_SHARED_KEY"), allowedBuyers: new Set(required("SELLER_ALLOWED_BUYERS").split(",")), claudeKey: required("CLAUDE_API_KEY"), ...(process.env.DIRECTORY_WALRUS_AGGREGATOR ? { directoryAggregator: process.env.DIRECTORY_WALRUS_AGGREGATOR } : {}) })
+    SellerService.create({ db: new SellerDatabase(required("SUPABASE_URL"), required("SUPABASE_SERVICE_ROLE_KEY")), snapshotKey: required("SELLER_STATE_KEY"), origin, facilitatorUrl: required("FACILITATOR_URL"), facilitatorKey: required("FACILITATOR_SHARED_KEY"), allowedBuyers: new Set((process.env.SELLER_ALLOWED_BUYERS ?? "").split(",").map((item) => item.trim().toLowerCase()).filter(Boolean)), ...(process.env.DIRECTORY_WALRUS_AGGREGATOR ? { directoryAggregator: process.env.DIRECTORY_WALRUS_AGGREGATOR } : {}) })
         .then((service) => { const server = service.createServer(); server.listen(port, "0.0.0.0"); const close = () => server.close(() => { service.close(); process.exit(0); }); process.on("SIGINT", close); process.on("SIGTERM", close); })
         .catch((error) => { process.stderr.write(`${error instanceof Error ? error.message : "seller service failed"}\n`); process.exitCode = 1; });
 }

package/dist/seller-setup.d.ts

@@ -0,0 +1,3 @@
+export declare function createSellerSession(home: string): Record<string, unknown>;
+export declare function setupSeller(home: string, configPath: string): Record<string, unknown>;
+export declare function promptSellerSetup(home: string): Promise<Record<string, unknown>>;

package/dist/seller-setup.js

@@ -0,0 +1,107 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createInterface } from "node:readline/promises";
+import { decodeSuiPrivateKey } from "@mysten/sui/cryptography";
+import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
+import { fail } from "./errors.js";
+import { initialize } from "./phase3.js";
+function ownerFile(path) {
+    if ((statSync(path).mode & 0o077) !== 0)
+        fail("SETUP_PERMISSIONS", `${path} must be owner-only`);
+}
+function validateConfig(config) {
+    config.deploymentConfig ||= join(dirname(fileURLToPath(import.meta.url)), "../config/phase1.testnet.json");
+    for (const key of ["deploymentConfig", "tatumKeyFile", "writeGrpc", "tatumGrpc", "walrusPublisher", "walrusAggregator"]) {
+        if (typeof config[key] !== "string" || !config[key])
+            fail("SETUP_INVALID", `${key} is required`);
+    }
+    ownerFile(resolve(config.tatumKeyFile));
+    if (config.suiKeyFile)
+        ownerFile(resolve(config.suiKeyFile));
+    const deployment = JSON.parse(readFileSync(resolve(config.deploymentConfig), "utf8"));
+    if (deployment.network !== "testnet" || deployment.testOnly !== true || deployment.verifierVersion !== 2)
+        fail("SETUP_INVALID", "seller setup requires the pinned experimental v2 Testnet deployment");
+    return config;
+}
+function readConfig(path) {
+    ownerFile(path);
+    return validateConfig(JSON.parse(readFileSync(path, "utf8")));
+}
+export function createSellerSession(home) {
+    if (!existsSync(join(home, "profile.json")))
+        fail("SETUP_REQUIRED", "initialize the seller before creating an agent session");
+    const mcpScript = join(dirname(fileURLToPath(import.meta.url)), "mcp-bootstrap.js");
+    const mcp = `[mcp_servers.supercuts-seller]\ncommand = ${JSON.stringify(process.execPath)}\nargs = ${JSON.stringify([mcpScript])}\n[mcp_servers.supercuts-seller.env]\nSUPERCUTS_HOME = ${JSON.stringify(home)}\n`;
+    const mcpConfig = join(home, "seller-codex.toml");
+    writeFileSync(mcpConfig, mcp, { mode: 0o600 });
+    chmodSync(mcpConfig, 0o600);
+    return { mcpConfig };
+}
+function setupSellerConfig(home, config) {
+    if (existsSync(join(home, "profile.json")))
+        fail("PROFILE_EXISTS", "seller home already exists; create a separate home for another seller identity");
+    mkdirSync(home, { recursive: true, mode: 0o700 });
+    chmodSync(home, 0o700);
+    const keyPath = config.suiKeyFile ? resolve(config.suiKeyFile) : join(home, "seller.sui.key");
+    if (!config.suiKeyFile)
+        writeFileSync(keyPath, Ed25519Keypair.generate().getSecretKey(), { mode: 0o600, flag: "wx" });
+    ownerFile(keyPath);
+    initialize(home, {
+        role: "seller",
+        "deployment-config": resolve(config.deploymentConfig),
+        "sui-key-file": keyPath,
+        "tatum-key-file": resolve(config.tatumKeyFile),
+        "write-grpc": config.writeGrpc,
+        "tatum-grpc": config.tatumGrpc,
+        "walrus-publisher": config.walrusPublisher,
+        "walrus-aggregator": config.walrusAggregator,
+        ...(config.snarkjs ? { snarkjs: resolve(config.snarkjs) } : {}),
+        ...(config.converter ? { converter: resolve(config.converter) } : {}),
+        ...(config.rapidsnark ? { rapidsnark: resolve(config.rapidsnark) } : {}),
+    });
+    const decoded = decodeSuiPrivateKey(readFileSync(keyPath, "utf8").trim());
+    if (decoded.scheme !== "ED25519")
+        fail("SETUP_INVALID", "seller key must use ED25519");
+    const address = Ed25519Keypair.fromSecretKey(decoded.secretKey).toSuiAddress();
+    return {
+        home,
+        address,
+        fundingRequired: false,
+        warning: "Do not faucet-fund the seller. Only a generated buyer address is funded for live purchases.",
+        ...createSellerSession(home),
+        nextStep: `Run supercuts seller scaffold --home ${JSON.stringify(home)} --output <offer-dir> with the capability, origin, price, rails, and expiry options. Review the handler, then run the printed registration and service commands.`,
+    };
+}
+export function setupSeller(home, configPath) {
+    return setupSellerConfig(home, readConfig(resolve(configPath)));
+}
+export async function promptSellerSetup(home) {
+    if (!process.stdin.isTTY)
+        fail("SETUP_INPUT_REQUIRED", "interactive seller setup requires a terminal; use --config with an owner-only JSON file");
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    try {
+        const ask = async (label) => (await rl.question(`${label}: `)).trim();
+        const config = {
+            deploymentConfig: await ask("Pinned v2 Testnet deployment config path (blank for bundled config)"),
+            tatumKeyFile: await ask("Owner-only Tatum key file path"),
+            writeGrpc: await ask("Sui write gRPC URL"),
+            tatumGrpc: await ask("Tatum read gRPC URL"),
+            walrusPublisher: await ask("Walrus publisher URL"),
+            walrusAggregator: await ask("Walrus aggregator URL"),
+        };
+        const snarkjs = await ask("SnarkJS executable path (blank for deployment-relative default)");
+        const converter = await ask("Groth16 converter path (blank for deployment-relative default)");
+        const rapidsnark = await ask("RapidSnark executable path (blank to use SnarkJS)");
+        if (snarkjs)
+            config.snarkjs = snarkjs;
+        if (converter)
+            config.converter = converter;
+        if (rapidsnark)
+            config.rapidsnark = rapidsnark;
+        return setupSellerConfig(home, validateConfig(config));
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/x402-resource-service.d.ts

@@ -11,6 +11,8 @@ export interface X402ResourceServiceConfig {
     payTo: string;
     amount: string;
     maxTimeoutSeconds?: number;
+    /** Bounded retry schedule for transient facilitator cold starts. */
+    facilitatorRetryDelaysMs?: number[];
 }
 /** Seller-owned standard x402 v2 exact resource with additional request-binding replay protection. */
 export declare class X402ResourceService {

package/dist/x402-resource-service.js

@@ -67,8 +67,10 @@ export class X402ResourceService {
     challenge(artifact) {
         // The live Sui exact facilitator requires the x402 nonce to be exactly
         // 32 random bytes (hex encoded), not merely an application nonce.
-        const requirements = this.requirements(artifact), nonce = this.#ledger.challenge(artifact.requestId, requirementsHash(requirements), () => randomBytes(32).toString("hex"));
-        requirements.extra = { ...requirements.extra, nonce };
+        const requirements = this.requirements(artifact), baseHash = requirementsHash(requirements), nonce = this.#ledger.challenge(artifact.requestId, baseHash, () => randomBytes(32).toString("hex"));
+        const stored = this.#ledger.getChallenge(artifact.requestId, baseHash) ?? fail("X402_CHALLENGE_MISSING", "resource challenge was not persisted");
+        const expiresAt = stored.createdAt + requirements.maxTimeoutSeconds * 1_000;
+        requirements.extra = { ...requirements.extra, nonce, expiresAt };
         // The nonce changes the signed requirement set and is persisted per request.
         const finalHash = requirementsHash(requirements);
         return { x402Version: 2, resource: { url: this.resourceUrl(artifact.requestId), description: "Supercuts seller capability artifact", mimeType: "application/json" }, accepts: [{ ...requirements, extra: { ...requirements.extra, requirementsHash: finalHash } }] };
@@ -96,10 +98,10 @@ export class X402ResourceService {
             const offered = payload.accepted;
             if (!offered || requirementsHash(offered) !== requirementsHash(requirements))
                 fail("X402_REQUIREMENTS_MISMATCH", "payment payload changed the challenged requirements");
-            const extra = requirements.extra, nonce = String(extra.nonce ?? ""), declaredHash = String(extra.requirementsHash ?? "");
-            const unsignedRequirements = { ...requirements, extra: { requestId: extra.requestId, operationId: extra.operationId, nonce } };
-            if (declaredHash !== requirementsHash(unsignedRequirements))
-                fail("X402_REQUIREMENTS_MISMATCH", "challenge requirements hash is invalid");
+            const extra = requirements.extra, nonce = String(extra.nonce ?? ""), declaredHash = String(extra.requirementsHash ?? ""), expiresAt = Number(extra.expiresAt);
+            const unsignedRequirements = { ...requirements, extra: { requestId: extra.requestId, operationId: extra.operationId, nonce, expiresAt } };
+            if (!Number.isSafeInteger(expiresAt) || expiresAt !== stored.createdAt + requirements.maxTimeoutSeconds * 1_000 || declaredHash !== requirementsHash(unsignedRequirements))
+                fail("X402_REQUIREMENTS_MISMATCH", "challenge requirements hash or expiry is invalid");
             verifyBinding(binding, artifact.requestId, nonce, unsignedRequirements, binding.transactionDigest);
             const { payerSignature: _signature, ...unsignedBinding } = binding;
             if (!(await isValidPersonalMessageSignature(paymentBindingBytes(unsignedBinding), binding.payerSignature, { address: binding.payer })))
@@ -133,20 +135,37 @@ export class X402ResourceService {
     createServer() { return createServer((request, response) => void this.handle(request, response)); }
     async facilitator(path, body) {
         const endpoint = new URL(path, `${this.#facilitator.toString().replace(/\/$/, "")}/`);
-        const response = await this.http(endpoint, { method: "POST", headers: { "content-type": "application/json", "x-supercuts-facilitator-key": this.config.facilitatorKey }, body: JSON.stringify(body), signal: AbortSignal.timeout(60_000) });
-        let value;
-        try {
-            value = await response.json();
-        }
-        catch (error) {
-            return fail("X402_FACILITATOR_INVALID", "facilitator returned invalid JSON", error);
-        }
-        if (!response.ok || !value || typeof value !== "object" || Array.isArray(value)) {
+        const delays = this.config.facilitatorRetryDelaysMs ?? [0, 2_000, 5_000, 10_000];
+        let lastCause;
+        for (const delay of delays) {
+            if (delay > 0)
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            let response;
+            try {
+                response = await this.http(endpoint, { method: "POST", headers: { "content-type": "application/json", "x-supercuts-facilitator-key": this.config.facilitatorKey }, body: JSON.stringify(body), signal: AbortSignal.timeout(60_000) });
+            }
+            catch (error) {
+                lastCause = error;
+                continue;
+            }
+            const raw = Buffer.from(await response.arrayBuffer());
+            let value;
+            try {
+                value = JSON.parse(raw.toString("utf8"));
+            }
+            catch (error) {
+                lastCause = error;
+                continue;
+            }
+            if (response.ok && value && typeof value === "object" && !Array.isArray(value))
+                return value;
             const message = value && typeof value === "object" && !Array.isArray(value) && typeof value.message === "string"
                 ? `: ${value.message}` : "";
-            fail("X402_FACILITATOR_INVALID", `facilitator ${path} failed with ${response.status}${message}`);
+            if (response.status < 500)
+                fail("X402_FACILITATOR_INVALID", `facilitator ${path} failed with ${response.status}${message}`);
+            lastCause = new Error(`facilitator ${path} returned ${response.status}${message}`);
         }
-        return value;
+        return fail("X402_FACILITATOR_UNAVAILABLE", `facilitator ${path} remained unavailable after bounded retries`, lastCause);
     }
     send(response, status, body, headers = {}) { response.writeHead(status, { "content-length": String(body.length), ...headers }); response.end(body); }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supercuts-walrus/backend",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "private": false,
   "type": "module",
   "exports": {
@@ -29,6 +29,7 @@
   },
   "files": [
     "dist",
+    "config",
     "README.md"
   ],
   "license": "Apache-2.0",