@faremeter/payment-solana 0.20.1 → 0.21.0

package/dist/src/flex/facilitator/index.d.ts

@@ -0,0 +1,5 @@
+export { createFacilitatorHandler } from "./handler.js";
+export type { FlexFacilitator, FlushResult } from "./handler.js";
+export { fetchEscrowAccounting } from "@faremeter/flex-solana/facilitator";
+export type { HoldEntry, EscrowAccounting, } from "@faremeter/flex-solana/facilitator";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/flex/facilitator/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/flex/facilitator/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,WAAW,CAAC;AACrD,YAAY,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAC9D,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,YAAY,EACV,SAAS,EACT,gBAAgB,GACjB,MAAM,oCAAoC,CAAC"}

package/dist/src/flex/facilitator/index.js

@@ -0,0 +1,2 @@
+export { createFacilitatorHandler } from "./handler.js";
+export { fetchEscrowAccounting } from "@faremeter/flex-solana/facilitator";

package/dist/src/flex/hono/index.d.ts

@@ -0,0 +1,3 @@
+export { createUptoHandler } from "./upto-handler.js";
+export type { CreateUptoHandlerOpts, UptoAccept, SettleFunction, } from "./upto-handler.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/flex/hono/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/flex/hono/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnD,YAAY,EACV,qBAAqB,EACrB,UAAU,EACV,cAAc,GACf,MAAM,gBAAgB,CAAC"}

package/dist/src/flex/hono/index.js

@@ -0,0 +1 @@
+export { createUptoHandler } from "./upto-handler.js";

package/dist/src/flex/hono/upto-handler.d.ts

@@ -0,0 +1,20 @@
+import type { Handler } from "hono";
+import type { x402SettleResponse } from "@faremeter/types/x402v2";
+export type UptoAccept = {
+    scheme: string;
+    network: string;
+    amount: string;
+    asset: string;
+    payTo: string;
+    maxTimeoutSeconds?: number;
+};
+export type SettleFunction = (amount: bigint) => Promise<x402SettleResponse>;
+export type CreateUptoHandlerOpts = {
+    facilitatorURL: string;
+    accepts: UptoAccept[];
+    authorize: (body: unknown) => bigint | Promise<bigint>;
+    handle: (body: unknown, settle: SettleFunction) => Promise<Response>;
+    fetch?: typeof fetch;
+};
+export declare function createUptoHandler(opts: CreateUptoHandlerOpts): Handler;
+//# sourceMappingURL=upto-handler.d.ts.map

package/dist/src/flex/hono/upto-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upto-handler.d.ts","sourceRoot":"","sources":["../../../../src/flex/hono/upto-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAW,OAAO,EAAE,MAAM,MAAM,CAAC;AAc7C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE,MAAM,MAAM,UAAU,GAAG;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,kBAAkB,CAAC,CAAC;AAE7E,MAAM,MAAM,qBAAqB,GAAG;IAClC,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,UAAU,EAAE,CAAC;IACtB,SAAS,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACvD,MAAM,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,cAAc,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;IACrE,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;CACtB,CAAC;AAEF,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,qBAAqB,GAAG,OAAO,CAoFtE"}

package/dist/src/flex/hono/upto-handler.js

@@ -0,0 +1,72 @@
+import { handleMiddlewareRequest, resolveSupportedVersions, deriveCapabilities, deriveResourceInfo, acceptsToPricing, relaxedRequirementsToV2, } from "@faremeter/middleware/common";
+import { createHTTPFacilitatorHandler } from "@faremeter/middleware";
+export function createUptoHandler(opts) {
+    const supportedVersions = resolveSupportedVersions({
+        x402v1: false,
+        x402v2: true,
+    });
+    const middlewareAccepts = opts.accepts.map(({ amount, ...rest }) => ({
+        ...rest,
+        maxAmountRequired: amount,
+    }));
+    const capabilities = deriveCapabilities(middlewareAccepts);
+    const handler = createHTTPFacilitatorHandler(opts.facilitatorURL, {
+        capabilities,
+        acceptsOverride: middlewareAccepts.map(relaxedRequirementsToV2),
+        ...(opts.fetch ? { fetch: opts.fetch } : {}),
+    });
+    const pricing = acceptsToPricing(middlewareAccepts);
+    const resourceInfo = deriveResourceInfo(middlewareAccepts, "");
+    return async (c) => {
+        const args = {
+            x402Handlers: [handler],
+            pricing,
+            supportedVersions,
+            resource: c.req.url,
+            resourceInfo: { ...resourceInfo, url: c.req.url },
+            getHeader: (key) => c.req.header(key),
+            setResponseHeader: (key, value) => c.header(key, value),
+            sendJSONResponse: (status, jsonBody, headers) => {
+                c.status(status);
+                if (headers) {
+                    for (const [key, value] of Object.entries(headers)) {
+                        c.header(key, value);
+                    }
+                }
+                return jsonBody ? c.json(jsonBody) : c.body(null);
+            },
+            body: async (ctx) => {
+                if (ctx.protocolVersion !== 2) {
+                    return c.json({ error: "upto requires x402 v2" }, 400);
+                }
+                const verifyResult = await ctx.verify();
+                if (!verifyResult.success)
+                    return verifyResult.errorResponse;
+                const body = await c.req.json();
+                const ceiling = await opts.authorize(body);
+                let settled = false;
+                const settle = async (amount) => {
+                    if (settled) {
+                        throw new Error("settle() has already been called");
+                    }
+                    if (amount < 0n) {
+                        throw new Error("Settle amount must be non-negative");
+                    }
+                    if (amount > ceiling) {
+                        throw new Error(`Settle amount ${amount} exceeds authorized ceiling ${ceiling}`);
+                    }
+                    settled = true;
+                    // XXX - Mutate in place: ctx.settle() closes over the original object reference
+                    ctx.paymentRequirements.amount = amount.toString();
+                    const result = await ctx.settle();
+                    if (!result.success) {
+                        throw new Error(`Settlement failed for amount ${amount} (ceiling ${ceiling})`);
+                    }
+                    return result.facilitatorResponse;
+                };
+                return opts.handle(body, settle);
+            },
+        };
+        return handleMiddlewareRequest(args);
+    };
+}

package/dist/src/flex/hono/upto-handler.test.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env pnpm tsx
+export {};
+//# sourceMappingURL=upto-handler.test.d.ts.map

package/dist/src/flex/hono/upto-handler.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upto-handler.test.d.ts","sourceRoot":"","sources":["../../../../src/flex/hono/upto-handler.test.ts"],"names":[],"mappings":""}

package/dist/src/flex/hono/upto-handler.test.js

@@ -0,0 +1,381 @@
+#!/usr/bin/env pnpm tsx
+import t from "tap";
+import { Hono } from "hono";
+import { createUptoHandler } from "./upto-handler.js";
+const SCHEME = "upto";
+const NETWORK = "solana:devnet";
+const ASSET = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+const PAY_TO = "J8tVV2K1Lf9P3E7vXqFm4TnUz4DqvJAA8bFkaiAAaaaa";
+const REQUIREMENTS = {
+    scheme: SCHEME,
+    network: NETWORK,
+    amount: "10000",
+    asset: ASSET,
+    payTo: PAY_TO,
+    maxTimeoutSeconds: 60,
+};
+const PAYMENT_PAYLOAD = {
+    x402Version: 2,
+    accepted: REQUIREMENTS,
+    payload: { escrow: "test", signature: "test" },
+};
+function encodePaymentHeader(payload) {
+    return btoa(JSON.stringify(payload));
+}
+function createMockFetch(overrides) {
+    const calls = [];
+    const mockFetch = async (input, init) => {
+        const url = typeof input === "string"
+            ? input
+            : input instanceof URL
+                ? input.toString()
+                : new URL(input.url).toString();
+        const body = init?.body
+            ? JSON.parse(init.body)
+            : { paymentRequirements: { amount: "" } };
+        calls.push({ url, body });
+        if (url.endsWith("/accepts")) {
+            return Response.json(overrides?.acceptsResponse ?? {
+                x402Version: 2,
+                resource: { url: "http://localhost/test" },
+                accepts: [REQUIREMENTS],
+            });
+        }
+        if (url.endsWith("/verify")) {
+            return Response.json(overrides?.verifyResponse ?? {
+                isValid: true,
+                payer: "payer123",
+            });
+        }
+        if (url.endsWith("/settle")) {
+            return Response.json(overrides?.settleResponse ?? {
+                success: true,
+                transaction: "tx123",
+                network: NETWORK,
+                payer: "payer123",
+            });
+        }
+        return new Response("Not found", { status: 404 });
+    };
+    return { fetch: mockFetch, calls };
+}
+function createTestApp(opts) {
+    const mock = createMockFetch(opts);
+    const authorize = opts?.authorize ?? ((_body) => 10000n);
+    const handle = opts?.handle ??
+        (async (_body, settle) => {
+            const settlement = await settle(5000n);
+            return Response.json({ result: "ok", payment: settlement });
+        });
+    const app = new Hono();
+    app.post("/test", createUptoHandler({
+        facilitatorURL: "http://facilitator",
+        accepts: [
+            {
+                scheme: SCHEME,
+                network: NETWORK,
+                amount: "10000",
+                asset: ASSET,
+                payTo: PAY_TO,
+                maxTimeoutSeconds: 60,
+            },
+        ],
+        authorize,
+        handle,
+        fetch: mock.fetch,
+        ...opts,
+    }));
+    return { app, mock };
+}
+function findCall(calls, endpoint) {
+    const call = calls.find((c) => c.url.endsWith(endpoint));
+    if (!call)
+        throw new Error(`No call to ${endpoint} found`);
+    return call;
+}
+await t.test("createUptoHandler", async (t) => {
+    await t.test("returns 402 when no payment header is present", async (t) => {
+        const { app } = createTestApp();
+        const res = await app.request("/test", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ max_tokens: 100 }),
+        });
+        t.equal(res.status, 402);
+        const header = res.headers.get("PAYMENT-REQUIRED");
+        if (!header)
+            throw new Error("Missing PAYMENT-REQUIRED header");
+        const decoded = JSON.parse(atob(header));
+        t.equal(decoded.accepts.length, 1);
+        t.equal(decoded.accepts[0]?.scheme, SCHEME);
+    });
+    await t.test("verifies, authorizes, and settles a valid payment", async (t) => {
+        const { app, mock } = createTestApp();
+        const res = await app.request("/test", {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "PAYMENT-SIGNATURE": encodePaymentHeader(PAYMENT_PAYLOAD),
+            },
+            body: JSON.stringify({ max_tokens: 100 }),
+        });
+        t.equal(res.status, 200);
+        const body = (await res.json());
+        t.equal(body.result, "ok");
+        t.equal(body.payment.success, true);
+        t.equal(body.payment.transaction, "tx123");
+        findCall(mock.calls, "/verify");
+        const settleCall = findCall(mock.calls, "/settle");
+        t.equal(settleCall.body.paymentRequirements.amount, "5000");
+    });
+    await t.test("passes parsed body to authorize callback", async (t) => {
+        let receivedBody;
+        const { app } = createTestApp({
+            authorize: (body) => {
+                receivedBody = body;
+                return 10000n;
+            },
+        });
+        await app.request("/test", {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "PAYMENT-SIGNATURE": encodePaymentHeader(PAYMENT_PAYLOAD),
+            },
+            body: JSON.stringify({ max_tokens: 42 }),
+        });
+        t.strictSame(receivedBody, { max_tokens: 42 });
+    });
+    await t.test("passes parsed body to handle callback", async (t) => {
+        let receivedBody;
+        const { app } = createTestApp({
+            handle: async (body, settle) => {
+                receivedBody = body;
+                await settle(100n);
+                return Response.json({ ok: true });
+            },
+        });
+        await app.request("/test", {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "PAYMENT-SIGNATURE": encodePaymentHeader(PAYMENT_PAYLOAD),
+            },
+            body: JSON.stringify({ prompt: "hello" }),
+        });
+        t.strictSame(receivedBody, { prompt: "hello" });
+    });
+    await t.test("throws when settle amount exceeds ceiling", async (t) => {
+        const { app } = createTestApp({
+            authorize: () => 100n,
+            handle: async (_body, settle) => {
+                await settle(200n);
+                return Response.json({ ok: true });
+            },
+        });
+        const res = await app.request("/test", {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "PAYMENT-SIGNATURE": encodePaymentHeader(PAYMENT_PAYLOAD),
+            },
+            body: JSON.stringify({}),
+        });
+        t.equal(res.status, 500);
+    });
+    await t.test("mutates requirements.amount before calling facilitator settle", async (t) => {
+        const { app, mock } = createTestApp({
+            authorize: () => 10000n,
+            handle: async (_body, settle) => {
+                await settle(7777n);
+                return Response.json({ ok: true });
+            },
+        });
+        await app.request("/test", {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "PAYMENT-SIGNATURE": encodePaymentHeader(PAYMENT_PAYLOAD),
+            },
+            body: JSON.stringify({}),
+        });
+        const settleCall = findCall(mock.calls, "/settle");
+        t.equal(settleCall.body.paymentRequirements.amount, "7777");
+    });
+    await t.test("returns 402 when verification fails", async (t) => {
+        const mock = createMockFetch({
+            verifyResponse: { isValid: false, invalidReason: "bad signature" },
+        });
+        const app = new Hono();
+        app.post("/test", createUptoHandler({
+            facilitatorURL: "http://facilitator",
+            accepts: [
+                {
+                    scheme: SCHEME,
+                    network: NETWORK,
+                    amount: "10000",
+                    asset: ASSET,
+                    payTo: PAY_TO,
+                },
+            ],
+            authorize: () => 10000n,
+            handle: async (_body, settle) => {
+                await settle(100n);
+                return Response.json({ ok: true });
+            },
+            fetch: mock.fetch,
+        }));
+        const res = await app.request("/test", {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "PAYMENT-SIGNATURE": encodePaymentHeader(PAYMENT_PAYLOAD),
+            },
+            body: JSON.stringify({}),
+        });
+        t.equal(res.status, 402);
+    });
+    await t.test("throws when facilitator settlement fails", async (t) => {
+        const mock = createMockFetch({
+            settleResponse: {
+                success: false,
+                transaction: "",
+                network: NETWORK,
+                errorReason: "insufficient funds",
+            },
+        });
+        const app = new Hono();
+        app.post("/test", createUptoHandler({
+            facilitatorURL: "http://facilitator",
+            accepts: [
+                {
+                    scheme: SCHEME,
+                    network: NETWORK,
+                    amount: "10000",
+                    asset: ASSET,
+                    payTo: PAY_TO,
+                },
+            ],
+            authorize: () => 10000n,
+            handle: async (_body, settle) => {
+                await settle(100n);
+                return Response.json({ ok: true });
+            },
+            fetch: mock.fetch,
+        }));
+        const res = await app.request("/test", {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "PAYMENT-SIGNATURE": encodePaymentHeader(PAYMENT_PAYLOAD),
+            },
+            body: JSON.stringify({}),
+        });
+        t.equal(res.status, 500);
+    });
+    await t.test("supports async authorize callback", async (t) => {
+        const { app } = createTestApp({
+            authorize: async () => {
+                await new Promise((resolve) => setTimeout(resolve, 10));
+                return 10000n;
+            },
+        });
+        const res = await app.request("/test", {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "PAYMENT-SIGNATURE": encodePaymentHeader(PAYMENT_PAYLOAD),
+            },
+            body: JSON.stringify({}),
+        });
+        t.equal(res.status, 200);
+    });
+    await t.test("settle can be called with zero amount", async (t) => {
+        const { app, mock } = createTestApp({
+            authorize: () => 10000n,
+            handle: async (_body, settle) => {
+                await settle(0n);
+                return Response.json({ ok: true });
+            },
+        });
+        const res = await app.request("/test", {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "PAYMENT-SIGNATURE": encodePaymentHeader(PAYMENT_PAYLOAD),
+            },
+            body: JSON.stringify({}),
+        });
+        t.equal(res.status, 200);
+        const settleCall = findCall(mock.calls, "/settle");
+        t.equal(settleCall.body.paymentRequirements.amount, "0");
+    });
+    await t.test("settle at exactly the ceiling amount succeeds", async (t) => {
+        const { app } = createTestApp({
+            authorize: () => 5000n,
+            handle: async (_body, settle) => {
+                await settle(5000n);
+                return Response.json({ ok: true });
+            },
+        });
+        const res = await app.request("/test", {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "PAYMENT-SIGNATURE": encodePaymentHeader(PAYMENT_PAYLOAD),
+            },
+            body: JSON.stringify({}),
+        });
+        t.equal(res.status, 200);
+    });
+    await t.test("throws when settle is called twice", async (t) => {
+        const { app } = createTestApp({
+            authorize: () => 10000n,
+            handle: async (_body, settle) => {
+                await settle(1000n);
+                await settle(2000n);
+                return Response.json({ ok: true });
+            },
+        });
+        const res = await app.request("/test", {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "PAYMENT-SIGNATURE": encodePaymentHeader(PAYMENT_PAYLOAD),
+            },
+            body: JSON.stringify({}),
+        });
+        t.equal(res.status, 500);
+    });
+    await t.test("handler returns streaming response", async (t) => {
+        const { app } = createTestApp({
+            handle: async (_body, settle) => {
+                const encoder = new TextEncoder();
+                const stream = new ReadableStream({
+                    async start(controller) {
+                        controller.enqueue(encoder.encode("data: chunk1\n\n"));
+                        const settlement = await settle(100n);
+                        controller.enqueue(encoder.encode(`data: ${JSON.stringify(settlement)}\n\n`));
+                        controller.close();
+                    },
+                });
+                return new Response(stream, {
+                    headers: { "content-type": "text/event-stream" },
+                });
+            },
+        });
+        const res = await app.request("/test", {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "PAYMENT-SIGNATURE": encodePaymentHeader(PAYMENT_PAYLOAD),
+            },
+            body: JSON.stringify({}),
+        });
+        t.equal(res.status, 200);
+        t.equal(res.headers.get("content-type"), "text/event-stream");
+        const text = await res.text();
+        t.ok(text.includes("chunk1"));
+        t.ok(text.includes("tx123"));
+    });
+});

package/dist/src/flex/index.d.ts

@@ -0,0 +1,4 @@
+export * as client from "./client/index.js";
+export * as facilitator from "./facilitator/index.js";
+export * as hono from "./hono/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/flex/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/flex/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,gBAAgB,CAAC;AACzC,OAAO,KAAK,WAAW,MAAM,qBAAqB,CAAC;AACnD,OAAO,KAAK,IAAI,MAAM,cAAc,CAAC"}

package/dist/src/flex/index.js

@@ -0,0 +1,3 @@
+export * as client from "./client/index.js";
+export * as facilitator from "./facilitator/index.js";
+export * as hono from "./hono/index.js";

package/dist/src/flex/logger.d.ts

@@ -0,0 +1,2 @@
+export declare const logger: import("@faremeter/logs").Logger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/src/flex/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../src/flex/logger.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,MAAM,kCAAgD,CAAC"}

package/dist/src/flex/logger.js

@@ -0,0 +1,2 @@
+import { getLogger } from "@faremeter/logs";
+export const logger = await getLogger(["faremeter", "flex-solana"]);

package/dist/src/index.d.ts

@@ -22,4 +22,5 @@ export * as charge from "./charge/index.js";
  * @description SPL token balance and account utilities
  */
 export * as splToken from "./splToken.js";
+export * as flex from "./flex/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH;;;;GAIG;AACH,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC;;;;GAIG;AACH,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC;;;;GAIG;AACH,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH;;;;GAIG;AACH,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC;;;;GAIG;AACH,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC;;;;GAIG;AACH,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAC"}

package/dist/src/index.js

@@ -22,3 +22,4 @@ export * as charge from "./charge/index.js";
  * @description SPL token balance and account utilities
  */
 export * as splToken from "./splToken.js";
+export * as flex from "./flex/index.js";