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

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

@@ -0,0 +1,180 @@
+import type { Address, Hex } from 'viem';
+import type { AgentCardRules } from './rules';
+import type { JobSpec, JobSpecTemplate } from '../job-spec/types';
+import type { SessionWire } from '../agentic/codec/session';
+import type { StackProgressHook } from './runtime';
+import type { UniversalTxResponse } from '../orchestrator/orchestrator.types';
+export interface AgentCardInput {
+    /** A name is hashed on write; reads retain the canonical bytes32 jobType. */
+    jobType: string;
+    metadataURI: string;
+    metadataHash: Hex;
+    chain: string;
+    providerFee: bigint;
+    paymentToken: Address;
+    principalMin: bigint;
+    principalMax: bigint;
+    minDuration: number;
+    maxDuration: number;
+    minExecuteWindow: number;
+    settleWindow: number;
+}
+export interface AgentCard extends AgentCardInput {
+    cardId: bigint;
+    provider: Address;
+    active: boolean;
+    version: bigint;
+    verified: boolean;
+    disabled: boolean;
+    rating: bigint;
+    rules: AgentCardRules;
+    jobSpecTemplate: JobSpecTemplate;
+    /** Canonical on-chain bytes retained for exact matching and unknown token metadata. */
+    rulesBytes: Hex;
+    jobSpecTemplateBytes: Hex;
+}
+export type AgentCardSummary = Omit<AgentCard, 'rules' | 'jobSpecTemplate' | 'rulesBytes' | 'jobSpecTemplateBytes'>;
+export interface MarketJobInputs {
+    principal: bigint;
+    expiredAt: number;
+    executeBy: number;
+    params: bigint[];
+}
+export interface OwnerIntent {
+    owner: Address;
+    wallet: Address;
+    executor: Address;
+    index: bigint;
+    sessionHash: Hex;
+    mode: Hex;
+    execCalldataHash: Hex;
+    nonceKey: bigint;
+    nonceSeq: bigint;
+    grantNonce: bigint;
+    deadline: number;
+    signerChainId: bigint;
+}
+export interface JobPlan {
+    cardId: bigint;
+    cardVersion: bigint;
+    wallet: Address;
+    walletDeployed: boolean;
+    session: SessionWire;
+    intent: OwnerIntent;
+    calldata: Hex;
+    jobSpec: {
+        spec: JobSpec;
+        bytes: Hex;
+    };
+    job: MarketJobInputs;
+    label: string;
+    /** Reference deposit amounts; no principal or fee is moved by openJob. */
+    deposit: {
+        principal: {
+            prc20: Address;
+            amount: bigint;
+        };
+        providerFee: {
+            token: Address;
+            amount: bigint;
+        };
+        pc: bigint;
+    };
+    preview: {
+        mayDo: string[];
+        mayMove: string[];
+        judgedBy: string[];
+        until: string;
+    };
+}
+export interface MarketPreviewOptions extends Omit<MarketJobInputs, 'params'> {
+    params?: bigint[];
+    walletIndex?: number;
+    deadline?: number;
+    label?: string;
+}
+export interface MarketWriteOptions {
+    progressHook?: StackProgressHook;
+}
+export interface MarketOpenOptions extends MarketWriteOptions {
+    relay?: boolean;
+    /** Recover a submitted opening, without signing or sending again. Rehydrate a hash with trackTransaction. */
+    resume?: UniversalTxResponse;
+}
+export interface MarketDepositStep {
+    /** PRINCIPAL_AND_FEE combines requirements when both use the same token. */
+    step: 'PRINCIPAL' | 'PROVIDER_FEE' | 'PRINCIPAL_AND_FEE' | 'PC';
+    token?: Address;
+    amount: bigint;
+    tx: UniversalTxResponse;
+}
+export interface MarketDepositOptions extends MarketWriteOptions {
+    /** Token transfers use Push holdings by default. Origin explicitly bridges matching registered assets; PC always uses Push holdings. */
+    funding?: 'push' | 'origin';
+    /** Wallet PC balance to reach. Defaults to the opened card's per-call gas cap. */
+    pcAmount?: bigint;
+    /** Wallet fee reserve to reach. Defaults to the opened card's reference fee; does not accept a kernel price. */
+    providerFee?: bigint;
+    /** Previously submitted steps. Their waits must settle before any further transfer. */
+    resume?: readonly MarketDepositStep[];
+}
+export interface MarketDepositResult {
+    jobId: bigint;
+    wallet: Address;
+    cardId: bigint;
+    cardVersion: bigint;
+    /** Includes resumed transactions, in submission order. */
+    txs: MarketDepositStep[];
+    /** A broadcast that failed before returning a response. Track it before resuming. */
+    pending?: Omit<MarketDepositStep, 'tx'> & {
+        txHash: string;
+        chain: string;
+    };
+}
+export interface MarketNamespace {
+    cards(options?: {
+        provider?: Address;
+        chain?: string;
+        active?: boolean;
+    }): Promise<{
+        cards: AgentCardSummary[];
+    }>;
+    card(cardId: bigint): Promise<AgentCard>;
+    preview(cardId: bigint, options: MarketPreviewOptions): Promise<JobPlan>;
+    openJob(plan: JobPlan, options?: MarketOpenOptions): Promise<{
+        jobId: bigint;
+        wallet: Address;
+        rulesId: Hex;
+        tx: UniversalTxResponse;
+    }>;
+    deposit(jobId: bigint, options?: MarketDepositOptions): Promise<MarketDepositResult>;
+    job(jobId: bigint): Promise<{
+        cardId: bigint;
+        cardVersion: bigint;
+        wallet: Address;
+        rulesId: Hex;
+    }>;
+    activeJob(wallet: Address): Promise<{
+        jobId: bigint;
+    }>;
+    agent: {
+        register(card: AgentCardInput, options: MarketWriteOptions & {
+            rules: AgentCardRules;
+            jobSpecTemplate: JobSpecTemplate;
+        }): Promise<{
+            cardId: bigint;
+            version: bigint;
+            tx: UniversalTxResponse;
+        }>;
+        update(cardId: bigint, card: AgentCardInput, options: MarketWriteOptions & {
+            rules: AgentCardRules;
+            jobSpecTemplate: JobSpecTemplate;
+        }): Promise<{
+            cardId: bigint;
+            version: bigint;
+            tx: UniversalTxResponse;
+        }>;
+        setActive(cardId: bigint, active: boolean, options?: MarketWriteOptions): Promise<UniversalTxResponse>;
+        card(): Promise<AgentCard | undefined>;
+    };
+}

package/src/lib/market/types.js

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

package/src/lib/orchestrator/internals/errors.d.ts

@@ -27,8 +27,10 @@ export interface DecodedErrorPayload {
  * discriminator lets callers classify via `instanceof PushChainExecutionError`
  * instead of sniffing error messages.
  *
- * Carries the origin-chain gateway tx hash. There is no successful Push Chain
- * tx to reference on this path — by definition the pcTx committed `FAILED`.
+ * A failed universal execution can carry its origin-chain gateway hash. Native
+ * confirmation/indexing errors retain the submitted Push hash instead; those
+ * errors do not prove that the transaction reverted. Track a retained hash
+ * before retrying an operation with side effects.
  *
  * `decodedError`: optional structured payload that flows through to terminal
  * failure hook payloads (199-02 / 299-02 / 399-02 / 999-02). Set by the
@@ -38,11 +40,16 @@ export interface DecodedErrorPayload {
 export declare class PushChainExecutionError extends Error {
     readonly code: "PUSH_CHAIN_EXECUTION_FAILED";
     readonly gatewayTxHash?: string;
+    /** Native Push transaction already broadcast before confirmation/indexing failed. */
+    readonly txHash?: `0x${string}`;
+    readonly pendingTransactionHash?: `0x${string}`;
     readonly decodedError?: DecodedErrorPayload;
     /** Underlying transport/RPC error, kept so raw revert data is not lost. */
     readonly cause?: unknown;
     constructor(message: string, opts?: {
         gatewayTxHash?: string;
+        txHash?: `0x${string}`;
+        pendingTransactionHash?: `0x${string}`;
         decodedError?: DecodedErrorPayload;
         cause?: unknown;
     });

package/src/lib/orchestrator/internals/errors.js

@@ -19,8 +19,10 @@ const formatters_1 = require("../../formatters");
  * discriminator lets callers classify via `instanceof PushChainExecutionError`
  * instead of sniffing error messages.
  *
- * Carries the origin-chain gateway tx hash. There is no successful Push Chain
- * tx to reference on this path — by definition the pcTx committed `FAILED`.
+ * A failed universal execution can carry its origin-chain gateway hash. Native
+ * confirmation/indexing errors retain the submitted Push hash instead; those
+ * errors do not prove that the transaction reverted. Track a retained hash
+ * before retrying an operation with side effects.
  *
  * `decodedError`: optional structured payload that flows through to terminal
  * failure hook payloads (199-02 / 299-02 / 399-02 / 999-02). Set by the
@@ -30,6 +32,9 @@ const formatters_1 = require("../../formatters");
 class PushChainExecutionError extends Error {
     code = 'PUSH_CHAIN_EXECUTION_FAILED';
     gatewayTxHash;
+    /** Native Push transaction already broadcast before confirmation/indexing failed. */
+    txHash;
+    pendingTransactionHash;
     decodedError;
     /** Underlying transport/RPC error, kept so raw revert data is not lost. */
     cause;
@@ -37,6 +42,8 @@ class PushChainExecutionError extends Error {
         super((0, formatters_1.normalizePublicErrorMessage)(message));
         this.name = 'PushChainExecutionError';
         this.gatewayTxHash = opts.gatewayTxHash;
+        this.txHash = opts.txHash;
+        this.pendingTransactionHash = opts.pendingTransactionHash;
         this.decodedError = opts.decodedError;
         if (opts.cause !== undefined)
             this.cause = opts.cause;

package/src/lib/orchestrator/internals/push-chain-tx.js

@@ -37,7 +37,7 @@ async function getIndexedPushTransaction(ctx, txHash, label) {
                 });
                 receiptWaited = true;
                 if (receipt.status === 'reverted') {
-                    throw new errors_1.PushChainExecutionError(`${label} — Push Chain transaction ${txHash} reverted`);
+                    throw new errors_1.PushChainExecutionError(`${label} — Push Chain transaction ${txHash} reverted`, { txHash });
                 }
             }
             return await ctx.pushClient.getTransaction(txHash);
@@ -92,6 +92,7 @@ async function sendPushTx(ctx, execute, eventBuffer, transformFn, requireAtomicB
             }
         }
         if (executor && ctx.universalSigner.signAuthorization) {
+            let submittedHash;
             try {
                 (0, context_1.printLog)(ctx, `sendPushTx — executing ${calls.length} call(s) atomically via EIP-7702 (executor: ${executor})`);
                 const txHash = await ctx.pushClient.sendBatch7702({
@@ -99,10 +100,16 @@ async function sendPushTx(ctx, execute, eventBuffer, transformFn, requireAtomicB
                     calls,
                     signer: ctx.universalSigner,
                 });
+                submittedHash = txHash;
                 const txResponse = await getIndexedPushTransaction(ctx, txHash, 'sendPushTx');
                 return await transformFn(txResponse, eventBuffer);
             }
             catch (err) {
+                if (submittedHash) {
+                    if (err instanceof errors_1.PushChainExecutionError && err.txHash === submittedHash)
+                        throw err;
+                    throw new errors_1.PushChainExecutionError((0, formatters_1.normalizePublicErrorMessage)(err), { txHash: submittedHash, pendingTransactionHash: submittedHash, cause: err });
+                }
                 // Only fall back when the wallet genuinely can't sign a 7702
                 // authorization. This is raised before any broadcast, so falling back
                 // to sequential execution cannot double-execute. Any other error
@@ -224,8 +231,15 @@ async function sendPushTx(ctx, execute, eventBuffer, transformFn, requireAtomicB
         value: execute.value,
         signer: ctx.universalSigner,
     });
-    const txResponse = await getIndexedPushTransaction(ctx, txHash, 'sendPushTx');
-    return await transformFn(txResponse, eventBuffer);
+    try {
+        const txResponse = await getIndexedPushTransaction(ctx, txHash, 'sendPushTx');
+        return await transformFn(txResponse, eventBuffer);
+    }
+    catch (cause) {
+        if (cause instanceof errors_1.PushChainExecutionError && cause.txHash === txHash)
+            throw cause;
+        throw new errors_1.PushChainExecutionError((0, formatters_1.normalizePublicErrorMessage)(cause), { txHash, pendingTransactionHash: txHash, cause });
+    }
 }
 // ============================================================================
 // sendUniversalTx

package/src/lib/push-chain/push-chain.d.ts

@@ -11,6 +11,10 @@ import type { Hex } from 'viem';
 import type { BatchReadResponse, PreparedRead, UniversalReadResponse } from '../read-state/read-state.types';
 import { type ReadOptions, type ReadPrepareOptions, type ReadValue, type ValidateReadCall, type ReadTrackOptions, type ReadExecuteOptions } from '../read-state/read-params';
 import type { AgenticNamespace } from '../agentic/agentic.types';
+import type { MarketNamespace } from '../market/types';
+import type { JobNamespace } from '../job/types';
+import { prepareJobRead } from '../job-spec/read';
+import type { ExecuteJobReadOptions, PreparedJobRead } from '../job-spec/types';
 /** Options accepted by `PushChain.initialize` / `reinitialize`. */
 export interface PushChainInitializeOptions {
     network: PUSH_NETWORK;
@@ -96,6 +100,41 @@ export declare class PushChain {
         };
         AGENTIC: Readonly<{
             WALLET: "agentic:wallet";
+            PRINCIPAL: "agentic:principal";
+            JOB: Readonly<{
+                ADDRESS: Readonly<{
+                    'eip155:42101': Readonly<{
+                        KERNEL: "0x977cf1AC973E9eC4332791d531507575006157Ed";
+                        HOOK: "0xDe7A94e510b6C571DE7880d441349689F73A32b3";
+                        EVALUATOR: "0x1afC81396f1bb36F91f74506284952b81e4bd47c";
+                    }>;
+                }>;
+                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";
+                }>;
+            }>;
             PRESETS: Readonly<{
                 CATEGORY: Readonly<{
                     DEXES: "DEXES";
@@ -202,7 +241,9 @@ export declare class PushChain {
          * Defaults to the canonical registry on Donut. For your own application receiver,
          * pass callback.target, gasLimit, abi and functionName, plus an optional args mapper.
          */
-        read: <const O extends ReadOptions>(subject: string, options: O & ValidateReadCall<O>) => Promise<UniversalReadResponse<ReadValue<O>>>;
+        read: (<const O extends ReadOptions>(subject: string, options: O & ValidateReadCall<O>) => Promise<UniversalReadResponse<ReadValue<O>>>) & ((read: PreparedJobRead, options?: ExecuteJobReadOptions) => Promise<UniversalReadResponse<`0x${string}`>>) & {
+            prepare: typeof prepareJobRead;
+        };
         /**
          * Build a validated `ReadSpec` for `subject` on `options.chain`: preflight (oracle
          * height, protocol fee, gas price), envelope encoding, budget sizing, expiry math.
@@ -297,6 +338,8 @@ export declare class PushChain {
      * handles. Ownership is the connected signer's Push identity.
      */
     agentic: AgenticNamespace;
+    market: MarketNamespace;
+    job: JobNamespace;
     /** @internal AGW execution context when initialized with `agenticWallet`. */
     private agenticContext?;
     private readonly agenticRuntime;

package/src/lib/push-chain/push-chain.js

@@ -19,6 +19,10 @@ const send_1 = require("../agentic/execution/send");
 const guards_1 = require("../agentic/execution/guards");
 const response_1 = require("../agentic/response");
 const runtime_1 = require("../agentic/runtime");
+const market_1 = require("../market/market");
+const job_1 = require("../job/job");
+const preview_1 = require("../job-spec/preview");
+const read_1 = require("../job-spec/read");
 /**
  * @class PushChain
  *
@@ -63,6 +67,8 @@ class PushChain {
      * handles. Ownership is the connected signer's Push identity.
      */
     agentic;
+    market;
+    job;
     /** @internal AGW execution context when initialized with `agenticWallet`. */
     agenticContext;
     agenticRuntime;
@@ -97,6 +103,17 @@ class PushChain {
         this.accountStatusReady = Promise.resolve();
         this.agenticRuntime = (0, runtime_1.createAgenticRuntime)(orchestrator, isReadMode);
         this.agentic = new agentic_1.AgenticNamespaceImpl(this.agenticRuntime);
+        const stackRuntime = {
+            agw: this.agenticRuntime,
+            jobBlocks: new Map(),
+            account: () => this.universal.account,
+            wallet: () => this.agenticContext?.wallet,
+            send: (params, options) => this.universal.sendTransaction(params, options),
+            signTypedData: (data) => this.universal.signTypedData(data),
+            canSignTypedData: () => typeof this.universalSigner.signTypedData === 'function',
+        };
+        this.market = new market_1.MarketNamespaceImpl(stackRuntime);
+        this.job = new job_1.JobNamespaceImpl(stackRuntime);
         // eslint-disable-next-line @typescript-eslint/no-this-alias -- getters below need the instance
         const self = this;
         // In agenticWallet mode, request transactions execute through the wallet
@@ -167,15 +184,17 @@ class PushChain {
                 return orchestrator.rescueFunds.bind(orchestrator)(params);
             },
             // Only read()/executeReads() send transactions; prepare/simulate/track remain read-only.
-            read: async (subject, options) => {
-                const params = await (0, read_params_1.resolveReadSpecParams)(subject, withReadRefund(options), orchestrator.getNetwork(), orchestrator.getRpcUrls());
+            read: Object.assign(async (subject, input) => {
+                const options = typeof subject === 'string' ? input : (0, read_1.jobReadOptions)(subject, input);
+                const target = typeof subject === 'string' ? subject : subject.target;
+                const params = await (0, read_params_1.resolveReadSpecParams)(target, withReadRefund(options), orchestrator.getNetwork(), orchestrator.getRpcUrls());
                 (0, read_executor_1.assertRequestEntrypoint)(params.callback, 'read');
                 if (this.isReadMode)
                     throw new Error('Read only mode cannot call read function');
                 const prepared = await orchestrator.prepareRead(params, options.progressHook);
                 const { reads: [response] } = await (0, read_executor_1.executeReads)(readDeps(), [prepared], options);
                 return response;
-            },
+            }, { prepare: read_1.prepareJobRead }),
             prepareRead: async (subject, options) => {
                 const params = await (0, read_params_1.resolveReadSpecParams)(subject, withReadRefund(options), orchestrator.getNetwork(), orchestrator.getRpcUrls());
                 return orchestrator.prepareRead(params);
@@ -214,6 +233,7 @@ class PushChain {
                 return (0, viem_1.bytesToHex)(signBytes);
             },
         };
+        (0, preview_1.bindJobPreviewAccounts)(this.universal, async (wallet, chain) => (await this.agenticRuntime.resolveCEA(wallet, chain)).cea);
         const network = orchestrator.getNetwork() === enums_1.PUSH_NETWORK.MAINNET
             ? 'mainnet'
             : 'testnet';

package/src/lib/read-state/read-params.d.ts

@@ -44,6 +44,8 @@ interface ReadOptionsInput {
     idl?: Idl;
     /** Typed contract call — encodes the call and decodes the result. */
     abi?: Abi;
+    /** Encoded EVM view call. The result is returned as raw consensus bytes. */
+    callData?: Hex;
     /**
      * With `abi`: the function to call (required). With `idl`: the account layout
      * (optional — inferred from the discriminator; snake_case or camelCase).
@@ -79,6 +81,7 @@ type NoQuery = {
     idl?: never;
     accountName?: never;
     abi?: never;
+    callData?: never;
     functionName?: never;
     args?: never;
     storageSlot?: never;
@@ -113,6 +116,10 @@ export type ReadQueryOptions = ({
     args?: readonly unknown[];
 }>) | ({
     chain: EvmChain;
+} & Query<'callData', {
+    callData: Hex;
+}>) | ({
+    chain: EvmChain;
 } & Query<'storageSlot', {
     storageSlot: Hex | bigint;
 }>) | ({
@@ -191,6 +198,8 @@ export type ReadValue<O> = O extends {
     readonly [K in keyof E]: Web2Value<E[K]>;
 } : O extends {
     storageSlot: unknown;
+} | {
+    callData: unknown;
 } ? Hex : O extends {
     idl: infer I extends Idl;
 } ? IdlReadValue<I, O extends {

package/src/lib/read-state/read-params.js

@@ -27,7 +27,7 @@ exports.ERC20_BALANCE_OF_ABI = [
         outputs: [{ name: '', type: 'uint256' }],
     },
 ];
-const QUERY_KEYS = ['token', 'abi', 'idl', 'storageSlot', 'web2'];
+const QUERY_KEYS = ['token', 'abi', 'callData', 'idl', 'storageSlot', 'web2'];
 function queryKind(o) {
     if ('tokenProgram' in o)
         throw new errors_1.InvalidReadQueryError('tokenProgram is detected from the mint; remove options.tokenProgram');
@@ -75,6 +75,10 @@ function toReadQuery(subject, o, resolvedTokenProgram) {
                 if (!o.functionName)
                     throw new errors_1.InvalidReadQueryError('abi needs functionName');
                 return { type: 'contractCall', target: subject, abi: o.abi, functionName: o.functionName, args: o.args };
+            case 'callData':
+                if (!/^0x(?:[\da-f]{2}){4,}$/i.test(o.callData ?? ''))
+                    throw new errors_1.InvalidReadQueryError('callData must contain a function selector and complete bytes');
+                return { type: 'contractCall', target: subject, callData: o.callData };
             case 'storageSlot':
                 return { type: 'storageSlot', target: subject, slot: o.storageSlot };
             default:

package/src/lib/utils.d.ts

@@ -1,3 +1,4 @@
+import { validateAgentCardRules, encodeAgentCardRules, decodeAgentCardRules } from './market/rules';
 import { convertOriginToExecutor, fromChainAgnostic, convertExecutorToOriginAccount, toChainAgnostic, toUniversal, deriveExecutorAccount, resolveControllerAccount } from './universal/account';
 import { construct, toUniversal as toUniversalSigner, toUniversalFromKeypair } from './universal/signer';
 import { CHAIN, PUSH_NETWORK } from './constants/enums';
@@ -323,6 +324,20 @@ export declare class Utils {
     static readonly agentic: Readonly<{
         presets: import("./agentic").AgenticPresets;
     }>;
+    static readonly job: Readonly<{
+        buildJobSpec: typeof import("./job-spec/codec").buildJobSpec;
+        buildJobSpecTemplate: typeof import("./job-spec/codec").buildJobSpecTemplate;
+        encodeJobSpec: typeof import("./job-spec/codec").encodeJobSpec;
+        decodeJobSpec: typeof import("./job-spec/codec").decodeJobSpec;
+        describeJobSpec: typeof import("./job-spec/helpers").describeJobSpec;
+        prepareRead: typeof import("./job-spec/read").prepareJobRead;
+        previewJobSpec: typeof import("./job-spec/preview").previewJobSpec;
+    }>;
+    static readonly market: Readonly<{
+        validateAgentCardRules: typeof validateAgentCardRules;
+        encodeAgentCardRules: typeof encodeAgentCardRules;
+        decodeAgentCardRules: typeof decodeAgentCardRules;
+    }>;
     /**
      * Internal: resolves a CHAIN enum from either a CHAIN value or a PushChain client instance.
      */

package/src/lib/utils.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Utils = void 0;
 const presets_1 = require("./agentic/presets");
+const job_spec_1 = require("./job-spec");
+const rules_1 = require("./market/rules");
 const account_1 = require("./universal/account");
 const signer_1 = require("./universal/signer");
 const enums_1 = require("./constants/enums");
@@ -665,6 +667,8 @@ class Utils {
     };
     /** Pure preset discovery/templates; internal encoders and identifiers stay private. */
     static agentic = Object.freeze({ presets: presets_1.agenticPresets });
+    static job = job_spec_1.jobSpecUtils;
+    static market = Object.freeze({ validateAgentCardRules: rules_1.validateAgentCardRules, encodeAgentCardRules: rules_1.encodeAgentCardRules, decodeAgentCardRules: rules_1.decodeAgentCardRules });
     /**
      * Internal: resolves a CHAIN enum from either a CHAIN value or a PushChain client instance.
      */