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

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

@@ -0,0 +1,24 @@
+import { type Address, type Hex } from 'viem';
+import { type MoveableToken } from '../constants/tokens';
+import { type MarketSnapshot, type StackRuntime } from './runtime';
+import type { AgentCard, MarketDepositOptions, MarketDepositResult, MarketDepositStep } from './types';
+type LoadCard = (cardId: bigint, at: MarketSnapshot) => Promise<AgentCard>;
+export interface DepositCheckpoint {
+    txs: MarketDepositStep[];
+    pending?: MarketDepositResult['pending'];
+}
+interface Asset {
+    step: MarketDepositStep['step'];
+    token?: Address;
+    required: bigint;
+    originToken?: MoveableToken;
+}
+/** Recover amounts from the block that opened the job, never today's mutable card. */
+export declare function openedDeposit(rt: StackRuntime, jobId: bigint, loadCard: LoadCard): Promise<{
+    result: MarketDepositResult;
+    assets: Asset[];
+    rulesId: Hex;
+}>;
+/** Separate, confirmed top-ups from the signer's Push identity. Does not fund kernel escrow. */
+export declare function depositJob(rt: StackRuntime, jobId: bigint, options: MarketDepositOptions, loadCard: LoadCard, checkpoints: Map<bigint, DepositCheckpoint>): Promise<MarketDepositResult>;
+export {};

package/src/lib/market/deposit.js

@@ -0,0 +1,271 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openedDeposit = openedDeposit;
+exports.depositJob = depositJob;
+const viem_1 = require("viem");
+const UniversalMarketplace_1 = require("./contracts/UniversalMarketplace");
+const AgenticCommerce_1 = require("./contracts/AgenticCommerce");
+const kernel_wire_1 = require("./kernel-wire");
+const codec_1 = require("../job-spec/codec");
+const helpers_1 = require("../job-spec/helpers");
+const deployments_1 = require("../agentic/deployments");
+const ids_1 = require("../agentic/codec/ids");
+const snapshot_1 = require("../agentic/reads/snapshot");
+const common_1 = require("../agentic/management/common");
+const rules_1 = require("./rules");
+const history_1 = require("./history");
+const tokens_1 = require("../constants/tokens");
+const prc20_address_1 = require("../universal/prc20-address");
+const errors_1 = require("./errors");
+const runtime_1 = require("./runtime");
+const uint256 = (n) => {
+    if (typeof n !== 'bigint' || n < BigInt(0) || n >= BigInt(1) << BigInt(256))
+        throw new errors_1.MarketError('INVALID_AMOUNT', 'Deposit amounts must fit uint256.');
+};
+function submittedHash(cause, seen = new Set()) {
+    if (!cause || typeof cause !== 'object' || seen.has(cause) || seen.size > 16)
+        return;
+    seen.add(cause);
+    const value = cause;
+    for (const key of ['gatewayTxHash', 'pendingTransactionHash', 'txHash'])
+        if (typeof value[key] === 'string' && value[key])
+            return value[key];
+    for (const key of ['cause', 'error', 'details']) {
+        const found = submittedHash(value[key], seen);
+        if (found)
+            return found;
+    }
+    return;
+}
+const sameAsset = (a, b) => a === undefined || b === undefined
+    ? a === b
+    : (0, viem_1.getAddress)(a) === (0, viem_1.getAddress)(b);
+/** Recover amounts from the block that opened the job, never today's mutable card. */
+async function openedDeposit(rt, jobId, loadCard) {
+    if (typeof jobId !== 'bigint' || jobId < BigInt(1))
+        throw new errors_1.MarketError('INVALID_JOB_ID', 'Job IDs are positive bigint values.');
+    const s = await (0, runtime_1.snapshot)(rt);
+    const d = (0, runtime_1.deployment)(rt);
+    const [cardId, version, wallet, rulesId, kernel] = await Promise.all([
+        s.read(d.marketplace, UniversalMarketplace_1.MARKETPLACE_ABI, 'cardOfJob', [jobId]),
+        s.read(d.marketplace, UniversalMarketplace_1.MARKETPLACE_ABI, 'cardVersionOfJob', [jobId]),
+        s.read(d.marketplace, UniversalMarketplace_1.MARKETPLACE_ABI, 'agwOfJob', [jobId]),
+        s.read(d.marketplace, UniversalMarketplace_1.MARKETPLACE_ABI, 'rulesOfJob', [jobId]),
+        s.read(d.kernel, kernel_wire_1.KERNEL_READ_ABI, 'getJob', [jobId]),
+    ]);
+    if (!cardId || (0, viem_1.getAddress)(wallet) === viem_1.zeroAddress)
+        throw new errors_1.MarketError('NOT_MARKETPLACE_JOB', 'This job was not opened through this marketplace.');
+    if (kernel.status !== 0 || kernel.expiredAt <= s.timestamp)
+        throw new errors_1.MarketError('WRONG_STATUS', 'Deposit only while the job is Open and unexpired.');
+    if ((0, viem_1.getAddress)(kernel.client) !== (0, viem_1.getAddress)(wallet))
+        throw new errors_1.MarketError('INCONSISTENT_READ', 'The marketplace wallet differs from the kernel client.');
+    let block = rt.jobBlocks?.get(jobId);
+    if (block === undefined) {
+        const created = await (0, snapshot_1.scanLogs)(rt.agw.reader, {
+            address: d.kernel,
+            event: (0, viem_1.getAbiItem)({ abi: AgenticCommerce_1.JOB_KERNEL_ABI, name: 'JobCreated' }),
+            args: { jobId },
+        }, d.startBlock, s.blockNumber);
+        if (created.length !== 1 || created[0].blockNumber === null)
+            throw new errors_1.MarketError('HISTORY_UNAVAILABLE', 'Could not recover one creation block for this job.');
+        block = created[0].blockNumber;
+    }
+    const logs = await (0, snapshot_1.scanLogs)(rt.agw.reader, {
+        address: d.marketplace,
+        event: (0, viem_1.getAbiItem)({ abi: UniversalMarketplace_1.MARKETPLACE_ABI, name: 'JobOpened' }),
+        args: { cardId, agw: wallet },
+    }, block, block);
+    const events = logs
+        .map((l) => (0, viem_1.decodeEventLog)({
+        abi: UniversalMarketplace_1.MARKETPLACE_ABI,
+        eventName: 'JobOpened',
+        data: l.data,
+        topics: l.topics,
+        strict: true,
+    }).args)
+        .filter((e) => e.jobId === jobId);
+    if (events.length !== 1)
+        throw new errors_1.MarketError('HISTORY_UNAVAILABLE', 'Could not recover one marketplace opening for this job.');
+    const opened = events[0];
+    const card = await (0, history_1.historicalCard)(rt, cardId, version, block, loadCard);
+    if (opened.cardVersion !== version)
+        throw new errors_1.MarketError('HISTORY_UNAVAILABLE', 'The opening event does not match the recorded card version.');
+    const spec = (0, codec_1.decodeJobSpec)(kernel.description, { format: 'spec' });
+    if (!('origin' in spec) ||
+        spec.origin !==
+            (0, helpers_1.specOrigin)(d.marketplace, cardId, version, opened.principal) ||
+        opened.rulesId !== rulesId ||
+        (0, viem_1.getAddress)(opened.agw) !== (0, viem_1.getAddress)(wallet) ||
+        (0, viem_1.getAddress)(card.provider) !== (0, viem_1.getAddress)(kernel.provider))
+        throw new errors_1.MarketError('INCONSISTENT_READ', 'The historical opening does not match the stored job.');
+    const token = await s.read(d.kernel, AgenticCommerce_1.JOB_KERNEL_ABI, 'paymentToken');
+    if ((0, viem_1.getAddress)(card.paymentToken) !== (0, viem_1.getAddress)(token))
+        throw new errors_1.MarketError('TOKEN_MISMATCH', 'The opened card and kernel use different payment tokens.');
+    rt.jobBlocks?.set(jobId, block);
+    const rules = (0, rules_1.decodeCardRulesWire)(card.rulesBytes);
+    return {
+        result: {
+            jobId,
+            wallet: (0, viem_1.getAddress)(wallet),
+            cardId,
+            cardVersion: version,
+            txs: [],
+        },
+        assets: [
+            {
+                step: 'PRINCIPAL',
+                token: (0, viem_1.getAddress)(rules.assets[rules.principalAsset].token),
+                required: opened.principal,
+            },
+            {
+                step: 'PROVIDER_FEE',
+                token: (0, viem_1.getAddress)(token),
+                required: card.providerFee,
+            },
+            { step: 'PC', required: card.rules.maxGasPerCall },
+        ],
+        rulesId,
+    };
+}
+/** Separate, confirmed top-ups from the signer's Push identity. Does not fund kernel escrow. */
+async function depositJob(rt, jobId, options, loadCard, checkpoints) {
+    if (rt.agw.isReadOnly)
+        throw new errors_1.MarketError('READ_ONLY', 'Connect a signing wallet to deposit.');
+    if ('skipApprovals' in options)
+        throw new errors_1.MarketError('INVALID_DEPOSIT_OPTIONS', 'V2 cards grant pinned approvals to the agent; deposit has no owner approval step.');
+    if (options.funding !== undefined &&
+        !['push', 'origin'].includes(options.funding))
+        throw new errors_1.MarketError('INVALID_DEPOSIT_OPTIONS', 'Choose push or origin deposit funding.');
+    if (options.funding === 'origin' && rt.agw.signerIsPushNative())
+        throw new errors_1.MarketError('INVALID_DEPOSIT_OPTIONS', 'Use push funding for a Push-native signer.');
+    if (options.pcAmount !== undefined)
+        uint256(options.pcAmount);
+    if (options.providerFee !== undefined)
+        uint256(options.providerFee);
+    const { result, assets, rulesId } = await openedDeposit(rt, jobId, loadCard);
+    const previous = checkpoints.get(jobId);
+    result.txs = [...(options.resume ?? previous?.txs ?? [])];
+    if (previous?.pending &&
+        !result.txs.some((t) => sameAsset(t.token, previous.pending?.token)))
+        throw new errors_1.MarketError('DEPOSIT_INCOMPLETE', 'A broadcast deposit still needs tracking. Rehydrate its response and pass it as a resume step before sending more.', { ...result, pending: previous.pending });
+    const fee = assets[1];
+    fee.required = options.providerFee ?? fee.required;
+    assets[2].required = options.pcAmount ?? assets[2].required;
+    if (assets[0].token === fee.token) {
+        assets[0].step = 'PRINCIPAL_AND_FEE';
+        assets[0].required += fee.required;
+        uint256(assets[0].required);
+        assets.splice(1, 1);
+    }
+    const balance = async (asset, account) => asset.token
+        ? (await (0, runtime_1.snapshot)(rt)).read(asset.token, viem_1.erc20Abi, 'balanceOf', [
+            account,
+        ])
+        : rt.agw.reader.getBalance({ address: account });
+    const available = async () => {
+        const s = await (0, runtime_1.snapshot)(rt);
+        const d = (0, runtime_1.deployment)(rt);
+        const job = await s.read(d.kernel, kernel_wire_1.KERNEL_READ_ABI, 'getJob', [jobId]);
+        if (job.status !== 0 || job.expiredAt <= s.timestamp)
+            throw new errors_1.MarketError('WRONG_STATUS', 'The job is no longer Open and unexpired.');
+        const gen = (0, deployments_1.currentGeneration)(rt.agw.network);
+        if (!(await s.read(gen.addresses.sessionEngine, gen.contracts.abis.engine, 'isPermissionEnabled', [rulesId, result.wallet])))
+            throw new errors_1.MarketError('RULE_NOT_FOUND', 'The job permission is no longer enabled.');
+        const actions = await s.read(gen.addresses.sessionEngine, gen.contracts.abis.engine, 'getEnabledActions', [result.wallet, rulesId]);
+        if (actions.length !== 1)
+            throw new errors_1.MarketError('INCONSISTENT_READ', 'The job permission has an unexpected action count.');
+        const config = await s.read(gen.addresses.rulesPolicy, gen.contracts.abis.policy, 'getConfig', [
+            (0, ids_1.configId)(result.wallet, rulesId, actions[0]),
+            result.wallet,
+        ]);
+        if (!config.initialized || config.assets.some((a) => a.spent > BigInt(0)))
+            throw new errors_1.MarketError('DEPOSIT_ALREADY_USED', 'The job permission has already moved assets. Review funding manually before adding more.');
+    };
+    const checkpoint = {
+        txs: result.txs,
+        pending: previous?.pending,
+    };
+    checkpoints.set(jobId, checkpoint);
+    let submitting;
+    try {
+        // Uncertain prior receipts must settle before balances can authorize another transfer.
+        for (const step of result.txs)
+            await (0, common_1.confirmedLogs)(rt.agw, step.tx);
+        checkpoint.pending = undefined;
+        await available();
+        for (const asset of assets) {
+            const held = await balance(asset, result.wallet);
+            if (held >= asset.required)
+                continue;
+            if (result.txs.some((t) => sameAsset(t.token, asset.token)))
+                throw new errors_1.MarketError('DEPOSIT_BALANCE_CHANGED', 'A confirmed deposit no longer covers its target balance. Review the wallet before sending more.');
+            const needed = asset.required - held;
+            if (asset.token && options.funding === 'origin') {
+                const chain = rt.agw.signerOrigin().chain;
+                asset.originToken = (tokens_1.MOVEABLE_TOKENS[chain] ?? []).find((candidate) => {
+                    try {
+                        return ((0, viem_1.getAddress)((0, prc20_address_1.getPRC20Address)({ chain, address: candidate.address }, { network: rt.agw.network }).address) === asset.token);
+                    }
+                    catch {
+                        return false;
+                    }
+                });
+                if (!asset.originToken)
+                    throw new errors_1.MarketError('TOKEN_ROUTE_UNAVAILABLE', 'This deposit token has no registered route from the connected origin chain. Prefund it on Push or connect its origin.', { chain, token: asset.token });
+                continue;
+            }
+            const source = (0, viem_1.getAddress)(rt.agw.signerPushAccount());
+            if (source === result.wallet || (await balance(asset, source)) < needed)
+                throw new errors_1.MarketError('INSUFFICIENT_FUNDS', 'The connected signer’s Push account cannot cover this deposit.', { token: asset.token, required: needed, account: source });
+        }
+        for (const asset of assets) {
+            await available();
+            const held = await balance(asset, result.wallet);
+            if (held >= asset.required)
+                continue;
+            const amount = asset.required - held;
+            if (result.txs.some((t) => sameAsset(t.token, asset.token)))
+                throw new errors_1.MarketError('DEPOSIT_BALANCE_CHANGED', 'A confirmed deposit balance changed before the next step. Review the wallet before sending more.');
+            submitting = { step: asset.step, token: asset.token, amount };
+            const tx = asset.originToken
+                ? await rt.agw.execute({ to: result.wallet, funds: { token: asset.originToken, amount } }, { progressHook: options.progressHook })
+                : await (0, runtime_1.write)(rt, asset.token
+                    ? {
+                        target: asset.token,
+                        value: BigInt(0),
+                        data: (0, viem_1.encodeFunctionData)({
+                            abi: viem_1.erc20Abi,
+                            functionName: 'transfer',
+                            args: [result.wallet, amount],
+                        }),
+                    }
+                    : { target: result.wallet, value: amount, data: '0x' }, options.progressHook, 'MARKET', true);
+            result.txs.push({ step: asset.step, token: asset.token, amount, tx });
+            submitting = undefined;
+            (0, runtime_1.progress)(rt, options.progressHook, 'MARKET-TX-111', 'Deposit step submitted', { step: asset.step, token: asset.token, amount, txHash: tx.hash });
+            await (0, common_1.confirmedLogs)(rt.agw, tx);
+            if ((await balance(asset, result.wallet)) < asset.required)
+                throw new errors_1.MarketError('DEPOSIT_BALANCE_CHANGED', 'The transfer did not establish the required wallet balance. Review the receipt before retrying.');
+        }
+        checkpoints.delete(jobId);
+        return result;
+    }
+    catch (cause) {
+        const txHash = submitting && submittedHash(cause);
+        if (submitting && txHash) {
+            checkpoint.pending = {
+                ...submitting,
+                txHash,
+                chain: options.funding === 'origin' && submitting.token
+                    ? rt.agw.signerOrigin().chain
+                    : rt.agw.pushChainNamespace,
+            };
+        }
+        throw new errors_1.MarketError('DEPOSIT_INCOMPLETE', 'The deposit did not finish. Resume with the recorded transactions after resolving the cause.', {
+            ...result,
+            ...(checkpoint.pending ? { pending: checkpoint.pending } : {}),
+            causeCode: cause instanceof errors_1.MarketError ? cause.code : undefined,
+        }, cause);
+    }
+}
+//# sourceMappingURL=deposit.js.map

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

@@ -0,0 +1,13 @@
+import { AgenticError } from '../agentic/errors';
+export declare class MarketError extends AgenticError<string> {
+    constructor(code: string, message: string, details?: Record<string, unknown>, cause?: unknown);
+}
+export declare class JobError extends MarketError {
+    constructor(code: string, message: string, details?: Record<string, unknown>, cause?: unknown);
+}
+export declare class JobSpecError extends MarketError {
+    constructor(code: string, message: string, details?: Record<string, unknown>, cause?: unknown);
+}
+export declare function unavailable(feature: string): never;
+/** Inspect provider error chains without parsing human-readable revert messages. */
+export declare function stackError(error: unknown): unknown;

package/src/lib/market/errors.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobSpecError = exports.JobError = exports.MarketError = void 0;
+exports.unavailable = unavailable;
+exports.stackError = stackError;
+const viem_1 = require("viem");
+const errors_1 = require("../agentic/errors");
+const UniversalMarketplaceErrors_1 = require("./contracts/UniversalMarketplaceErrors");
+const AgenticCommerce_1 = require("./contracts/AgenticCommerce");
+const RulesBindingHook_1 = require("./contracts/RulesBindingHook");
+class MarketError extends errors_1.AgenticError {
+    constructor(code, message, details, cause) {
+        super(code, message, { userMessage: message, details, cause });
+        this.name = 'MarketError';
+    }
+}
+exports.MarketError = MarketError;
+class JobError extends MarketError {
+    constructor(code, message, details, cause) {
+        super(code, message, details, cause);
+        this.name = 'JobError';
+    }
+}
+exports.JobError = JobError;
+class JobSpecError extends MarketError {
+    constructor(code, message, details, cause) {
+        super(code, message, details, cause);
+        this.name = 'JobSpecError';
+    }
+}
+exports.JobSpecError = JobSpecError;
+function unavailable(feature) {
+    throw new MarketError('CAPABILITY_UNAVAILABLE', `${feature} is not available in the deployed marketplace v2 stack.`, { feature });
+}
+/** Inspect provider error chains without parsing human-readable revert messages. */
+function stackError(error) {
+    if (error instanceof errors_1.AgenticError)
+        return error;
+    const seen = new Set();
+    const submitted = error;
+    const recovery = {
+        ...(submitted?.txHash ? { txHash: submitted.txHash } : {}),
+        ...(submitted?.pendingTransactionHash
+            ? { pendingTransactionHash: submitted.pendingTransactionHash }
+            : {}),
+        ...(submitted?.gatewayTxHash
+            ? { gatewayTxHash: submitted.gatewayTxHash }
+            : {}),
+    };
+    function visit(value, depth) {
+        if (!value || typeof value !== 'object' || seen.has(value) || depth > 8)
+            return;
+        seen.add(value);
+        const o = value;
+        if (o['code'] === 4001 || o['name'] === 'UserRejectedRequestError')
+            return new MarketError('REQUEST_REJECTED', 'The wallet request was cancelled.', undefined, error);
+        if (typeof o['data'] === 'string' && /^0x[0-9a-f]+$/i.test(o['data'])) {
+            try {
+                const decoded = (0, viem_1.decodeErrorResult)({
+                    abi: [...UniversalMarketplaceErrors_1.MARKET_ERRORS_ABI, ...AgenticCommerce_1.JOB_KERNEL_ABI, ...RulesBindingHook_1.RULES_HOOK_ABI],
+                    data: o['data'],
+                });
+                const code = decoded.errorName
+                    .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+                    .toUpperCase();
+                return new MarketError(code, `The contract rejected the request: ${decoded.errorName}.`, { decodedError: decoded, ...recovery }, error);
+            }
+            catch {
+                /* This value is not a known stack revert; retain the provider cause. */
+            }
+        }
+        for (const key of ['cause', 'error', 'data']) {
+            const found = visit(o[key], depth + 1);
+            if (found)
+                return found;
+        }
+        return;
+    }
+    return visit(error, 0) ?? error;
+}
+//# sourceMappingURL=errors.js.map

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

@@ -0,0 +1,6 @@
+import { type MarketSnapshot, type StackRuntime } from './runtime';
+import type { AgentCard } from './types';
+/** Exact deposit-critical fields from an emitted version, including same-block updates.
+ * Event content hashes, immutable provider/chain and the kernel token bind the recovered input.
+ */
+export declare function historicalCard(rt: StackRuntime, cardId: bigint, version: bigint, openedAt: bigint, load: (cardId: bigint, at: MarketSnapshot) => Promise<AgentCard>): Promise<Pick<AgentCard, 'version' | 'provider' | 'paymentToken' | 'providerFee' | 'rulesBytes' | 'rules'>>;

package/src/lib/market/history.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.historicalCard = historicalCard;
+const viem_1 = require("viem");
+const snapshot_1 = require("../agentic/reads/snapshot");
+const UniversalMarketplace_1 = require("./contracts/UniversalMarketplace");
+const rules_1 = require("./rules");
+const data_1 = require("./data");
+const errors_1 = require("./errors");
+const runtime_1 = require("./runtime");
+/** Exact deposit-critical fields from an emitted version, including same-block updates.
+ * Event content hashes, immutable provider/chain and the kernel token bind the recovered input.
+ */
+async function historicalCard(rt, cardId, version, openedAt, load) {
+    let originalCause;
+    try {
+        const card = await load(cardId, await (0, runtime_1.snapshot)(rt, openedAt));
+        if (card.version === version)
+            return card;
+    }
+    catch (cause) {
+        originalCause = cause;
+    }
+    const d = (0, runtime_1.deployment)(rt);
+    const fail = (cause) => {
+        throw new errors_1.MarketError('HISTORY_UNAVAILABLE', 'Could not authenticate the exact opened card version from historical state or transaction input.', { cardId, cardVersion: version, openedAt }, cause ?? originalCause);
+    };
+    if (!rt.agw.reader.getTransaction)
+        return fail();
+    const name = version === BigInt(1) ? 'AgentCardRegistered' : 'AgentCardUpdated';
+    const records = await (0, snapshot_1.scanLogs)(rt.agw.reader, {
+        address: d.marketplace,
+        event: (0, viem_1.getAbiItem)({ abi: UniversalMarketplace_1.MARKETPLACE_ABI, name }),
+        args: { cardId },
+    }, d.startBlock, openedAt);
+    const matches = records
+        .map((log) => ({
+        log,
+        event: (0, viem_1.decodeEventLog)({
+            abi: UniversalMarketplace_1.MARKETPLACE_ABI,
+            eventName: name,
+            data: log.data,
+            topics: log.topics,
+            strict: true,
+        }).args,
+    }))
+        .filter(({ event }) => !('version' in event) || event.version === version);
+    if (matches.length !== 1)
+        return fail();
+    const { log, event } = matches[0];
+    if (!log.transactionHash || log.blockNumber === null)
+        return fail();
+    const tx = await rt.agw.reader.getTransaction({ hash: log.transactionHash });
+    if (tx.blockNumber !== log.blockNumber)
+        return fail();
+    // The chain and provider cannot change on update. Do not decode today's potentially malformed template.
+    const current = await (await (0, runtime_1.snapshot)(rt)).read(d.marketplace, UniversalMarketplace_1.MARKETPLACE_ABI, 'getAgentCard', [cardId]);
+    const fn = version === BigInt(1) ? 'registerAgentCard' : 'updateAgentCard';
+    const candidates = (0, data_1.embeddedCalls)(tx.input, UniversalMarketplace_1.MARKETPLACE_ABI, fn).filter((args) => {
+        const i = version === BigInt(1) ? 0 : 1;
+        const c = args[i];
+        return ((i === 0 || args[0] === cardId) &&
+            c.chainNamespace === current.card.chainNamespace &&
+            (0, viem_1.getAddress)(c.paymentToken) === (0, viem_1.getAddress)(current.card.paymentToken) &&
+            c.providerFee === event.providerFee &&
+            (0, viem_1.keccak256)(args[i + 1]) === event.rulesHash &&
+            (0, viem_1.keccak256)(args[i + 2]) === event.jobSpecHash);
+    });
+    // Identical byte sequences may appear more than once in a wrapper. Hash-bound content is identical.
+    if (!candidates.length)
+        return fail();
+    const i = version === BigInt(1) ? 0 : 1;
+    const rulesBytes = candidates[0][i + 1];
+    return {
+        version,
+        provider: (0, viem_1.getAddress)(current.card.provider),
+        paymentToken: (0, viem_1.getAddress)(current.card.paymentToken),
+        providerFee: event.providerFee,
+        rulesBytes,
+        rules: (0, rules_1.decodeAgentCardRules)(rulesBytes),
+    };
+}
+//# sourceMappingURL=history.js.map

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

@@ -0,0 +1,4 @@
+export { MarketError, JobError, JobSpecError } from './errors';
+export type * from './types';
+export type { AgentCardRules, MarketAssetToken, MarketPin } from './rules';
+export { validateAgentCardRules, encodeAgentCardRules, decodeAgentCardRules, } from './rules';

package/src/lib/market/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeAgentCardRules = exports.encodeAgentCardRules = exports.validateAgentCardRules = exports.JobSpecError = exports.JobError = exports.MarketError = void 0;
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "MarketError", { enumerable: true, get: function () { return errors_1.MarketError; } });
+Object.defineProperty(exports, "JobError", { enumerable: true, get: function () { return errors_1.JobError; } });
+Object.defineProperty(exports, "JobSpecError", { enumerable: true, get: function () { return errors_1.JobSpecError; } });
+var rules_1 = require("./rules");
+Object.defineProperty(exports, "validateAgentCardRules", { enumerable: true, get: function () { return rules_1.validateAgentCardRules; } });
+Object.defineProperty(exports, "encodeAgentCardRules", { enumerable: true, get: function () { return rules_1.encodeAgentCardRules; } });
+Object.defineProperty(exports, "decodeAgentCardRules", { enumerable: true, get: function () { return rules_1.decodeAgentCardRules; } });
+//# sourceMappingURL=index.js.map

package/src/lib/market/kernel-wire.d.ts

@@ -0,0 +1,15 @@
+import { type Abi, type Address, type Hex } from 'viem';
+export declare const CREATE_JOB_SELECTOR: `0x${string}`;
+/** Solidity string(description) carries arbitrary ABI bytes, not UTF-8 text. */
+export declare const KERNEL_READ_ABI: Abi;
+export declare function encodeCreateJob(provider: Address, evaluator: Address, expiredAt: number, payload: {
+    jobSpec?: Hex;
+    description?: string;
+}, hook: Address): Hex;
+export declare function decodeCreateJob(data: Hex): {
+    provider: Address;
+    evaluator: Address;
+    expiredAt: bigint;
+    description: Hex;
+    hook: Address;
+};

package/src/lib/market/kernel-wire.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KERNEL_READ_ABI = exports.CREATE_JOB_SELECTOR = void 0;
+exports.encodeCreateJob = encodeCreateJob;
+exports.decodeCreateJob = decodeCreateJob;
+const viem_1 = require("viem");
+const AgenticCommerce_1 = require("./contracts/AgenticCommerce");
+const errors_1 = require("./errors");
+const create = (0, viem_1.getAbiItem)({ abi: AgenticCommerce_1.JOB_KERNEL_ABI, name: 'createJob' });
+exports.CREATE_JOB_SELECTOR = (0, viem_1.toFunctionSelector)(create);
+const inputs = create.inputs.map((p) => p.name === 'description' ? { ...p, type: 'bytes' } : p);
+/** Solidity string(description) carries arbitrary ABI bytes, not UTF-8 text. */
+exports.KERNEL_READ_ABI = AgenticCommerce_1.JOB_KERNEL_ABI.map((item) => item.type === 'function' && item.name === 'getJob'
+    ? {
+        ...item,
+        outputs: item.outputs.map((p) => ({
+            ...p,
+            components: p.components.map((c) => c.name === 'description' ? { ...c, type: 'bytes' } : c),
+        })),
+    }
+    : item);
+function encodeCreateJob(provider, evaluator, expiredAt, payload, hook) {
+    if (payload.jobSpec && payload.description !== undefined)
+        throw new errors_1.JobError('INVALID_JOB', 'Use jobSpec or description, not both.');
+    const bytes = payload.jobSpec ?? (0, viem_1.stringToHex)(payload.description ?? '');
+    return (exports.CREATE_JOB_SELECTOR +
+        (0, viem_1.encodeAbiParameters)(inputs, [
+            provider,
+            evaluator,
+            BigInt(expiredAt),
+            bytes,
+            hook,
+        ]).slice(2));
+}
+function decodeCreateJob(data) {
+    if (data.slice(0, 10).toLowerCase() !== exports.CREATE_JOB_SELECTOR)
+        throw new errors_1.JobError('INVALID_JOB', 'Expected the deployed kernel createJob selector.');
+    const [provider, evaluator, expiredAt, description, hook] = (0, viem_1.decodeAbiParameters)(inputs, ('0x' + data.slice(10)));
+    return { provider, evaluator, expiredAt, description, hook };
+}
+//# sourceMappingURL=kernel-wire.js.map

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

@@ -0,0 +1,55 @@
+import { type Address, type Hex } from 'viem';
+import { type StackRuntime } from './runtime';
+import type { AgentCard, AgentCardInput, AgentCardSummary, JobPlan, MarketNamespace, MarketPreviewOptions, MarketWriteOptions, MarketDepositOptions, MarketOpenOptions } from './types';
+export declare class MarketNamespaceImpl implements MarketNamespace {
+    private readonly rt;
+    constructor(rt: StackRuntime);
+    private readonly deposits;
+    private readonly depositCheckpoints;
+    private viewAt;
+    private summaryAt;
+    private cardAt;
+    card(cardId: bigint): Promise<AgentCard>;
+    cards(options?: {
+        provider?: Address;
+        chain?: string;
+        active?: boolean;
+    }): Promise<{
+        cards: AgentCardSummary[];
+    }>;
+    job(jobId: bigint): Promise<{
+        cardId: bigint;
+        cardVersion: bigint;
+        wallet: Address;
+        rulesId: Hex;
+    }>;
+    activeJob(wallet: Address): Promise<{
+        jobId: bigint;
+    }>;
+    preview(cardId: bigint, options: MarketPreviewOptions): Promise<JobPlan>;
+    openJob(plan: JobPlan, options?: MarketOpenOptions): Promise<{
+        jobId: bigint;
+        wallet: `0x${string}`;
+        rulesId: Hex;
+        tx: import("../orchestrator/orchestrator.types").UniversalTxResponse;
+    }>;
+    private openedResult;
+    private verifyOpening;
+    deposit(jobId: bigint, options?: MarketDepositOptions): Promise<import("./types").MarketDepositResult>;
+    readonly agent: {
+        card: () => Promise<AgentCard | undefined>;
+        register: (card: AgentCardInput, options: Parameters<MarketNamespace["agent"]["register"]>[1]) => Promise<{
+            cardId: bigint;
+            version: bigint;
+            tx: import("../orchestrator/orchestrator.types").UniversalTxResponse;
+        }>;
+        update: (cardId: bigint, card: AgentCardInput, options: Parameters<MarketNamespace["agent"]["update"]>[2]) => Promise<{
+            cardId: bigint;
+            version: bigint;
+            tx: import("../orchestrator/orchestrator.types").UniversalTxResponse;
+        }>;
+        setActive: (cardId: bigint, active: boolean, options?: MarketWriteOptions) => Promise<import("../orchestrator/orchestrator.types").UniversalTxResponse>;
+    };
+    private assertProvider;
+    private cardWrite;
+}