@runtab/mcp 0.0.1

package/dist/durable-payment-fetch.js

@@ -0,0 +1,117 @@
+import { x402HTTPClient } from "@x402/core/client";
+import { newPaymentEnvelope } from "./payment-envelope.js";
+import { PaymentEnvelopeJournal, PaymentIdempotencyRequiredError, PaymentReconciliationRequiredError, } from "./payment-envelope-journal.js";
+import { fingerprintPaymentRequest } from "./payment-request-fingerprint.js";
+const MAX_PAYMENT_REQUIRED_BODY_BYTES = 65_536;
+async function boundedJson(response) {
+    if (!response.body)
+        return undefined;
+    const reader = response.body.getReader();
+    const chunks = [];
+    let length = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            length += value.byteLength;
+            if (length > MAX_PAYMENT_REQUIRED_BODY_BYTES) {
+                await reader.cancel().catch(() => undefined);
+                throw new Error("Payment-required response is too large");
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    const bytes = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    return text ? JSON.parse(text) : undefined;
+}
+async function paymentRequired(response, client) {
+    const getHeader = (name) => response.headers.get(name);
+    try {
+        const required = client.getPaymentRequiredResponse(getHeader);
+        void response.body?.cancel().catch(() => undefined);
+        return required;
+    }
+    catch {
+        const body = await boundedJson(response);
+        return client.getPaymentRequiredResponse(getHeader, body);
+    }
+}
+export function createDurablePaymentFetch(options) {
+    const httpClient = new x402HTTPClient(options.client);
+    const journal = new PaymentEnvelopeJournal({
+        address: options.address,
+        ...(options.authorizationState ? { authorizationState: options.authorizationState } : {}),
+        ...(options.nowSeconds ? { nowSeconds: options.nowSeconds } : {}),
+        paymentProfile: options.paymentProfile,
+        signer: options.signer,
+        store: options.store,
+    });
+    async function processPaidResponse(response, parsed, idempotencyKey, requestFingerprint) {
+        const result = await httpClient.processPaymentResult(parsed.payload, (name) => response.headers.get(name), response.status);
+        if (result.settleResponse) {
+            const observed = await journal.recordObservation(idempotencyKey, requestFingerprint, parsed, result.settleResponse);
+            if (observed) {
+                await journal.reconcileObserved(idempotencyKey, requestFingerprint, observed, parsed);
+            }
+        }
+        return response;
+    }
+    async function sendEnvelope(request, envelope, idempotencyKey, requestFingerprint) {
+        const parsed = await journal.parse(envelope);
+        await journal.reconcileObserved(idempotencyKey, requestFingerprint, envelope, parsed);
+        request.headers.set("PAYMENT-SIGNATURE", envelope.paymentSignature);
+        request.headers.set("Access-Control-Expose-Headers", "PAYMENT-RESPONSE,X-PAYMENT-RESPONSE");
+        const response = await options.fetch(request);
+        return processPaidResponse(response, parsed, idempotencyKey, requestFingerprint);
+    }
+    return async (input, init) => {
+        const request = new Request(input, init);
+        const paymentRequest = request.clone();
+        const requestFingerprint = await fingerprintPaymentRequest(request.clone());
+        const idempotencyKey = options.idempotencyKey();
+        if (idempotencyKey) {
+            const existing = await journal.load(idempotencyKey, requestFingerprint);
+            if (existing) {
+                return sendEnvelope(paymentRequest, existing, idempotencyKey, requestFingerprint);
+            }
+        }
+        const response = await options.fetch(request);
+        if (response.status !== 402)
+            return response;
+        if (!idempotencyKey) {
+            await response.body?.cancel().catch(() => undefined);
+            throw new PaymentIdempotencyRequiredError();
+        }
+        const required = await paymentRequired(response, httpClient);
+        const hookHeaders = await httpClient.handlePaymentRequired(required);
+        if (hookHeaders) {
+            const hookRequest = paymentRequest.clone();
+            for (const [name, value] of Object.entries(hookHeaders))
+                hookRequest.headers.set(name, value);
+            const hookResponse = await options.fetch(hookRequest);
+            if (hookResponse.status !== 402)
+                return hookResponse;
+            await hookResponse.body?.cancel().catch(() => undefined);
+        }
+        const envelope = await journal.getOrCreate(idempotencyKey, requestFingerprint, async () => {
+            const payload = await options.client.createPaymentPayload(required);
+            const headers = httpClient.encodePaymentSignatureHeader(payload);
+            const paymentSignature = headers["PAYMENT-SIGNATURE"];
+            if (!paymentSignature)
+                throw new Error("The x402 payment header is invalid");
+            return newPaymentEnvelope(payload, paymentSignature, options.signer);
+        });
+        return sendEnvelope(paymentRequest, envelope, idempotencyKey, requestFingerprint);
+    };
+}
+export { PaymentIdempotencyRequiredError, PaymentReconciliationRequiredError };

package/dist/eip3009-authorization.d.ts

@@ -0,0 +1,59 @@
+import type { PaymentProfile } from "./payment-profile.js";
+export declare const MAX_USDC_AMOUNT_ATOMIC: bigint;
+export interface SignerRequest {
+    domain: Record<string, unknown>;
+    message: Record<string, unknown>;
+    primaryType: string;
+    types: Record<string, unknown>;
+}
+export declare class InvalidEip3009AuthorizationError extends Error {
+    constructor();
+}
+export declare function parseExactEip3009Authorization(value: SignerRequest, options: {
+    address: `0x${string}`;
+    nowSeconds: number;
+    paymentProfile: PaymentProfile;
+}): {
+    amount: string;
+    asset: `0x${string}`;
+    network: "eip155:8453" | "eip155:42161" | "eip155:84532";
+    payTo: `0x${string}`;
+    typedData: {
+        domain: {
+            chainId: number;
+            name: string;
+            verifyingContract: `0x${string}`;
+            version: string;
+        };
+        message: {
+            from: `0x${string}`;
+            nonce: `0x${string}`;
+            to: `0x${string}`;
+            validAfter: bigint;
+            validBefore: bigint;
+            value: bigint;
+        };
+        primaryType: "TransferWithAuthorization";
+        types: {
+            TransferWithAuthorization: readonly [{
+                readonly name: "from";
+                readonly type: "address";
+            }, {
+                readonly name: "to";
+                readonly type: "address";
+            }, {
+                readonly name: "value";
+                readonly type: "uint256";
+            }, {
+                readonly name: "validAfter";
+                readonly type: "uint256";
+            }, {
+                readonly name: "validBefore";
+                readonly type: "uint256";
+            }, {
+                readonly name: "nonce";
+                readonly type: "bytes32";
+            }];
+        };
+    };
+};

package/dist/eip3009-authorization.js

@@ -0,0 +1,142 @@
+import { getAddress } from "viem";
+import { ARBITRUM_NETWORK, ARBITRUM_USDC, BASE_NETWORK, BASE_SEPOLIA_NETWORK, BASE_SEPOLIA_USDC, BASE_USDC, } from "./routing.js";
+const MAX_AUTHORIZATION_LIFETIME_SECONDS = 600;
+// Mirrors numeric(20,0) cap cents at 10,000 atomic USDC units per cent.
+const MAX_CAP_USD_CENTS = 10n ** 20n - 1n;
+const ATOMIC_UNITS_PER_CENT = 10000n;
+export const MAX_USDC_AMOUNT_ATOMIC = MAX_CAP_USD_CENTS * ATOMIC_UNITS_PER_CENT;
+const AUTHORIZATION_TYPES = [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { name: "nonce", type: "bytes32" },
+];
+export class InvalidEip3009AuthorizationError extends Error {
+    constructor() {
+        super("The EIP-3009 authorization is invalid.");
+        this.name = "InvalidEip3009AuthorizationError";
+    }
+}
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function exactRecord(value, sortedKeys) {
+    if (!record(value))
+        throw new InvalidEip3009AuthorizationError();
+    const keys = Object.keys(value).sort();
+    if (keys.length !== sortedKeys.length || keys.some((key, index) => key !== sortedKeys[index])) {
+        throw new InvalidEip3009AuthorizationError();
+    }
+    return value;
+}
+function unsigned(value) {
+    if (typeof value === "bigint" && value >= 0n)
+        return value.toString();
+    if (typeof value === "string" && /^(0|[1-9][0-9]*)$/.test(value))
+        return value;
+    throw new InvalidEip3009AuthorizationError();
+}
+function address(value) {
+    if (typeof value !== "string")
+        throw new InvalidEip3009AuthorizationError();
+    try {
+        return getAddress(value);
+    }
+    catch {
+        throw new InvalidEip3009AuthorizationError();
+    }
+}
+function network(chainIdValue, paymentProfile) {
+    const chainId = typeof chainIdValue === "number" && Number.isSafeInteger(chainIdValue)
+        ? String(chainIdValue)
+        : unsigned(chainIdValue);
+    if (paymentProfile === "mainnet" && chainId === "8453") {
+        return { asset: getAddress(BASE_USDC), chainId: 8453, name: "USD Coin", network: BASE_NETWORK };
+    }
+    if (paymentProfile === "mainnet" && chainId === "42161") {
+        return {
+            asset: getAddress(ARBITRUM_USDC),
+            chainId: 42161,
+            name: "USD Coin",
+            network: ARBITRUM_NETWORK,
+        };
+    }
+    if (paymentProfile === "base_sepolia_integration" && chainId === "84532") {
+        return {
+            asset: getAddress(BASE_SEPOLIA_USDC),
+            chainId: 84532,
+            name: "USDC",
+            network: BASE_SEPOLIA_NETWORK,
+        };
+    }
+    throw new InvalidEip3009AuthorizationError();
+}
+export function parseExactEip3009Authorization(value, options) {
+    const request = exactRecord(value, ["domain", "message", "primaryType", "types"]);
+    if (request.primaryType !== "TransferWithAuthorization") {
+        throw new InvalidEip3009AuthorizationError();
+    }
+    const domain = exactRecord(request.domain, ["chainId", "name", "verifyingContract", "version"]);
+    const selectedNetwork = network(domain.chainId, options.paymentProfile);
+    const asset = address(domain.verifyingContract);
+    if (domain.name !== selectedNetwork.name ||
+        domain.version !== "2" ||
+        asset !== selectedNetwork.asset) {
+        throw new InvalidEip3009AuthorizationError();
+    }
+    const types = exactRecord(request.types, ["TransferWithAuthorization"]);
+    if (JSON.stringify(types.TransferWithAuthorization) !== JSON.stringify(AUTHORIZATION_TYPES)) {
+        throw new InvalidEip3009AuthorizationError();
+    }
+    const message = exactRecord(request.message, [
+        "from",
+        "nonce",
+        "to",
+        "validAfter",
+        "validBefore",
+        "value",
+    ]);
+    const from = address(message.from);
+    const payTo = address(message.to);
+    const amount = unsigned(message.value);
+    const validAfter = unsigned(message.validAfter);
+    const validBefore = unsigned(message.validBefore);
+    const nonce = message.nonce;
+    if (from !== getAddress(options.address) ||
+        amount === "0" ||
+        BigInt(amount) > MAX_USDC_AMOUNT_ATOMIC ||
+        validAfter !== "0" ||
+        typeof nonce !== "string" ||
+        !/^0x[0-9a-fA-F]{64}$/.test(nonce) ||
+        BigInt(validBefore) <= BigInt(options.nowSeconds) ||
+        BigInt(validBefore) > BigInt(options.nowSeconds + MAX_AUTHORIZATION_LIFETIME_SECONDS)) {
+        throw new InvalidEip3009AuthorizationError();
+    }
+    const authorizationNonce = nonce;
+    return {
+        amount,
+        asset,
+        network: selectedNetwork.network,
+        payTo,
+        typedData: {
+            domain: {
+                chainId: selectedNetwork.chainId,
+                name: selectedNetwork.name,
+                verifyingContract: asset,
+                version: "2",
+            },
+            message: {
+                from,
+                nonce: authorizationNonce,
+                to: payTo,
+                validAfter: BigInt(validAfter),
+                validBefore: BigInt(validBefore),
+                value: BigInt(amount),
+            },
+            primaryType: "TransferWithAuthorization",
+            types: { TransferWithAuthorization: AUTHORIZATION_TYPES },
+        },
+    };
+}

package/dist/errors.d.ts

@@ -0,0 +1,4 @@
+export declare class SignerNotConfiguredError extends Error {
+    readonly code = "SIGNER_NOT_CONFIGURED";
+    constructor();
+}

package/dist/errors.js

@@ -0,0 +1,7 @@
+export class SignerNotConfiguredError extends Error {
+    code = "SIGNER_NOT_CONFIGURED";
+    constructor() {
+        super("SIGNER_NOT_CONFIGURED: Agent signing is not configured for this agent.");
+        this.name = "SignerNotConfiguredError";
+    }
+}

package/dist/fetch-wire.d.ts

@@ -0,0 +1,46 @@
+export declare const PAID_FETCH_INPUT_SCHEMA: {
+    additionalProperties: boolean;
+    properties: {
+        body: {
+            maxLength: number;
+            type: "string";
+        };
+        headers: {
+            additionalProperties: {
+                type: "string";
+            };
+            maxProperties: number;
+            type: "object";
+        };
+        idempotencyKey: {
+            maxLength: number;
+            pattern: string;
+            type: "string";
+        };
+        method: {
+            enum: string[];
+            type: "string";
+        };
+        url: {
+            maxLength: number;
+            type: "string";
+        };
+    };
+    required: string[];
+    type: "object";
+};
+export interface ParsedFetchRequest {
+    body?: string;
+    headers?: Record<string, string>;
+    idempotencyKey: string;
+    method: string;
+    url: string;
+}
+export declare function parsePaidFetchRequest(value: unknown, options?: {
+    allowDevelopmentLoopback?: boolean;
+}): ParsedFetchRequest;
+export declare function readBoundedResponse(response: Response): Promise<{
+    body: string;
+    truncated: boolean;
+}>;
+export declare function readResponseHeaders(response: Response): Record<string, string>;

package/dist/fetch-wire.js

@@ -0,0 +1,143 @@
+import { validatePaymentTarget } from "./payment-target-policy.js";
+const MAX_BODY_BYTES = 1_048_576;
+const MAX_HEADERS = 32;
+const MAX_RESPONSE_BYTES = 262_144;
+const MAX_URL_LENGTH = 2_048;
+const IDEMPOTENCY_KEY_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+const METHODS = new Set(["DELETE", "GET", "HEAD", "PATCH", "POST", "PUT"]);
+const FORBIDDEN_HEADERS = new Set(["connection", "content-length", "host", "transfer-encoding"]);
+export const PAID_FETCH_INPUT_SCHEMA = {
+    additionalProperties: false,
+    properties: {
+        body: { maxLength: MAX_BODY_BYTES, type: "string" },
+        headers: {
+            additionalProperties: { type: "string" },
+            maxProperties: MAX_HEADERS,
+            type: "object",
+        },
+        idempotencyKey: {
+            maxLength: 128,
+            pattern: IDEMPOTENCY_KEY_PATTERN.source,
+            type: "string",
+        },
+        method: { enum: [...METHODS], type: "string" },
+        url: { maxLength: MAX_URL_LENGTH, type: "string" },
+    },
+    required: ["idempotencyKey", "url"],
+    type: "object",
+};
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseHeaders(value) {
+    if (value === undefined)
+        return undefined;
+    if (!record(value) || Object.keys(value).length > MAX_HEADERS)
+        throw new Error("headers");
+    const headers = {};
+    let totalBytes = 0;
+    for (const [name, headerValue] of Object.entries(value)) {
+        const normalized = name.toLowerCase();
+        if (!/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(name) ||
+            FORBIDDEN_HEADERS.has(normalized) ||
+            typeof headerValue !== "string" ||
+            /[\r\n]/.test(headerValue)) {
+            throw new Error("headers");
+        }
+        totalBytes += Buffer.byteLength(name) + Buffer.byteLength(headerValue);
+        if (totalBytes > 32_768)
+            throw new Error("headers");
+        headers[name] = headerValue;
+    }
+    return headers;
+}
+export function parsePaidFetchRequest(value, options = {}) {
+    if (!record(value))
+        throw new Error("request");
+    const keys = Object.keys(value);
+    if (keys.some((key) => !["body", "headers", "idempotencyKey", "method", "url"].includes(key))) {
+        throw new Error("request");
+    }
+    if (typeof value.idempotencyKey !== "string" ||
+        !IDEMPOTENCY_KEY_PATTERN.test(value.idempotencyKey)) {
+        throw new Error("idempotencyKey");
+    }
+    if (typeof value.url !== "string" ||
+        value.url.length === 0 ||
+        value.url.length > MAX_URL_LENGTH) {
+        throw new Error("url");
+    }
+    let url;
+    try {
+        url = new URL(value.url);
+    }
+    catch {
+        throw new Error("url");
+    }
+    if ((url.protocol !== "http:" && url.protocol !== "https:") ||
+        url.username.length > 0 ||
+        url.password.length > 0) {
+        throw new Error("url");
+    }
+    const method = value.method === undefined ? "GET" : value.method;
+    if (typeof method !== "string" || method !== method.toUpperCase() || !METHODS.has(method)) {
+        throw new Error("method");
+    }
+    if (value.body !== undefined &&
+        (typeof value.body !== "string" ||
+            Buffer.byteLength(value.body) > MAX_BODY_BYTES ||
+            method === "GET" ||
+            method === "HEAD")) {
+        throw new Error("body");
+    }
+    const headers = parseHeaders(value.headers);
+    return {
+        ...(value.body === undefined ? {} : { body: value.body }),
+        ...(headers === undefined ? {} : { headers }),
+        idempotencyKey: value.idempotencyKey,
+        method,
+        url: validatePaymentTarget(url.toString(), options),
+    };
+}
+export async function readBoundedResponse(response) {
+    if (!response.body)
+        return { body: "", truncated: false };
+    const reader = response.body.getReader();
+    const chunks = [];
+    let length = 0;
+    let truncated = false;
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        const remaining = MAX_RESPONSE_BYTES - length;
+        if (value.byteLength > remaining) {
+            if (remaining > 0)
+                chunks.push(value.subarray(0, remaining));
+            length += Math.max(remaining, 0);
+            truncated = true;
+            await reader.cancel();
+            break;
+        }
+        chunks.push(value);
+        length += value.byteLength;
+    }
+    const bytes = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return { body: new TextDecoder().decode(bytes), truncated };
+}
+export function readResponseHeaders(response) {
+    const headers = {};
+    let count = 0;
+    for (const [name, value] of response.headers) {
+        if (count >= 64)
+            break;
+        headers[name] = value.slice(0, 4_096);
+        count += 1;
+    }
+    return headers;
+}

package/dist/fetch-wrapper.d.ts

@@ -0,0 +1,24 @@
+import type { readPaymentAuthorizationState } from "./payment-authorization-state.js";
+import type { PaymentProfile } from "./payment-profile.js";
+import { type PaymentTargetLookup } from "./payment-target-network.js";
+import { TabRemoteSigner } from "./remote-signer.js";
+interface LeashFetchOptions {
+    address: `0x${string}`;
+    allowDevelopmentLoopback?: boolean;
+    apiBaseUrl: string;
+    apiKey: string;
+    authorizationState?: typeof readPaymentAuthorizationState;
+    clientName?: string | (() => string);
+    fetch?: typeof globalThis.fetch;
+    idempotencyKey?: () => string | undefined;
+    nowSeconds?: () => number;
+    paymentProfile: PaymentProfile;
+    paymentStateDirectory?: string;
+    lookup?: PaymentTargetLookup;
+    signer?: TabRemoteSigner;
+}
+type FetchInput = Request | string | URL;
+export declare function createTabFetch(options: LeashFetchOptions): ((input: FetchInput, init?: RequestInit) => Promise<Response>) & {
+    close: () => Promise<void>;
+};
+export {};

package/dist/fetch-wrapper.js

@@ -0,0 +1,70 @@
+import { createDurablePaymentFetch } from "./durable-payment-fetch.js";
+import { currentPaymentOrigin, withPaymentOrigin, withPaymentResourceUrl, } from "./origin-context.js";
+import { createLeashPaymentClient } from "./payment-client.js";
+import { defaultPaymentStateDirectory, PaymentEnvelopeStore } from "./payment-envelope-store.js";
+import { currentPaymentIdempotencyKey } from "./payment-idempotency.js";
+import { createPinnedPaymentFetch } from "./payment-target-network.js";
+import { safePaymentRequestInit, validatePaymentTarget } from "./payment-target-policy.js";
+import { TabRemoteSigner } from "./remote-signer.js";
+function requestUrl(input) {
+    return input instanceof Request ? input.url : input.toString();
+}
+function requestName(input, init) {
+    const method = init?.method ?? (input instanceof Request ? input.method : "GET");
+    const rawUrl = input instanceof Request ? input.url : input.toString();
+    let safeUrl = "Invalid URL";
+    try {
+        const url = new URL(rawUrl);
+        url.username = "";
+        url.password = "";
+        url.search = "";
+        url.hash = "";
+        safeUrl = url.toString();
+    }
+    catch {
+        // The underlying fetch reports invalid input without persisting the raw value as receipt origin.
+    }
+    return `${method.toUpperCase()} ${safeUrl}`;
+}
+export function createTabFetch(options) {
+    const baseFetch = options.fetch ?? globalThis.fetch;
+    const allowDevelopmentLoopback = options.allowDevelopmentLoopback === true;
+    const targetPolicy = createPinnedPaymentFetch({
+        allowDevelopmentLoopback,
+        fetch: baseFetch,
+        ...(options.lookup ? { lookup: options.lookup } : {}),
+    });
+    const signer = options.signer ??
+        new TabRemoteSigner({
+            address: options.address,
+            apiBaseUrl: options.apiBaseUrl,
+            apiKey: options.apiKey,
+            fetch: baseFetch,
+            origin: currentPaymentOrigin,
+            paymentProfile: options.paymentProfile,
+        });
+    const paidFetch = createDurablePaymentFetch({
+        address: options.address,
+        ...(options.authorizationState ? { authorizationState: options.authorizationState } : {}),
+        client: createLeashPaymentClient(signer, options.paymentProfile),
+        fetch: targetPolicy.fetch,
+        idempotencyKey: options.idempotencyKey ?? currentPaymentIdempotencyKey,
+        ...(options.nowSeconds ? { nowSeconds: options.nowSeconds } : {}),
+        paymentProfile: options.paymentProfile,
+        signer,
+        store: new PaymentEnvelopeStore(options.address, options.paymentStateDirectory ?? defaultPaymentStateDirectory()),
+    });
+    const leashFetch = (input, init) => {
+        validatePaymentTarget(requestUrl(input), {
+            allowDevelopmentLoopback,
+        });
+        return withPaymentOrigin({
+            clientName: typeof options.clientName === "function"
+                ? options.clientName()
+                : (options.clientName ?? "leash-fetch"),
+            toolName: requestName(input, init),
+            transport: "http",
+        }, () => withPaymentResourceUrl(requestUrl(input), () => paidFetch(input, safePaymentRequestInit(init))));
+    };
+    return Object.assign(leashFetch, { close: () => targetPolicy.close() });
+}

package/dist/fetch.d.ts

@@ -0,0 +1,3 @@
+export { createTabFetch } from "./fetch-wrapper.js";
+export type CreateTabFetchOptions = Parameters<typeof import("./fetch-wrapper.js").createTabFetch>[0];
+export type { PaymentProfile } from "./payment-profile.js";

package/dist/fetch.js

@@ -0,0 +1 @@
+export { createTabFetch } from "./fetch-wrapper.js";

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { createTabFetch } from "./fetch-wrapper.js";
+export type CreateTabFetchOptions = Parameters<typeof import("./fetch-wrapper.js").createTabFetch>[0];
+export { InvalidControlPlaneOriginError, validateControlPlaneOrigin, } from "./control-plane-origin.js";
+export type { PaymentProfile } from "./payment-profile.js";
+export { PaymentTargetPolicyError, validatePaymentTarget } from "./payment-target-policy.js";
+export { RemoteSignerError, TabRemoteSigner } from "./remote-signer.js";

package/dist/index.js

@@ -0,0 +1,4 @@
+export { createTabFetch } from "./fetch-wrapper.js";
+export { InvalidControlPlaneOriginError, validateControlPlaneOrigin, } from "./control-plane-origin.js";
+export { PaymentTargetPolicyError, validatePaymentTarget } from "./payment-target-policy.js";
+export { RemoteSignerError, TabRemoteSigner } from "./remote-signer.js";

package/dist/origin-context.d.ts

@@ -0,0 +1,5 @@
+import type { PaymentOrigin } from "./remote-signer.js";
+export declare function currentPaymentOrigin(): PaymentOrigin | undefined;
+export declare function withPaymentOrigin<T>(origin: PaymentOrigin, action: () => T): T;
+export declare function currentPaymentResourceUrl(): string | undefined;
+export declare function withPaymentResourceUrl<T>(resourceUrl: string, action: () => T): T;

package/dist/origin-context.js

@@ -0,0 +1,15 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+const paymentOrigin = new AsyncLocalStorage();
+const paymentResourceUrl = new AsyncLocalStorage();
+export function currentPaymentOrigin() {
+    return paymentOrigin.getStore();
+}
+export function withPaymentOrigin(origin, action) {
+    return paymentOrigin.run(origin, action);
+}
+export function currentPaymentResourceUrl() {
+    return paymentResourceUrl.getStore();
+}
+export function withPaymentResourceUrl(resourceUrl, action) {
+    return paymentResourceUrl.run(resourceUrl, action);
+}