@pushchain/core 6.0.27-alpha.3 → 6.0.27-alpha.4

package/src/lib/job-spec/constants.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MUTABILITIES = exports.LOGIC_KINDS = exports.OPERATIONS = exports.EVALUATIONS = exports.PRINCIPAL = exports.JOB_VOCABULARY = void 0;
+exports.JOB_VOCABULARY = Object.freeze({
+    EVALUATION: Object.freeze({
+        BOOLEAN: 'BOOLEAN',
+        COMPARE: 'COMPARE',
+        NUMBER: 'NUMBER',
+        PERCENTAGE: 'PERCENTAGE',
+    }),
+    OPERATION: Object.freeze({
+        EQUAL: 'EQUAL',
+        NOT_EQUAL: 'NOT_EQUAL',
+        GREATER_THAN: 'GREATER_THAN',
+        GREATER_OR_EQUAL: 'GREATER_OR_EQUAL',
+        LESS_THAN: 'LESS_THAN',
+        LESS_OR_EQUAL: 'LESS_OR_EQUAL',
+    }),
+    LOGIC: Object.freeze({
+        ALL: 'ALL',
+        ANY: 'ANY',
+        AT_LEAST: 'AT_LEAST',
+    }),
+    ALLOWED_MUTABILITY: Object.freeze({
+        NONE: 'NONE',
+        CLIENT: 'CLIENT',
+        PROVIDER: 'PROVIDER',
+        BOTH: 'BOTH',
+    }),
+});
+exports.PRINCIPAL = 'agentic:principal';
+exports.EVALUATIONS = Object.values(exports.JOB_VOCABULARY.EVALUATION);
+exports.OPERATIONS = Object.values(exports.JOB_VOCABULARY.OPERATION);
+exports.LOGIC_KINDS = Object.values(exports.JOB_VOCABULARY.LOGIC);
+exports.MUTABILITIES = Object.values(exports.JOB_VOCABULARY.ALLOWED_MUTABILITY);
+//# sourceMappingURL=constants.js.map

package/src/lib/job-spec/helpers.d.ts

@@ -0,0 +1,19 @@
+import { type Address, type Hex } from 'viem';
+import type { JobSpec, JobSpecTemplate } from './types';
+export declare function resolveJobSpec(template: JobSpecTemplate, ctx: {
+    principal: bigint;
+    params: bigint[];
+    accounts: Record<string, Address>;
+    origin: Hex;
+    executeBy: number;
+    settleWindow: number;
+}): JobSpec;
+export declare function describeJobSpec(spec: JobSpec | JobSpecTemplate, options?: {
+    principal?: bigint;
+    decimals?: Record<Address, number>;
+}): {
+    checks: string[];
+    logic: string;
+    timing: string;
+};
+export declare function specOrigin(marketplace: Address, cardId: bigint, version: bigint, principal: bigint): Hex;

package/src/lib/job-spec/helpers.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveJobSpec = resolveJobSpec;
+exports.describeJobSpec = describeJobSpec;
+exports.specOrigin = specOrigin;
+const viem_1 = require("viem");
+const codec_1 = require("./codec");
+const constants_1 = require("./constants");
+const errors_1 = require("../market/errors");
+const read_1 = require("./read");
+function resolveJobSpec(template, ctx) {
+    (0, codec_1.encodeJobSpec)(template);
+    if (ctx.params.length !== template.params.length ||
+        ctx.params.some((n, i) => (0, codec_1.int256)(n) < template.params[i].min || n > template.params[i].max))
+        throw new errors_1.JobSpecError('PARAM_OUT_OF_RANGE', 'The job parameters do not match the template bounds.');
+    const account = (read) => {
+        const r = template.reads[read];
+        const a = ctx.accounts[`${r.chainNamespace}:${r.chainId}`];
+        if (!a)
+            throw new errors_1.JobSpecError('UNFILLED_PLACEHOLDER', 'Resolve the wallet account on every read chain.');
+        return (0, viem_1.getAddress)(a);
+    };
+    const reads = template.reads.map((r, i) => {
+        let args = r.args;
+        for (const f of r.fills ?? []) {
+            const value = f.source === 'WALLET'
+                ? BigInt(account(i))
+                : BigInt.asUintN(256, ctx.params[f.param ?? 0]);
+            const at = 2 + f.word * 64;
+            args = (args.slice(0, at) +
+                (0, viem_1.toHex)(value, { size: 32 }).slice(2) +
+                args.slice(at + 64));
+        }
+        const read = { ...r };
+        delete read.fills;
+        const resolved = { ...read, args };
+        (0, read_1.inheritReadLabel)(r, resolved);
+        return resolved;
+    });
+    const checks = template.checks.map((c) => {
+        const t = c.target;
+        const target = typeof t === 'bigint'
+            ? t
+            : t === constants_1.PRINCIPAL
+                ? ctx.principal
+                : t === 'agentic:wallet'
+                    ? BigInt(account(c.read))
+                    : 'param' in t
+                        ? ctx.params[t.param]
+                        : (() => {
+                            const product = ctx.principal * t.principalBps;
+                            if (product >= BigInt(1) << BigInt(256))
+                                throw new errors_1.JobSpecError('TARGET_OVERFLOW', 'The principal-based target overflows uint256.');
+                            return product / BigInt(10000);
+                        })();
+        return { ...c, target: (0, codec_1.int256)(target) };
+    });
+    const spec = {
+        reads,
+        checks,
+        logic: template.logic,
+        allowedMutability: template.allowedMutability,
+        origin: ctx.origin,
+        executeBy: ctx.executeBy,
+        failFinalAt: ctx.executeBy + ctx.settleWindow,
+    };
+    (0, codec_1.encodeJobSpec)(spec);
+    return spec;
+}
+const words = {
+    EQUAL: 'equals',
+    NOT_EQUAL: 'does not equal',
+    GREATER_THAN: 'is greater than',
+    GREATER_OR_EQUAL: 'is at least',
+    LESS_THAN: 'is less than',
+    LESS_OR_EQUAL: 'is at most',
+};
+function describeJobSpec(spec, options) {
+    (0, codec_1.encodeJobSpec)(spec);
+    if (options?.principal !== undefined && (0, codec_1.int256)(options.principal) < BigInt(0))
+        throw new errors_1.JobSpecError('INVALID_DESCRIPTION_OPTIONS', 'Principal must be nonnegative.');
+    const decimals = new Map();
+    for (const [address, value] of Object.entries(options?.decimals ?? {})) {
+        if (!Number.isInteger(value) || value < 0 || value > 255)
+            throw new errors_1.JobSpecError('INVALID_DESCRIPTION_OPTIONS', 'Token decimals must be integers from 0 to 255.');
+        try {
+            decimals.set((0, viem_1.getAddress)(address).toLowerCase(), value);
+        }
+        catch (cause) {
+            throw new errors_1.JobSpecError('INVALID_DESCRIPTION_OPTIONS', 'Decimals must be keyed by token address.', undefined, cause);
+        }
+    }
+    function logic(t) {
+        return `${t.kind === 'ALL' ? 'All' : t.kind === 'ANY' ? 'Any' : `At least ${t.k}`} of (${t.of
+            .map((x) => (typeof x === 'number' ? `check ${x + 1}` : logic(x)))
+            .join(', ')})`;
+    }
+    return {
+        checks: spec.checks.map((c) => {
+            const r = spec.reads[c.read];
+            const t = c.target;
+            const resolvedTarget = typeof t === 'bigint'
+                ? t
+                : t === constants_1.PRINCIPAL
+                    ? options?.principal ?? 'principal'
+                    : t === 'agentic:wallet'
+                        ? 'the wallet on this chain'
+                        : 'param' in t
+                            ? `parameter ${t.param + 1}`
+                            : options?.principal !== undefined
+                                ? (options.principal * t.principalBps) / BigInt(10000)
+                                : `${t.principalBps} basis points of principal`;
+            const precision = decimals.get(r.target.toLowerCase());
+            const target = typeof resolvedTarget === 'bigint'
+                ? c.evaluation === 'PERCENTAGE'
+                    ? `${(0, viem_1.formatUnits)(resolvedTarget, 2)}% (${resolvedTarget} bps)`
+                    : precision !== undefined && c.evaluation !== 'BOOLEAN'
+                        ? `${(0, viem_1.formatUnits)(resolvedTarget, precision)} (${resolvedTarget} raw units; ${precision} decimals)`
+                        : `${resolvedTarget} (raw units)`
+                : `${resolvedTarget}${c.evaluation === 'PERCENTAGE' ? ' bps' : ' (raw units)'}`;
+            const name = (0, read_1.jobReadLabel)(r);
+            return `Read ${c.read + 1}: ${r.target} ${name ? name + ' ' : ''}${r.selector} on ${r.chainNamespace}:${r.chainId}, field [${r.field.join(',')}], ${c.evaluation} ${words[c.operation]} ${target}.`;
+        }),
+        logic: logic(spec.logic),
+        timing: 'executeBy' in spec
+            ? `Execute by ${new Date(spec.executeBy * 1000).toISOString()}; failure is final after ${new Date(spec.failFinalAt * 1000).toISOString()}.`
+            : '',
+    };
+}
+function specOrigin(marketplace, cardId, version, principal) {
+    // Imported here to keep the public helpers independent of client state.
+    return (0, viem_1.keccak256)(('0x' +
+        [
+            marketplace.slice(2).padStart(64, '0'),
+            ...[cardId, version, principal].map((n) => (0, viem_1.toHex)(n, { size: 32 }).slice(2)),
+        ].join('')));
+}
+//# sourceMappingURL=helpers.js.map

package/src/lib/job-spec/index.d.ts

@@ -0,0 +1,14 @@
+import { buildJobSpec, buildJobSpecTemplate, encodeJobSpec, decodeJobSpec } from './codec';
+import { describeJobSpec } from './helpers';
+import { prepareJobRead } from './read';
+import { previewJobSpec } from './preview';
+export declare const jobSpecUtils: Readonly<{
+    buildJobSpec: typeof buildJobSpec;
+    buildJobSpecTemplate: typeof buildJobSpecTemplate;
+    encodeJobSpec: typeof encodeJobSpec;
+    decodeJobSpec: typeof decodeJobSpec;
+    describeJobSpec: typeof describeJobSpec;
+    prepareRead: typeof prepareJobRead;
+    previewJobSpec: typeof previewJobSpec;
+}>;
+export type * from './types';

package/src/lib/job-spec/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jobSpecUtils = void 0;
+const codec_1 = require("./codec");
+const helpers_1 = require("./helpers");
+const read_1 = require("./read");
+const preview_1 = require("./preview");
+exports.jobSpecUtils = Object.freeze({
+    buildJobSpec: codec_1.buildJobSpec,
+    buildJobSpecTemplate: codec_1.buildJobSpecTemplate,
+    encodeJobSpec: codec_1.encodeJobSpec,
+    decodeJobSpec: codec_1.decodeJobSpec,
+    describeJobSpec: helpers_1.describeJobSpec,
+    prepareRead: read_1.prepareJobRead,
+    previewJobSpec: preview_1.previewJobSpec,
+});
+//# sourceMappingURL=index.js.map

package/src/lib/job-spec/preview.d.ts

@@ -0,0 +1,8 @@
+import { type Address, type Hex } from 'viem';
+import type { CHAIN } from '../constants/enums';
+import type { JobRead, JobSpec, JobSpecTemplate, JobSpecPreview, PreviewJobSpecOptions } from './types';
+/** @internal Bind the real client's configured CEA resolver without exposing its runtime. */
+export declare function bindJobPreviewAccounts(universal: object, resolve: (wallet: Address, chain: CHAIN) => Promise<Address>): void;
+/** Follow the deployed V2 type codes; uint values above int256.max cannot be compared. */
+export declare function decodeJobAnswer(read: JobRead, data: Hex): bigint;
+export declare function previewJobSpec(subject: JobSpec | JobSpecTemplate, options: PreviewJobSpecOptions): Promise<JobSpecPreview>;

package/src/lib/job-spec/preview.js

@@ -0,0 +1,298 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bindJobPreviewAccounts = bindJobPreviewAccounts;
+exports.decodeJobAnswer = decodeJobAnswer;
+exports.previewJobSpec = previewJobSpec;
+const viem_1 = require("viem");
+const read_state_types_1 = require("../read-state/read-state.types");
+const envelopes_1 = require("../read-state/envelopes");
+const errors_1 = require("../market/errors");
+const codec_1 = require("./codec");
+const helpers_1 = require("./helpers");
+const read_1 = require("./read");
+const constants_1 = require("./constants");
+const resolvers = new WeakMap();
+/** @internal Bind the real client's configured CEA resolver without exposing its runtime. */
+function bindJobPreviewAccounts(universal, resolve) {
+    resolvers.set(universal, resolve);
+}
+/** Follow the deployed V2 type codes; uint values above int256.max cannot be compared. */
+function decodeJobAnswer(read, data) {
+    const bytes = BigInt((data.length - 2) / 2);
+    const invalid = () => {
+        throw new errors_1.JobSpecError('INVALID_READ_RESULT', 'The consensus bytes do not contain the selected JobSpec field.');
+    };
+    const word = (at) => {
+        if (at < BigInt(0) || at + BigInt(32) > bytes)
+            return invalid();
+        return BigInt('0x' + data.slice(2 + Number(at) * 2, 66 + Number(at) * 2));
+    };
+    const dynamic = (n) => [6, 7, 9].includes(n.code) || n.children.some(dynamic);
+    const head = (n) => dynamic(n)
+        ? BigInt(1)
+        : n.code === 8
+            ? n.children.reduce((sum, c) => sum + head(c), BigInt(0))
+            : n.code === 10
+                ? BigInt(n.size ?? 0) * head(n.children[0])
+                : BigInt(1);
+    let node = (0, read_1.parseOutputs)(read.outputs);
+    let base = BigInt(0);
+    for (const index of read.field) {
+        let child;
+        let start = base;
+        let slot;
+        if (node.code === 8) {
+            child = node.children[index];
+            if (!child)
+                return invalid();
+            slot =
+                base +
+                    BigInt(32) *
+                        node.children
+                            .slice(0, index)
+                            .reduce((sum, c) => sum + head(c), BigInt(0));
+        }
+        else if (node.code === 9 || node.code === 10) {
+            if (BigInt(index) >= (node.code === 9 ? word(base) : BigInt(node.size ?? 0)))
+                return invalid();
+            child = node.children[0];
+            start += node.code === 9 ? BigInt(32) : BigInt(0);
+            slot = start + BigInt(32) * BigInt(index) * head(child);
+        }
+        else
+            return invalid();
+        base = dynamic(child) ? start + word(slot) : slot;
+        if (base > bytes)
+            return invalid();
+        node = child;
+    }
+    const value = word(base);
+    if (node.code === 6 || node.code === 7) {
+        if (base + BigInt(32) + value > bytes)
+            return invalid();
+        return BigInt.asIntN(256, BigInt((0, viem_1.keccak256)(('0x' +
+            data.slice(2 + Number(base + BigInt(32)) * 2, 2 + Number(base + BigInt(32) + value) * 2)))));
+    }
+    if (node.code === 9)
+        return BigInt.asIntN(256, value);
+    if ((node.code === 1 && value >= BigInt(1) << BigInt(255)) ||
+        (node.code === 3 && value > BigInt(1)) ||
+        (node.code === 4 && value >= BigInt(1) << BigInt(160)))
+        return invalid();
+    return BigInt.asIntN(256, value);
+}
+function compare(value, op, target) {
+    switch (op) {
+        case 'EQUAL':
+            return value === target;
+        case 'NOT_EQUAL':
+            return value !== target;
+        case 'GREATER_THAN':
+            return value > target;
+        case 'GREATER_OR_EQUAL':
+            return value >= target;
+        case 'LESS_THAN':
+            return value < target;
+        case 'LESS_OR_EQUAL':
+            return value <= target;
+    }
+}
+function combine(tree, checks) {
+    const results = tree.of.map((x) => typeof x === 'number' ? checks[x].pass : combine(x, checks));
+    const yes = results.filter((v) => v === true).length;
+    const unknown = results.filter((v) => v === null).length;
+    const required = tree.kind === 'ALL'
+        ? results.length
+        : tree.kind === 'ANY'
+            ? 1
+            : tree.k ?? 0;
+    return yes >= required ? true : yes + unknown < required ? false : null;
+}
+async function previewJobSpec(subject, options) {
+    // Validate and copy before asynchronous work; later caller mutations must not change paid criteria.
+    const input = (0, codec_1.decodeJobSpec)((0, codec_1.encodeJobSpec)(subject), {
+        format: 'params' in subject ? 'template' : 'spec',
+    });
+    options = {
+        ...options,
+        params: options.params && [...options.params],
+        baseline: options.baseline && [...options.baseline],
+        accounts: { ...options.accounts },
+        resume: options.resume && [...options.resume],
+    };
+    if (options.maxTotalFee !== undefined &&
+        (typeof options.maxTotalFee !== 'bigint' || options.maxTotalFee < BigInt(0)))
+        throw new errors_1.JobSpecError('INVALID_AMOUNT', 'maxTotalFee must be a nonnegative bigint.');
+    if (options.baseline) {
+        if (options.baseline.length !== input.reads.length)
+            throw new errors_1.JobSpecError('INVALID_BASELINE', 'Provide one baseline entry per read; use null for unknown entries.');
+        options.baseline.forEach((value) => {
+            if (value !== null)
+                (0, codec_1.int256)(value);
+        });
+    }
+    let spec;
+    if ('params' in input) {
+        if (input.checks.some((c) => c.target === constants_1.PRINCIPAL ||
+            (typeof c.target === 'object' && 'principalBps' in c.target)) &&
+            options.principal === undefined)
+            throw new errors_1.JobSpecError('UNFILLED_PLACEHOLDER', 'Supply principal to resolve principal-based preview targets.');
+        const accounts = { ...options.accounts };
+        const resolve = resolvers.get(options.client.universal);
+        for (const [index, read] of input.reads.entries()) {
+            const chain = `${read.chainNamespace}:${read.chainId}`;
+            const needed = read.fills?.some((f) => f.source === 'WALLET') ||
+                input.checks.some((c) => c.read === index && c.target === 'agentic:wallet');
+            if (needed && !accounts[chain] && options.wallet && resolve)
+                accounts[chain] = await resolve((0, viem_1.getAddress)(options.wallet), chain);
+        }
+        spec = (0, helpers_1.resolveJobSpec)(input, {
+            principal: options.principal ?? BigInt(0),
+            params: options.params ?? [],
+            accounts,
+            origin: viem_1.zeroHash,
+            executeBy: 0,
+            settleWindow: 1,
+        });
+    }
+    else
+        spec = input;
+    const waitOptions = {
+        timeoutMs: options.advanced?.timeout,
+        pollingIntervalMs: options.advanced?.pollingIntervalMs,
+        resultShape: { kind: 'raw' },
+    };
+    let responses;
+    let quoted = BigInt(0);
+    let newlyPaid = BigInt(0);
+    if (options.resume) {
+        if (options.resume.length !== spec.reads.length ||
+            options.resume.some((id) => !/^0x[\da-f]{64}$/i.test(id)) ||
+            new Set(options.resume.map((x) => x.toLowerCase())).size !==
+                options.resume.length)
+            throw new errors_1.JobSpecError('INVALID_PREVIEW_RESUME', 'Provide one distinct request ID per read, in read order.');
+        responses = [];
+        for (const [i, id] of options.resume.entries()) {
+            const response = await options.client.universal.trackRead({ requestId: id }, { resultShape: { kind: 'raw' }, progressHook: options.progressHook });
+            const read = spec.reads[i];
+            let matched = false;
+            try {
+                const actual = response.request.spec;
+                const envelope = (0, envelopes_1.decodeEvmQueryEnvelope)(actual.query);
+                const [target, calldata] = (0, viem_1.decodeAbiParameters)([{ type: 'address' }, { type: 'bytes' }], envelope.payload);
+                matched =
+                    response.requestId.toLowerCase() === id.toLowerCase() &&
+                        actual.account.chainNamespace === read.chainNamespace &&
+                        actual.account.chainId === read.chainId &&
+                        actual.minConfirmations >= read.minConfirmations &&
+                        envelope.queryType === 1 &&
+                        envelope.refType === 0 &&
+                        envelope.blockNumber === actual.blockNumber &&
+                        (0, viem_1.getAddress)(target) === (0, viem_1.getAddress)(read.target) &&
+                        calldata.toLowerCase() ===
+                            (read.selector + read.args.slice(2)).toLowerCase();
+            }
+            catch {
+                /* A request from another schema/query cannot stand in for this logical read. */
+            }
+            if (!matched)
+                throw new errors_1.JobSpecError('PREVIEW_REQUEST_MISMATCH', 'The recorded request does not match this resolved JobSpec read.', { read: i, requestId: id });
+            responses.push(response);
+        }
+        quoted = responses.reduce((sum, response) => sum + response.fees.paid, BigInt(0));
+    }
+    else {
+        const prepared = [];
+        for (const read of spec.reads) {
+            const readOptions = {
+                chain: `${read.chainNamespace}:${read.chainId}`,
+                callData: (read.selector + read.args.slice(2)),
+                minConfirmations: read.minConfirmations,
+                expiryBlocks: options.expiryBlocks,
+                refundTo: options.refundTo,
+                callback: options.callback,
+            };
+            prepared.push(await options.client.universal.prepareRead(read.target, readOptions));
+        }
+        quoted = prepared.reduce((sum, read) => sum + read.value, BigInt(0));
+        if (options.maxTotalFee !== undefined && quoted > options.maxTotalFee)
+            throw new errors_1.JobSpecError('PREVIEW_FEE_EXCEEDED', 'The prepared read fees exceed maxTotalFee. No read was submitted.', { quoted, maxTotalFee: options.maxTotalFee });
+        let batch;
+        try {
+            batch = await options.client.universal.executeReads(prepared, {
+                progressHook: options.progressHook,
+                advanced: options.advanced,
+                waitForCompletion: false,
+            });
+        }
+        catch (cause) {
+            const error = cause;
+            throw new errors_1.JobSpecError('PREVIEW_INCOMPLETE', 'Read submission could not be confirmed. Track the recorded transactions before requesting more reads.', {
+                txHash: error?.txHash,
+                transactionHashes: error?.transactionHashes,
+                pendingTransactionHash: error?.pendingTransactionHash,
+            }, cause);
+        }
+        responses = batch.reads;
+        newlyPaid = quoted;
+    }
+    const requestIds = responses.map((r) => r.requestId);
+    try {
+        responses = await Promise.all(responses.map((r) => r.wait(waitOptions)));
+    }
+    catch (cause) {
+        throw new errors_1.JobSpecError('PREVIEW_INCOMPLETE', 'The paid reads are still recoverable. Resume with these request IDs instead of paying again.', { requestIds, txHashes: responses.map((r) => r.txHash) }, cause);
+    }
+    const reads = responses.map((response, i) => {
+        const value = response.raw?.resultData ?? null;
+        if (response.outcome !== read_state_types_1.READ_OUTCOME.SUCCESS || value === null)
+            return {
+                value,
+                decoded: null,
+                error: response.errorMsg || 'The paid read did not complete successfully.',
+                response,
+            };
+        try {
+            return {
+                value,
+                decoded: decodeJobAnswer(spec.reads[i], value),
+                response,
+            };
+        }
+        catch (e) {
+            return { value, decoded: null, error: e.message, response };
+        }
+    });
+    const checks = spec.checks.map((check) => {
+        let value = reads[check.read].decoded;
+        if (value === null)
+            return { pass: null, value, reason: 'READ_UNAVAILABLE' };
+        if (check.evaluation === 'NUMBER' || check.evaluation === 'PERCENTAGE') {
+            const before = options.baseline?.[check.read];
+            if (before === undefined || before === null)
+                return { pass: null, value: null, reason: 'BASELINE_REQUIRED' };
+            if (check.evaluation === 'PERCENTAGE' && before === BigInt(0))
+                return { pass: null, value: null, reason: 'ZERO_BASELINE' };
+            try {
+                value = (0, codec_1.int256)(value - before);
+                if (check.evaluation === 'PERCENTAGE')
+                    value = (0, codec_1.int256)(value * BigInt(10000)) / before;
+            }
+            catch {
+                return { pass: null, value: null, reason: 'ARITHMETIC_OVERFLOW' };
+            }
+        }
+        return { pass: compare(value, check.operation, check.target), value };
+    });
+    return {
+        reads,
+        checks,
+        pass: combine(spec.logic, checks),
+        fees: {
+            quoted,
+            paid: reads.reduce((sum, r) => sum + r.response.fees.paid, BigInt(0)),
+            newlyPaid,
+        },
+    };
+}
+//# sourceMappingURL=preview.js.map

package/src/lib/job-spec/read.d.ts

@@ -0,0 +1,20 @@
+import { type AbiParameter, type Hex } from 'viem';
+import type { PrepareJobReadOptions, PreparedJobRead, ExecuteJobReadOptions } from './types';
+import type { ReadOptions } from '../read-state/read-params';
+export declare function inheritReadLabel(source: PreparedJobRead, target: PreparedJobRead): void;
+export declare function jobReadLabel(read: PreparedJobRead): string | undefined;
+/** Same logical call as a JobSpec read, through the normal paid universal-read path. */
+export declare function jobReadOptions(read: PreparedJobRead, options?: ExecuteJobReadOptions): ReadOptions;
+export declare function outputTypes(params: readonly AbiParameter[]): Hex;
+/** Pure ABI preparation, independent of read fees, RPCs and the request preflight. */
+export declare function prepareJobRead(options: PrepareJobReadOptions): PreparedJobRead;
+export interface OutputNode {
+    code: number;
+    children: OutputNode[];
+    size?: number;
+}
+export declare function parseOutputs(outputs: Hex): OutputNode;
+export declare function validateJobRead(r: PreparedJobRead & {
+    field?: number[];
+    minConfirmations?: number;
+}): void;