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

package/src/lib/job/types.d.ts

@@ -0,0 +1,94 @@
+import type { Address, Hex } from 'viem';
+import type { UniversalTxResponse } from '../orchestrator/orchestrator.types';
+import type { JobSpec } from '../job-spec/types';
+import type { StackProgressHook } from '../market/runtime';
+export type JobStatus = 'Open' | 'Funded' | 'Submitted' | 'Completed' | 'Rejected' | 'Expired';
+export interface CreateJobOptions {
+    provider: Address;
+    evaluator: Address;
+    hook: Address;
+    expiredAt: number;
+    paymentToken: Address;
+    jobSpec?: Hex;
+    description?: string;
+    progressHook?: StackProgressHook;
+}
+export interface Job {
+    jobId: bigint;
+    client: Address;
+    provider: Address;
+    evaluator: Address;
+    hook: Address;
+    status: JobStatus;
+    expiredAt: number;
+    budget: bigint;
+    paymentToken: Address;
+    /** Raw Solidity string bytes, which may contain a binary JobSpec rather than UTF-8. */
+    description: Hex;
+    deliverable?: Hex;
+    rulesId?: Hex;
+    jobSpec?: {
+        spec: JobSpec;
+        bytes: Hex;
+        /** Unavailable without a compatible evaluator. */ frozen?: boolean;
+    };
+    jobSpecDecodeError?: string;
+    evaluation: {
+        available: false;
+        reason: 'MANUAL_EVALUATOR' | 'UNVERIFIED_EVALUATOR';
+    };
+}
+export interface JobWriteOptions {
+    progressHook?: StackProgressHook;
+}
+export interface FundJobOptions extends JobWriteOptions {
+    rulesId?: Hex;
+    /** The price the client reviewed. Required for plain jobs or an updated card version. */
+    expectedBudget?: bigint;
+}
+export interface JobEvent {
+    jobId: bigint;
+    kind: string;
+    txHash?: Hex;
+    blockNumber?: bigint;
+    data?: unknown;
+    error?: unknown;
+    cursor?: JobWatchCursor;
+}
+/** Last delivered log; resume includes its block and excludes this log and earlier logs. */
+export interface JobWatchCursor {
+    blockNumber: bigint;
+    logIndex: number;
+    blockHash?: Hex;
+}
+export interface JobWatchOptions {
+    fromBlock?: bigint;
+    cursor?: JobWatchCursor;
+    pollIntervalMs?: number;
+}
+export interface JobNamespace {
+    create(options: CreateJobOptions): Promise<{
+        jobId: bigint;
+        tx: UniversalTxResponse;
+    }>;
+    setBudget(jobId: bigint, amount: bigint, options?: JobWriteOptions & {
+        jobSpec?: Hex;
+    }): Promise<UniversalTxResponse>;
+    fund(jobId: bigint, options?: FundJobOptions): Promise<UniversalTxResponse>;
+    submit(jobId: bigint, options: JobWriteOptions & {
+        deliverable: Hex | string;
+    }): Promise<UniversalTxResponse>;
+    cancel(jobId: bigint, options?: JobWriteOptions): Promise<UniversalTxResponse>;
+    claimRefund(jobId: bigint, options?: JobWriteOptions): Promise<UniversalTxResponse>;
+    verify(jobId: bigint, options?: JobWriteOptions): Promise<never>;
+    status(jobId: bigint): Promise<Job>;
+    list(options?: {
+        client?: Address;
+        provider?: Address;
+        status?: JobStatus;
+        fromJobId?: bigint;
+    }): Promise<{
+        jobs: Job[];
+    }>;
+    watch(jobId: bigint, callback: (event: JobEvent) => void, options?: JobWatchOptions): () => void;
+}

package/src/lib/job/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/src/lib/job/watch.d.ts

@@ -0,0 +1,3 @@
+import { type StackRuntime } from '../market/runtime';
+import type { JobEvent, JobWatchOptions } from './types';
+export declare function watchJob(rt: StackRuntime, jobId: bigint, callback: (event: JobEvent) => void, options: JobWatchOptions): () => void;

package/src/lib/job/watch.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchJob = watchJob;
+const viem_1 = require("viem");
+const AgenticCommerce_1 = require("../market/contracts/AgenticCommerce");
+const runtime_1 = require("../market/runtime");
+const errors_1 = require("../market/errors");
+const data_1 = require("../market/data");
+const names = [
+    'JobCreated',
+    'BudgetSet',
+    'JobFunded',
+    'JobSubmitted',
+    'JobCompleted',
+    'JobRejected',
+    'JobExpired',
+    'Refunded',
+];
+const kinds = [
+    'Created',
+    'BudgetSet',
+    'Funded',
+    'Submitted',
+    'Completed',
+    'Rejected',
+    'Expired',
+    'Refunded',
+];
+function watchJob(rt, jobId, callback, options) {
+    const d = (0, runtime_1.deployment)(rt);
+    let stopped = false;
+    let timer;
+    let cursor = options.cursor && { ...options.cursor };
+    let next = cursor?.blockNumber ?? options.fromBlock;
+    const interval = options.pollIntervalMs ?? 3000;
+    if (!Number.isSafeInteger(interval) ||
+        interval < 25 ||
+        (next !== undefined && (typeof next !== 'bigint' || next < BigInt(0))) ||
+        (cursor &&
+            (!Number.isSafeInteger(cursor.logIndex) ||
+                cursor.logIndex < 0 ||
+                (cursor.blockHash && !/^0x[\da-f]{64}$/i.test(cursor.blockHash)))) ||
+        (cursor && options.fromBlock !== undefined))
+        throw new errors_1.JobError('INVALID_WATCH_OPTIONS', 'Use a nonnegative block or a delivered-log cursor, and a polling interval of at least 25ms.');
+    const notify = (event) => {
+        try {
+            callback(event);
+        }
+        catch (error) {
+            if (event.kind !== 'Error' && !stopped) {
+                try {
+                    callback({
+                        jobId,
+                        kind: 'Error',
+                        error,
+                        cursor: cursor && { ...cursor },
+                    });
+                }
+                catch {
+                    /* A consumer exception must not rewind delivery or reject an unobserved promise. */
+                }
+            }
+        }
+    };
+    const poll = async () => {
+        try {
+            const head = await rt.agw.reader.getBlockNumber();
+            if (stopped)
+                return;
+            if (cursor) {
+                if (head < cursor.blockNumber)
+                    throw new errors_1.JobError('WATCH_REORG', 'The delivered cursor is ahead of the canonical head. Reload status before continuing.');
+                const block = rt.agw.reader.getBlock &&
+                    (await rt.agw.reader.getBlock({ blockNumber: cursor.blockNumber }));
+                if (head < cursor.blockNumber ||
+                    (cursor.blockHash &&
+                        block?.hash &&
+                        cursor.blockHash.toLowerCase() !== block.hash.toLowerCase()))
+                    throw new errors_1.JobError('WATCH_REORG', 'The delivered cursor is no longer canonical. Reload job status and restart from a reviewed block.');
+            }
+            if (next === undefined)
+                next = head;
+            const end = next + BigInt(999) < head ? next + BigInt(999) : head;
+            if (next <= end) {
+                const start = next;
+                const groups = await Promise.all(names.map((name) => rt.agw.reader.getLogs({
+                    address: d.kernel,
+                    event: (0, viem_1.getAbiItem)({ abi: AgenticCommerce_1.JOB_KERNEL_ABI, name }),
+                    args: { jobId },
+                    fromBlock: start,
+                    toBlock: end,
+                })));
+                if (stopped)
+                    return;
+                const unique = new Map();
+                for (const log of groups.flat()) {
+                    if (log.removed)
+                        throw new errors_1.JobError('WATCH_REORG', 'The RPC returned a removed job log. Reload status before continuing.');
+                    if ((0, viem_1.getAddress)(log.address) !== (0, viem_1.getAddress)(d.kernel) ||
+                        log.blockNumber === null ||
+                        log.logIndex === null ||
+                        log.blockNumber < start ||
+                        log.blockNumber > end)
+                        throw new errors_1.JobError('INCONSISTENT_READ', 'The RPC returned an unmined or out-of-range job log.');
+                    const event = (0, viem_1.decodeEventLog)({
+                        abi: AgenticCommerce_1.JOB_KERNEL_ABI,
+                        data: log.data,
+                        topics: log.topics,
+                        strict: true,
+                    });
+                    if (event.args.jobId !== jobId ||
+                        !names.includes(event.eventName))
+                        throw new errors_1.JobError('INCONSISTENT_READ', 'The RPC returned a different job or unsupported event.');
+                    const key = `${log.blockNumber}:${log.logIndex}`;
+                    const previous = unique.get(key);
+                    if (previous && (0, data_1.fingerprint)(previous.log) !== (0, data_1.fingerprint)(log))
+                        throw new errors_1.JobError('INCONSISTENT_READ', 'Two different logs occupy the same job cursor.');
+                    unique.set(key, { log, event });
+                }
+                const ordered = [...unique.values()].sort((a, b) => Number(a.log.blockNumber - b.log.blockNumber) || a.log.logIndex - b.log.logIndex);
+                for (const { log, event } of ordered) {
+                    if (stopped)
+                        return;
+                    const blockNumber = log.blockNumber;
+                    const logIndex = log.logIndex;
+                    if (cursor &&
+                        (blockNumber < cursor.blockNumber ||
+                            (blockNumber === cursor.blockNumber &&
+                                logIndex <= cursor.logIndex)))
+                        continue;
+                    cursor = {
+                        blockNumber,
+                        logIndex,
+                        ...(log.blockHash ? { blockHash: log.blockHash } : {}),
+                    };
+                    notify({
+                        jobId,
+                        kind: kinds[names.indexOf(event.eventName)],
+                        txHash: log.transactionHash ?? undefined,
+                        blockNumber,
+                        data: event.args,
+                        cursor: { ...cursor },
+                    });
+                }
+                next = end + BigInt(1);
+            }
+        }
+        catch (error) {
+            if (stopped)
+                return;
+            if (error instanceof errors_1.JobError && error.code === 'WATCH_REORG')
+                stopped = true;
+            notify({ jobId, kind: 'Error', error, cursor: cursor && { ...cursor } });
+        }
+        finally {
+            if (!stopped)
+                timer = setTimeout(() => {
+                    void poll();
+                }, interval);
+        }
+    };
+    void poll();
+    return () => {
+        stopped = true;
+        if (timer)
+            clearTimeout(timer);
+    };
+}
+//# sourceMappingURL=watch.js.map

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

@@ -0,0 +1,18 @@
+import { type Hex } from 'viem';
+import type { BuildJobSpecOptions, BuildJobSpecTemplateOptions, JobSpec, JobSpecTemplate, LogicTree } from './types';
+interface LogicWire {
+    kind: number;
+    checks: readonly number[];
+    children: readonly number[];
+    k: number;
+}
+export declare function int256(value: bigint, what?: string): bigint;
+export declare function flattenLogic(tree: LogicTree, checkCount: number): LogicWire[];
+export declare function buildJobSpec(options: BuildJobSpecOptions): JobSpec;
+export declare function buildJobSpecTemplate(options: BuildJobSpecTemplateOptions): JobSpecTemplate;
+export declare function encodeJobSpec(spec: JobSpec | JobSpecTemplate): Hex;
+/** Known callers pass the format; inference requires one canonical validated decode. */
+export declare function decodeJobSpec(bytes: Hex, options?: {
+    format?: 'spec' | 'template';
+}): JobSpec | JobSpecTemplate;
+export {};

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

@@ -0,0 +1,348 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.int256 = int256;
+exports.flattenLogic = flattenLogic;
+exports.buildJobSpec = buildJobSpec;
+exports.buildJobSpecTemplate = buildJobSpecTemplate;
+exports.encodeJobSpec = encodeJobSpec;
+exports.decodeJobSpec = decodeJobSpec;
+const viem_1 = require("viem");
+const errors_1 = require("../market/errors");
+const constants_1 = require("./constants");
+const schema_1 = require("./schema");
+const read_1 = require("./read");
+const originalLogic = new WeakMap();
+const fail = (message, code = 'INVALID_JOB_SPEC') => {
+    throw new errors_1.JobSpecError(code, message);
+};
+const fingerprint = (x) => JSON.stringify(x, (_, v) => (typeof v === 'bigint' ? v.toString() : v));
+function int256(value, what = 'Target') {
+    if (typeof value !== 'bigint' ||
+        value < -(BigInt(1) << BigInt(255)) ||
+        value >= BigInt(1) << BigInt(255))
+        fail(`${what} must fit int256.`);
+    return value;
+}
+function count(values, max, what, min = 1) {
+    if (!Array.isArray(values) || values.length < min || values.length > max)
+        fail(`${what} must contain ${min}..${max} entries.`, `TOO_MANY_${what.toUpperCase()}`);
+}
+function timestamp(n) {
+    if (!Number.isSafeInteger(n) || n < 0)
+        fail('Timestamps must be nonnegative safe integers.');
+}
+function enumIndex(values, value, name) {
+    const i = values.indexOf(value);
+    if (i < 0)
+        fail(`Unknown ${name}.`);
+    return i;
+}
+function flattenLogic(tree, checkCount) {
+    const nodes = [];
+    const active = new Set();
+    function visit(t) {
+        if (!t || active.has(t) || nodes.length >= 32)
+            fail('Logic is cyclic or exceeds 32 operators.', 'BAD_TREE');
+        active.add(t);
+        const index = nodes.length;
+        const kind = enumIndex(constants_1.LOGIC_KINDS, t.kind, 'logic kind');
+        if (!Array.isArray(t.of) || !t.of.length || t.of.length > 255)
+            fail('Logic operators need 1..255 operands.', 'BAD_TREE');
+        const k = t.kind === 'AT_LEAST' ? t.k ?? 0 : 0;
+        if (!Number.isInteger(k) ||
+            (t.kind === 'AT_LEAST' && (k < 1 || k > t.of.length)) ||
+            (t.kind !== 'AT_LEAST' && t.k !== undefined && t.k !== 0))
+            fail('Invalid AT_LEAST threshold.', 'BAD_TREE');
+        const n = { kind, checks: [], children: [], k: k };
+        nodes.push(n);
+        for (const item of t.of) {
+            if (typeof item === 'number') {
+                if (!Number.isInteger(item) ||
+                    item < 0 ||
+                    item >= checkCount ||
+                    n.checks.includes(item))
+                    fail('Dangling or duplicated check index.', 'BAD_TREE');
+                n.checks.push(item);
+            }
+            else
+                n.children.push(visit(item));
+        }
+        active.delete(t);
+        return index;
+    }
+    visit(tree);
+    const saved = originalLogic.get(tree);
+    return saved?.fingerprint === fingerprint(tree) ? saved.wire : nodes;
+}
+function nestLogic(nodes, checkCount) {
+    count(nodes, 32, 'logic');
+    const reached = new Set();
+    let expanded = 0;
+    function visit(index, depth) {
+        if (++expanded > 512 || depth > 32)
+            fail('Stored logic is too large to describe as a tree.', 'BAD_TREE');
+        const n = nodes[index];
+        if (!n || !constants_1.LOGIC_KINDS[n.kind])
+            fail('Unknown stored logic kind.', 'BAD_TREE');
+        reached.add(index);
+        if (n.checks.some((i) => !Number.isInteger(i) || i < 0 || i >= checkCount) ||
+            new Set(n.checks).size !== n.checks.length)
+            fail('Invalid stored check reference.', 'BAD_TREE');
+        if (n.children.some((i) => i <= index || i >= nodes.length) ||
+            new Set(n.children).size !== n.children.length)
+            fail('Invalid stored child reference.', 'BAD_TREE');
+        const t = {
+            kind: constants_1.LOGIC_KINDS[n.kind],
+            of: [...n.checks, ...n.children.map((i) => visit(i, depth + 1))],
+            ...(n.kind === 2 ? { k: n.k } : {}),
+        };
+        if (n.kind !== 2 && n.k !== 0)
+            fail('Unexpected threshold on stored logic.', 'BAD_TREE');
+        return t;
+    }
+    const tree = visit(0, 0);
+    if (reached.size !== nodes.length)
+        fail('Stored logic has unreachable operators.', 'BAD_TREE');
+    // Preserve an unchanged, valid topological order instead of rewriting signed bytes.
+    originalLogic.set(tree, { fingerprint: fingerprint(tree), wire: nodes });
+    flattenLogic(tree, checkCount);
+    return tree;
+}
+function normalizeReads(values) {
+    count(values, 16, 'reads');
+    return values.map((input) => {
+        const wrapper = input;
+        const source = 'read' in input ? wrapper.read : input;
+        const read = {
+            ...source,
+            field: [...(wrapper.field ?? [0])],
+            minConfirmations: wrapper.minConfirmations ?? 1,
+            ...(source.fills ? { fills: source.fills.map((f) => ({ ...f })) } : {}),
+        };
+        (0, read_1.inheritReadLabel)(source, read);
+        return read;
+    });
+}
+function validate(spec) {
+    count(spec.reads, 16, 'reads');
+    count(spec.checks, 16, 'checks');
+    enumIndex(constants_1.MUTABILITIES, spec.allowedMutability, 'allowedMutability');
+    const template = 'params' in spec;
+    if (template) {
+        count(spec.params, 16, 'params', 0);
+        for (const p of spec.params)
+            if (int256(p.min) > int256(p.max))
+                fail('Parameter minimum exceeds its maximum.');
+    }
+    else {
+        timestamp(spec.executeBy);
+        timestamp(spec.failFinalAt);
+        if (spec.failFinalAt <= spec.executeBy ||
+            !/^0x[\da-f]{64}$/i.test(spec.origin))
+            fail('Invalid JobSpec timing or origin.');
+    }
+    for (const r of spec.reads) {
+        (0, read_1.validateJobRead)(r);
+        if (!Number.isInteger(r.minConfirmations) ||
+            r.minConfirmations < 1 ||
+            r.minConfirmations > 65535)
+            fail('Read confirmations must be 1..65535.');
+        const words = new Set();
+        for (const f of r.fills ?? []) {
+            if (!template)
+                fail('A complete JobSpec cannot contain placeholders.', 'UNFILLED_PLACEHOLDER');
+            if (!Number.isInteger(f.word) ||
+                f.word < 0 ||
+                f.word > 255 ||
+                f.word * 32 + 32 > (r.args.length - 2) / 2 ||
+                words.has(f.word))
+                fail('Invalid or duplicate fill word.');
+            words.add(f.word);
+            if (!['WALLET', 'PARAM'].includes(f.source))
+                fail('Unknown fill source.');
+            if (f.source === 'PARAM' &&
+                (!Number.isInteger(f.param) ||
+                    (f.param ?? -1) < 0 ||
+                    (f.param ?? -1) >= spec.params.length))
+                fail('Fill parameter is out of range.');
+        }
+    }
+    for (const c of spec.checks) {
+        if (!Number.isInteger(c.read) || c.read < 0 || c.read >= spec.reads.length)
+            fail('Check read index is out of range.');
+        enumIndex(constants_1.EVALUATIONS, c.evaluation, 'evaluation');
+        enumIndex(constants_1.OPERATIONS, c.operation, 'operation');
+        if (c.evaluation === 'BOOLEAN' && c.operation !== 'EQUAL')
+            fail('BOOLEAN checks use EQUAL.');
+        if (typeof c.target === 'bigint')
+            int256(c.target);
+        else if (!template)
+            fail('Complete JobSpec targets must be resolved integers.', 'UNFILLED_PLACEHOLDER');
+        else
+            targetWire(c.target, spec.params.length);
+    }
+    flattenLogic(spec.logic, spec.checks.length);
+}
+function targetWire(target, params) {
+    if (typeof target === 'bigint')
+        return { source: 0, value: int256(target) };
+    if (target === constants_1.PRINCIPAL)
+        return { source: 1, value: BigInt(10000) };
+    if (target === 'agentic:wallet')
+        return { source: 3, value: BigInt(0) };
+    if (target && typeof target === 'object' && 'principalBps' in target) {
+        if (int256(target.principalBps) <= BigInt(0))
+            fail('principalBps must be positive.');
+        return { source: 1, value: target.principalBps };
+    }
+    if (target &&
+        typeof target === 'object' &&
+        'param' in target &&
+        Number.isInteger(target.param) &&
+        target.param >= 0 &&
+        target.param < params)
+        return { source: 2, value: BigInt(target.param) };
+    return fail('Unknown or out-of-range template target.');
+}
+function buildJobSpec(options) {
+    const spec = {
+        reads: normalizeReads(options.reads),
+        checks: options.checks.map((c) => ({ ...c })),
+        logic: typeof options.logic === 'string'
+            ? { kind: options.logic, of: options.checks.map((_, i) => i) }
+            : options.logic,
+        allowedMutability: options.allowedMutability ?? 'NONE',
+        origin: options.origin ?? viem_1.zeroHash,
+        executeBy: options.executeBy,
+        failFinalAt: options.failFinalAt,
+    };
+    validate(spec);
+    if (options.expiredAt !== undefined) {
+        timestamp(options.expiredAt);
+        if (options.failFinalAt >= options.expiredAt)
+            fail('failFinalAt must precede job expiry.', 'FAIL_WINDOW_THIN');
+    }
+    return spec;
+}
+function buildJobSpecTemplate(options) {
+    const t = {
+        reads: normalizeReads(options.reads),
+        checks: options.checks.map((c) => ({ ...c })),
+        logic: typeof options.logic === 'string'
+            ? { kind: options.logic, of: options.checks.map((_, i) => i) }
+            : options.logic,
+        allowedMutability: options.allowedMutability ?? 'NONE',
+        params: (options.params ?? []).map((p) => ({ ...p })),
+    };
+    validate(t);
+    return t;
+}
+function encodeJobSpec(spec) {
+    validate(spec);
+    const base = {
+        reads: spec.reads.map(({ fills, ...r }) => 'params' in spec
+            ? {
+                ...r,
+                fills: (fills ?? []).map((f) => ({
+                    word: f.word,
+                    source: f.source === 'WALLET' ? 0 : 1,
+                    param: f.param ?? 0,
+                })),
+            }
+            : r),
+        logic: flattenLogic(spec.logic, spec.checks.length),
+        allowedMutability: constants_1.MUTABILITIES.indexOf(spec.allowedMutability),
+    };
+    const checks = spec.checks.map((c) => ({
+        read: c.read,
+        evaluation: constants_1.EVALUATIONS.indexOf(c.evaluation),
+        operation: constants_1.OPERATIONS.indexOf(c.operation),
+        ...('params' in spec
+            ? targetWire(c.target, spec.params.length)
+            : { target: c.target }),
+    }));
+    const value = 'params' in spec
+        ? { ...base, checks, params: spec.params }
+        : {
+            ...base,
+            checks,
+            origin: spec.origin,
+            executeBy: BigInt(spec.executeBy),
+            failFinalAt: BigInt(spec.failFinalAt),
+        };
+    return (0, viem_1.encodeAbiParameters)([('params' in spec ? schema_1.JOB_TEMPLATE_PARAM : schema_1.JOB_SPEC_PARAM)], [value]);
+}
+/** Known callers pass the format; inference requires one canonical validated decode. */
+function decodeJobSpec(bytes, options) {
+    if (!(0, viem_1.isHex)(bytes) || bytes.length > 524290)
+        fail('Invalid or oversized JobSpec encoding.');
+    const valid = [];
+    for (const template of options?.format
+        ? [options.format === 'template']
+        : [false, true]) {
+        try {
+            const w = (0, viem_1.decodeAbiParameters)([(template ? schema_1.JOB_TEMPLATE_PARAM : schema_1.JOB_SPEC_PARAM)], bytes)[0];
+            const reads = w.reads.map(({ fills: rawFills, ...r }) => ({
+                ...r,
+                ...(template
+                    ? {
+                        fills: (rawFills ?? []).map((f) => {
+                            if (f.source > 1 || (f.source === 0 && f.param !== 0))
+                                fail('Invalid stored fill.');
+                            return {
+                                word: f.word,
+                                source: f.source === 0 ? 'WALLET' : 'PARAM',
+                                ...(f.source === 1 ? { param: f.param } : {}),
+                            };
+                        }),
+                    }
+                    : {}),
+            }));
+            const checks = w.checks.map((c) => {
+                const common = {
+                    read: c.read,
+                    evaluation: constants_1.EVALUATIONS[c.evaluation],
+                    operation: constants_1.OPERATIONS[c.operation],
+                };
+                if (!template)
+                    return { ...common, target: c.target };
+                const t = c;
+                const target = t.source === 0
+                    ? t.value
+                    : t.source === 1
+                        ? t.value === BigInt(10000)
+                            ? constants_1.PRINCIPAL
+                            : { principalBps: t.value }
+                        : t.source === 2
+                            ? { param: Number(t.value) }
+                            : t.source === 3 && t.value === BigInt(0)
+                                ? 'agentic:wallet'
+                                : fail('Unknown template target.');
+                return { ...common, target };
+            });
+            const common = {
+                reads,
+                checks,
+                logic: nestLogic(w.logic, checks.length),
+                allowedMutability: constants_1.MUTABILITIES[w.allowedMutability],
+            };
+            const spec = (template
+                ? { ...common, params: w.params }
+                : {
+                    ...common,
+                    origin: w.origin,
+                    executeBy: Number(w.executeBy),
+                    failFinalAt: Number(w.failFinalAt),
+                });
+            if (encodeJobSpec(spec).toLowerCase() === bytes.toLowerCase())
+                valid.push(spec);
+        }
+        catch {
+            /* Wrong shape, unsupported wire, malformed enums or noncanonical bytes. */
+        }
+    }
+    if (valid.length !== 1)
+        fail('The bytes do not identify one supported canonical deployed-v2 JobSpec format.', 'UNSUPPORTED_JOB_SPEC');
+    return valid[0];
+}
+//# sourceMappingURL=codec.js.map

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

@@ -0,0 +1,32 @@
+export declare const JOB_VOCABULARY: Readonly<{
+    EVALUATION: Readonly<{
+        readonly BOOLEAN: "BOOLEAN";
+        readonly COMPARE: "COMPARE";
+        readonly NUMBER: "NUMBER";
+        readonly PERCENTAGE: "PERCENTAGE";
+    }>;
+    OPERATION: Readonly<{
+        readonly EQUAL: "EQUAL";
+        readonly NOT_EQUAL: "NOT_EQUAL";
+        readonly GREATER_THAN: "GREATER_THAN";
+        readonly GREATER_OR_EQUAL: "GREATER_OR_EQUAL";
+        readonly LESS_THAN: "LESS_THAN";
+        readonly LESS_OR_EQUAL: "LESS_OR_EQUAL";
+    }>;
+    LOGIC: Readonly<{
+        readonly ALL: "ALL";
+        readonly ANY: "ANY";
+        readonly AT_LEAST: "AT_LEAST";
+    }>;
+    ALLOWED_MUTABILITY: Readonly<{
+        readonly NONE: "NONE";
+        readonly CLIENT: "CLIENT";
+        readonly PROVIDER: "PROVIDER";
+        readonly BOTH: "BOTH";
+    }>;
+}>;
+export declare const PRINCIPAL: "agentic:principal";
+export declare const EVALUATIONS: ("BOOLEAN" | "COMPARE" | "NUMBER" | "PERCENTAGE")[];
+export declare const OPERATIONS: ("EQUAL" | "NOT_EQUAL" | "GREATER_THAN" | "GREATER_OR_EQUAL" | "LESS_THAN" | "LESS_OR_EQUAL")[];
+export declare const LOGIC_KINDS: ("ALL" | "ANY" | "AT_LEAST")[];
+export declare const MUTABILITIES: ("NONE" | "CLIENT" | "PROVIDER" | "BOTH")[];