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

package/src/lib/market/market.js

@@ -0,0 +1,635 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarketNamespaceImpl = void 0;
+const viem_1 = require("viem");
+const UniversalMarketplace_1 = require("./contracts/UniversalMarketplace");
+const AgenticCommerce_1 = require("./contracts/AgenticCommerce");
+const UniversalMarketplaceRules_1 = require("./contracts/UniversalMarketplaceRules");
+const deployments_1 = require("../agentic/deployments");
+const ids_1 = require("../agentic/codec/ids");
+const session_1 = require("../agentic/codec/session");
+const universal_terms_1 = require("../agentic/codec/universal-terms");
+const label_1 = require("../agentic/management/label");
+const codec_1 = require("../job-spec/codec");
+const helpers_1 = require("../job-spec/helpers");
+const rules_1 = require("./rules");
+const kernel_wire_1 = require("./kernel-wire");
+const data_1 = require("./data");
+const deposit_1 = require("./deposit");
+const runtime_1 = require("./runtime");
+const errors_1 = require("./errors");
+const ownerIntentFields = [
+    ['owner', 'address'],
+    ['wallet', 'address'],
+    ['executor', 'address'],
+    ['index', 'uint96'],
+    ['sessionHash', 'bytes32'],
+    ['mode', 'bytes32'],
+    ['execCalldataHash', 'bytes32'],
+    ['nonceKey', 'uint192'],
+    ['nonceSeq', 'uint64'],
+    ['grantNonce', 'uint64'],
+    ['deadline', 'uint48'],
+    ['signerChainId', 'uint256'],
+].map(([name, type]) => ({ name, type }));
+function id(n) {
+    if (typeof n !== 'bigint' || n < BigInt(1))
+        throw new errors_1.MarketError('INVALID_CARD_ID', 'Card IDs are positive bigint values.');
+}
+class MarketNamespaceImpl {
+    rt;
+    constructor(rt) {
+        this.rt = rt;
+    }
+    deposits = new Set();
+    depositCheckpoints = new Map();
+    async viewAt(cardId, s) {
+        id(cardId);
+        const d = (0, runtime_1.deployment)(this.rt);
+        const v = await s.read(d.marketplace, UniversalMarketplace_1.MARKETPLACE_ABI, 'getAgentCard', [
+            cardId,
+        ]);
+        if ((0, viem_1.getAddress)(v.card.provider) === viem_1.zeroAddress)
+            throw new errors_1.MarketError('CARD_NOT_FOUND', 'This agent card does not exist.');
+        return v;
+    }
+    async summaryAt(cardId, s, view) {
+        const v = view ?? (await this.viewAt(cardId, s));
+        const d = (0, runtime_1.deployment)(this.rt);
+        const { chainNamespace, ...card } = v.card;
+        return {
+            ...card,
+            cardId,
+            chain: chainNamespace,
+            version: v.version,
+            verified: v.verified,
+            disabled: v.disabled,
+            rating: await s.read(d.marketplace, UniversalMarketplace_1.MARKETPLACE_ABI, 'getAgentRating', [
+                v.card.provider,
+            ]),
+        };
+    }
+    async cardAt(cardId, s) {
+        const v = await this.viewAt(cardId, s);
+        return {
+            ...(await this.summaryAt(cardId, s, v)),
+            rules: (0, rules_1.decodeAgentCardRules)(v.rules),
+            jobSpecTemplate: (0, codec_1.decodeJobSpec)(v.jobSpecTemplate, {
+                format: 'template',
+            }),
+            rulesBytes: v.rules,
+            jobSpecTemplateBytes: v.jobSpecTemplate,
+        };
+    }
+    async card(cardId) {
+        return this.cardAt(cardId, await (0, runtime_1.snapshot)(this.rt));
+    }
+    async cards(options = {}) {
+        const s = await (0, runtime_1.snapshot)(this.rt);
+        const d = (0, runtime_1.deployment)(this.rt);
+        const count = options.provider
+            ? await s.read(d.marketplace, UniversalMarketplace_1.MARKETPLACE_ABI, 'agentCardOf', [
+                (0, viem_1.getAddress)(options.provider),
+            ])
+            : await s.read(d.marketplace, UniversalMarketplace_1.MARKETPLACE_ABI, 'agentCardCount');
+        const cards = [];
+        // Bounded requests. An indexer can replace the walk without changing the public result.
+        for (let start = options.provider ? count : BigInt(1); start > BigInt(0) && start <= count;) {
+            const batch = options.provider
+                ? [start]
+                : Array.from({
+                    length: Number(count - start + BigInt(1) > BigInt(8)
+                        ? BigInt(8)
+                        : count - start + BigInt(1)),
+                }, (_, i) => start + BigInt(i));
+            const rows = await Promise.all(batch.map((n) => this.summaryAt(n, s)));
+            for (const card of rows)
+                if ((!options.chain || card.chain === options.chain) &&
+                    (options.active === undefined || card.active === options.active)) {
+                    cards.push(card);
+                }
+            if (options.provider)
+                break;
+            start += BigInt(batch.length);
+        }
+        return { cards };
+    }
+    async job(jobId) {
+        const s = await (0, runtime_1.snapshot)(this.rt);
+        const d = (0, runtime_1.deployment)(this.rt);
+        const [cardId, cardVersion, wallet, rulesId] = 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]),
+        ]);
+        return { cardId, cardVersion, wallet, rulesId };
+    }
+    async activeJob(wallet) {
+        const d = (0, runtime_1.deployment)(this.rt);
+        return {
+            jobId: await (await (0, runtime_1.snapshot)(this.rt)).read(d.marketplace, UniversalMarketplace_1.MARKETPLACE_ABI, 'activeJobOf', [(0, viem_1.getAddress)(wallet)]),
+        };
+    }
+    async preview(cardId, options) {
+        options = { ...options, params: options.params && [...options.params] };
+        const rt = this.rt;
+        const d = (0, runtime_1.deployment)(rt);
+        const s = await (0, runtime_1.snapshot)(rt);
+        const card = await this.cardAt(cardId, s);
+        const gen = (0, deployments_1.currentGeneration)(rt.agw.network);
+        const now = s.timestamp;
+        if (card.disabled || !card.active)
+            throw new errors_1.MarketError('AGENT_CARD_INACTIVE', 'This agent card is inactive or disabled.');
+        if (card.jobSpecTemplate.allowedMutability !== 'NONE')
+            (0, errors_1.unavailable)('Mutable marketplace criteria');
+        const [factory, kernel, paused, evaluator, hook, rulesHelper, kernelPaused,] = await Promise.all([
+            s.read(d.marketplace, UniversalMarketplace_1.MARKETPLACE_ABI, 'AGW_FACTORY'),
+            s.read(d.marketplace, UniversalMarketplace_1.MARKETPLACE_ABI, 'KERNEL'),
+            s.read(d.marketplace, UniversalMarketplace_1.MARKETPLACE_ABI, 'paused'),
+            s.read(d.marketplace, UniversalMarketplace_1.MARKETPLACE_ABI, 'evaluator'),
+            s.read(d.marketplace, UniversalMarketplace_1.MARKETPLACE_ABI, 'hook'),
+            s.read(d.marketplace, UniversalMarketplace_1.MARKETPLACE_ABI, 'RULES'),
+            s.read(d.kernel, AgenticCommerce_1.JOB_KERNEL_ABI, 'paused'),
+        ]);
+        if ((0, viem_1.getAddress)(factory) !== (0, viem_1.getAddress)(gen.addresses.factory) ||
+            (0, viem_1.getAddress)(kernel) !== (0, viem_1.getAddress)(d.kernel) ||
+            (0, viem_1.getAddress)(hook) !== (0, viem_1.getAddress)(d.hook) ||
+            (0, viem_1.getAddress)(rulesHelper) !== (0, viem_1.getAddress)(d.rules) ||
+            (0, viem_1.getAddress)(evaluator) !== (0, viem_1.getAddress)(d.evaluator))
+            throw new errors_1.MarketError('CAPABILITY_UNAVAILABLE', 'The marketplace deployment wiring has changed.');
+        if (paused || kernelPaused)
+            throw new errors_1.MarketError('PAUSED', 'The marketplace or kernel is paused.');
+        if ((0, viem_1.getAddress)(card.provider) === (0, viem_1.getAddress)(evaluator))
+            throw new errors_1.MarketError('PROVIDER_IS_EVALUATOR', 'The provider cannot be the evaluator.');
+        const job = {
+            principal: options.principal,
+            expiredAt: options.expiredAt,
+            executeBy: options.executeBy,
+            params: options.params ?? [],
+        };
+        if (typeof job.principal !== 'bigint' ||
+            job.principal < card.principalMin ||
+            job.principal > card.principalMax)
+            throw new errors_1.MarketError('PRINCIPAL_OUT_OF_RANGE', 'The principal is outside this card’s range.');
+        if (!Number.isSafeInteger(job.expiredAt) ||
+            job.expiredAt < now + card.minDuration ||
+            job.expiredAt > now + card.maxDuration ||
+            job.expiredAt >= 2 ** 48)
+            throw new errors_1.MarketError('EXPIRY_OUT_OF_RANGE', 'Choose an expiry inside the card’s duration window.');
+        if (!Number.isSafeInteger(job.executeBy) ||
+            job.executeBy < now + card.minExecuteWindow ||
+            job.executeBy + card.settleWindow > job.expiredAt)
+            throw new errors_1.MarketError('EXECUTE_BY_OUT_OF_RANGE', 'Choose an execution deadline that leaves the settlement window.');
+        const owner = (0, viem_1.getAddress)(rt.agw.signerPushAccount());
+        if (owner === (0, viem_1.getAddress)(card.provider))
+            throw new errors_1.MarketError('CLIENT_IS_PROVIDER', 'The wallet owner and provider must be different.');
+        if (options.walletIndex !== undefined &&
+            (!Number.isSafeInteger(options.walletIndex) || options.walletIndex < 0))
+            throw new errors_1.MarketError('INVALID_WALLET_INDEX', 'The wallet index must be a nonnegative safe integer.');
+        const index = options.walletIndex === undefined
+            ? await s.read(factory, gen.contracts.abis.factory, 'walletCount', [owner])
+            : BigInt(options.walletIndex);
+        const [wallet, deployed] = await s.read(factory, gen.contracts.abis.factory, 'predictWallet', [owner, index]);
+        if (deployed &&
+            (0, viem_1.getAddress)(await s.read(factory, gen.contracts.abis.factory, 'ownerOf', [
+                wallet,
+            ])) !== owner)
+            throw new errors_1.MarketError('NOT_OWNER', 'The connected account does not own this wallet.');
+        if ((await s.read(d.marketplace, UniversalMarketplace_1.MARKETPLACE_ABI, 'activeJobOf', [wallet])) !==
+            BigInt(0))
+            throw new errors_1.MarketError('WALLET_HAS_ACTIVE_JOB', 'This wallet already has an active marketplace job.');
+        const accounts = {};
+        const chains = new Set([
+            card.chain,
+            ...card.jobSpecTemplate.reads
+                .filter((r, i) => r.fills?.some((f) => f.source === 'WALLET') ||
+                card.jobSpecTemplate.checks.some((c) => c.read === i && c.target === 'agentic:wallet'))
+                .map((r) => `${r.chainNamespace}:${r.chainId}`),
+        ]);
+        for (const chain of chains) {
+            const [independent, onchain] = await Promise.all([
+                rt.agw.resolveCEA(wallet, chain),
+                s.read(d.marketplace, UniversalMarketplace_1.MARKETPLACE_ABI, 'computeCEA', [
+                    wallet,
+                    (0, viem_1.keccak256)((0, viem_1.stringToHex)(chain)),
+                ]),
+            ]);
+            if ((0, viem_1.getAddress)(independent.cea) !== (0, viem_1.getAddress)(onchain))
+                throw new errors_1.MarketError('CEA_MISMATCH', 'The independently derived destination wallet differs from the marketplace.', { chain, wallet, expectedCEA: onchain, derivedCEA: independent.cea });
+            accounts[chain] = (0, viem_1.getAddress)(onchain);
+        }
+        const rules = (0, rules_1.decodeCardRulesWire)(card.rulesBytes);
+        const terms = (0, rules_1.fillCardRules)(rules, job.principal, accounts[card.chain], job.expiredAt);
+        const session = (0, session_1.buildSession)({
+            validator: gen.addresses.sessionValidator,
+            agent: card.provider,
+            rulesPolicy: gen.addresses.rulesPolicy,
+            actions: [
+                {
+                    target: gen.addresses.gateway,
+                    selector: '0x77b86bec',
+                    initData: (0, session_1.encodeEnvelope)(card.chain, (0, universal_terms_1.encodeUniversalTerms)(terms)),
+                },
+            ],
+        });
+        const rawChain = rt.agw.signerOrigin().chain;
+        if (!/^eip155:[1-9]\d*$/.test(rawChain))
+            (0, errors_1.unavailable)('Non-EVM OwnerIntent signing');
+        const deadline = options.deadline ?? Math.min(now + 3600, job.expiredAt);
+        if (!Number.isSafeInteger(deadline) ||
+            deadline <= now ||
+            deadline >= 2 ** 48)
+            throw new errors_1.MarketError('INVALID_DEADLINE', 'The intent deadline must be a future uint48 timestamp.');
+        const request = {
+            cardId,
+            owner,
+            index,
+            job,
+            deadline,
+            signerChainId: BigInt(rawChain.split(':')[1]),
+        };
+        const [intent, [mode, calldata]] = await Promise.all([
+            s.read(d.marketplace, UniversalMarketplace_1.MARKETPLACE_ABI, 'previewIntent', [
+                request,
+                session,
+            ]),
+            s.read(d.marketplace, UniversalMarketplace_1.MARKETPLACE_ABI, 'buildCreateJobCalldata', [
+                cardId,
+                owner,
+                index,
+                job,
+            ]),
+        ]);
+        const spec = (0, helpers_1.resolveJobSpec)(card.jobSpecTemplate, {
+            principal: job.principal,
+            params: job.params,
+            accounts,
+            origin: (0, helpers_1.specOrigin)(d.marketplace, cardId, card.version, job.principal),
+            executeBy: job.executeBy,
+            settleWindow: card.settleWindow,
+        });
+        if ((0, viem_1.getAddress)(intent.owner) !== owner ||
+            intent.index !== index ||
+            intent.deadline !== deadline ||
+            intent.signerChainId !== request.signerChainId)
+            throw new errors_1.MarketError('INTENT_MISMATCH', 'The preview intent names a different owner, wallet index, chain or deadline.');
+        const bytes = (0, codec_1.encodeJobSpec)(spec);
+        const packedTarget = (0, viem_1.getAddress)(('0x' + calldata.slice(2, 42)));
+        const kernelCall = (0, kernel_wire_1.decodeCreateJob)(('0x' + calldata.slice(106)));
+        if (packedTarget !== (0, viem_1.getAddress)(d.kernel) ||
+            BigInt('0x' + calldata.slice(42, 106)) !== BigInt(0) ||
+            kernelCall.description !== bytes ||
+            (0, viem_1.getAddress)(kernelCall.provider) !== (0, viem_1.getAddress)(card.provider) ||
+            (0, viem_1.getAddress)(kernelCall.evaluator) !== (0, viem_1.getAddress)(evaluator) ||
+            (0, viem_1.getAddress)(kernelCall.hook) !== (0, viem_1.getAddress)(hook) ||
+            kernelCall.expiredAt !== BigInt(job.expiredAt) ||
+            intent.execCalldataHash !== (0, viem_1.keccak256)(calldata) ||
+            intent.sessionHash !== (0, viem_1.keccak256)((0, session_1.encodeSession)(session)) ||
+            intent.mode !== mode ||
+            (0, viem_1.getAddress)(intent.wallet) !== (0, viem_1.getAddress)(wallet) ||
+            (0, viem_1.getAddress)(intent.executor) !== (0, viem_1.getAddress)(d.marketplace))
+            throw new errors_1.MarketError('INTENT_MISMATCH', 'The marketplace preview disagrees with the independently built job or permissions.');
+        await s.read(d.rules, UniversalMarketplaceRules_1.MARKET_RULES_ABI, 'checkRulesMatchCard', [
+            card.rulesBytes,
+            session,
+            {
+                agent: card.provider,
+                chainHash: (0, viem_1.keccak256)((0, viem_1.stringToHex)(card.chain)),
+                principal: job.principal,
+                expiredAt: job.expiredAt,
+                expectedCEA: accounts[card.chain],
+            },
+        ]);
+        const label = options.label ?? 'Agent job';
+        (0, label_1.assertLabel)(label);
+        const description = (0, helpers_1.describeJobSpec)(spec);
+        return {
+            cardId,
+            cardVersion: card.version,
+            wallet: (0, viem_1.getAddress)(wallet),
+            walletDeployed: deployed,
+            session,
+            intent,
+            calldata,
+            jobSpec: { spec, bytes },
+            job,
+            label,
+            deposit: {
+                principal: {
+                    prc20: terms.assets[rules.principalAsset].token,
+                    amount: job.principal,
+                },
+                providerFee: { token: card.paymentToken, amount: card.providerFee },
+                pc: card.rules.maxGasPerCall,
+            },
+            preview: {
+                mayDo: terms.allowedCalls.map((c) => `${card.chain}: ${c.target} ${c.selector}; ${c.pins.length} argument conditions; max value ${c.maxValue}.`),
+                mayMove: terms.assets.map((a) => `${a.token}: up to ${a.maxPerCall} per outbound, ${a.maxTotal} total; gas budget ${terms.maxGasPerCall} PC wei.`),
+                judgedBy: [...description.checks, description.logic],
+                until: new Date(job.expiredAt * 1000).toISOString(),
+            },
+        };
+    }
+    async openJob(plan, options = {}) {
+        plan = (0, data_1.copyData)(plan);
+        options = { ...options };
+        if (options.relay)
+            (0, errors_1.unavailable)('Marketplace relaying');
+        if (options.resume)
+            return this.openedResult(plan, options.resume, true);
+        if (this.rt.agw.isReadOnly)
+            throw new errors_1.MarketError('READ_ONLY', 'Connect a signing wallet to open a job.');
+        if (this.rt.canSignTypedData?.() === false)
+            (0, errors_1.unavailable)('EIP-712 signing with this wallet');
+        if (!this.rt.agw.reader.call)
+            (0, errors_1.unavailable)('Signed marketplace transaction simulation with this reader');
+        const ownerCode = await this.rt.agw.reader.getCode({
+            address: this.rt.agw.signerPushAccount(),
+        });
+        if (!this.rt.agw.signerIsPushNative() && (!ownerCode || ownerCode === '0x'))
+            throw new errors_1.MarketError('OWNER_NOT_DEPLOYED', 'Deploy the connected signer’s UEA on Push before signing a marketplace intent.');
+        const fresh = await this.preview(plan.cardId, {
+            ...plan.job,
+            walletIndex: Number(plan.intent.index),
+            deadline: plan.intent.deadline,
+            label: plan.label,
+        });
+        if ((0, data_1.fingerprint)(fresh) !== (0, data_1.fingerprint)(plan))
+            throw new errors_1.MarketError('STALE_PLAN', 'The plan changed. Preview and review it again before signing.');
+        const d = (0, runtime_1.deployment)(this.rt);
+        const gen = (0, deployments_1.currentGeneration)(this.rt.agw.network);
+        (0, runtime_1.progress)(this.rt, options.progressHook, 'MARKET-TX-101', 'Plan verified', {
+            cardId: plan.cardId,
+            wallet: plan.wallet,
+        });
+        const domain = {
+            name: 'AGWFactory',
+            version: '1',
+            chainId: Number(plan.intent.signerChainId),
+            verifyingContract: gen.addresses.factory,
+            salt: (0, viem_1.toHex)(BigInt(this.rt.agw.pushChainNamespace.split(':')[1]), {
+                size: 32,
+            }),
+        };
+        const separator = await (await (0, runtime_1.snapshot)(this.rt)).read(gen.addresses.factory, gen.contracts.abis.factory, 'domainSeparator', [plan.intent.signerChainId]);
+        if (separator.toLowerCase() !== (0, viem_1.domainSeparator)({ domain }).toLowerCase())
+            throw new errors_1.MarketError('INTENT_MISMATCH', 'The factory EIP-712 domain differs from the signing domain.');
+        let sig;
+        try {
+            sig = (await this.rt.signTypedData({
+                domain,
+                types: { OwnerIntent: ownerIntentFields },
+                primaryType: 'OwnerIntent',
+                message: { ...plan.intent },
+            }));
+        }
+        catch (error) {
+            throw (0, errors_1.stackError)(error);
+        }
+        (0, runtime_1.progress)(this.rt, options.progressHook, 'MARKET-TX-102', 'Owner intent signed');
+        const call = {
+            target: d.marketplace,
+            value: BigInt(0),
+            data: (0, viem_1.encodeFunctionData)({
+                abi: UniversalMarketplace_1.MARKETPLACE_ABI,
+                functionName: 'openJob',
+                args: [
+                    {
+                        cardId: plan.cardId,
+                        cardVersion: plan.cardVersion,
+                        job: plan.job,
+                        session: plan.session,
+                        intent: plan.intent,
+                        sig,
+                        label: plan.label,
+                    },
+                ],
+            }),
+        };
+        try {
+            // Runs the actual factory, owner verifier (UEA / ERC-1271 / EOA), grant and kernel create.
+            // This catches unsupported 7702 delegates without spending gas or bypassing owner verification.
+            await this.rt.agw.reader.call({
+                to: call.target,
+                data: call.data,
+                account: this.rt.agw.signerPushAccount(),
+            });
+        }
+        catch (cause) {
+            throw new errors_1.MarketError('OPEN_JOB_SIMULATION_FAILED', 'The signed marketplace request failed simulation. No transaction was submitted.', { contractError: (0, errors_1.stackError)(cause) }, cause);
+        }
+        const tx = await (0, runtime_1.write)(this.rt, call, options.progressHook, 'MARKET', true);
+        return this.openedResult(plan, tx);
+    }
+    async openedResult(plan, tx, recover = false) {
+        try {
+            return await this.verifyOpening(plan, tx, recover);
+        }
+        catch (cause) {
+            if (cause instanceof errors_1.MarketError && cause.details?.['txHash'])
+                throw cause;
+            throw new errors_1.MarketError('OPEN_JOB_RECOVERY_REQUIRED', 'The opening was submitted but could not be fully verified. Track this transaction and resume with the original plan before opening again.', { txHash: tx.hash }, cause);
+        }
+    }
+    async verifyOpening(plan, tx, recover) {
+        const d = (0, runtime_1.deployment)(this.rt);
+        const gen = (0, deployments_1.currentGeneration)(this.rt.agw.network);
+        const e = await (0, runtime_1.eventArgs)(this.rt, tx, d.marketplace, UniversalMarketplace_1.MARKETPLACE_ABI, 'JobOpened');
+        const [agent] = (0, viem_1.decodeAbiParameters)([{ type: 'address' }], plan.session.sessionValidatorInitData);
+        const expectedRules = (0, ids_1.rulesId)({
+            validator: gen.addresses.sessionValidator,
+            agent,
+            grantNonce: plan.intent.grantNonce,
+        });
+        if (e['cardId'] !== plan.cardId ||
+            e['cardVersion'] !== plan.cardVersion ||
+            (0, viem_1.getAddress)(e['agw']) !== plan.wallet ||
+            e['principal'] !== plan.job.principal ||
+            (0, viem_1.getAddress)(e['owner']) !== (0, viem_1.getAddress)(plan.intent.owner) ||
+            e['rulesId'] !== expectedRules ||
+            (0, viem_1.getAddress)(plan.session.sessionValidator) !==
+                (0, viem_1.getAddress)(gen.addresses.sessionValidator) ||
+            plan.intent.sessionHash !== (0, viem_1.keccak256)((0, session_1.encodeSession)(plan.session)) ||
+            plan.intent.execCalldataHash !== (0, viem_1.keccak256)(plan.calldata))
+            throw new errors_1.MarketError('RECEIPT_MISMATCH', 'The opened job does not match the signed plan.', { txHash: tx.hash });
+        const jobId = e['jobId'];
+        const s = await (0, runtime_1.snapshot)(this.rt);
+        const [cardId, version, wallet, rules, job, owner] = 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]),
+            s.read(gen.addresses.factory, gen.contracts.abis.factory, 'ownerOf', [plan.wallet]),
+        ]);
+        const creation = (0, kernel_wire_1.decodeCreateJob)(('0x' + plan.calldata.slice(106)));
+        if (cardId !== plan.cardId ||
+            version !== plan.cardVersion ||
+            (0, viem_1.getAddress)(wallet) !== (0, viem_1.getAddress)(plan.wallet) ||
+            rules !== expectedRules ||
+            (0, viem_1.getAddress)(owner) !== (0, viem_1.getAddress)(plan.intent.owner) ||
+            (0, viem_1.getAddress)(job.client) !== (0, viem_1.getAddress)(plan.wallet) ||
+            (0, viem_1.getAddress)(job.provider) !== (0, viem_1.getAddress)(agent) ||
+            (0, viem_1.getAddress)(job.evaluator) !== (0, viem_1.getAddress)(creation.evaluator) ||
+            (0, viem_1.getAddress)(job.hook) !== (0, viem_1.getAddress)(creation.hook) ||
+            job.expiredAt !== plan.job.expiredAt ||
+            job.description !== plan.jobSpec.bytes)
+            throw new errors_1.MarketError('RECEIPT_MISMATCH', 'The kernel, wallet and marketplace mappings do not match the opening.', { txHash: tx.hash, jobId });
+        if (recover) {
+            if (!this.rt.agw.reader.getTransaction)
+                throw new errors_1.MarketError('HISTORY_UNAVAILABLE', 'This reader cannot load the submitted opening input.', { txHash: tx.hash });
+            const transaction = await this.rt.agw.reader.getTransaction({
+                hash: tx.hash,
+            });
+            const matched = (0, data_1.embeddedCalls)(transaction.input, UniversalMarketplace_1.MARKETPLACE_ABI, 'openJob').some(([value]) => {
+                const p = value;
+                return (p.cardId === plan.cardId &&
+                    p.cardVersion === plan.cardVersion &&
+                    (0, data_1.fingerprint)(p.job) === (0, data_1.fingerprint)(plan.job) &&
+                    (0, data_1.fingerprint)(p.intent) === (0, data_1.fingerprint)(plan.intent) &&
+                    (0, session_1.encodeSession)(p.session) === (0, session_1.encodeSession)(plan.session));
+            });
+            if (!matched)
+                throw new errors_1.MarketError('RECEIPT_MISMATCH', 'The submitted input does not contain this reviewed opening.', { txHash: tx.hash, jobId });
+        }
+        return {
+            jobId,
+            wallet: (0, viem_1.getAddress)(e['agw']),
+            rulesId: e['rulesId'],
+            tx,
+        };
+    }
+    async deposit(jobId, options = {}) {
+        options = { ...options, resume: options.resume && [...options.resume] };
+        if (this.deposits.has(jobId))
+            throw new errors_1.MarketError('DEPOSIT_IN_PROGRESS', 'A deposit for this job is already running on this client.');
+        this.deposits.add(jobId);
+        try {
+            return await (0, deposit_1.depositJob)(this.rt, jobId, options, (id, s) => this.cardAt(id, s), this.depositCheckpoints);
+        }
+        finally {
+            this.deposits.delete(jobId);
+        }
+    }
+    agent = {
+        card: async () => {
+            const d = (0, runtime_1.deployment)(this.rt);
+            const s = await (0, runtime_1.snapshot)(this.rt);
+            const n = await s.read(d.marketplace, UniversalMarketplace_1.MARKETPLACE_ABI, 'agentCardOf', [
+                this.rt.agw.signerPushAccount(),
+            ]);
+            return n ? this.cardAt(n, s) : undefined;
+        },
+        register: async (card, options) => this.cardWrite(undefined, card, options),
+        update: async (cardId, card, options) => this.cardWrite(cardId, card, options),
+        setActive: async (cardId, active, options = {}) => {
+            const card = await this.summaryAt(cardId, await (0, runtime_1.snapshot)(this.rt));
+            this.assertProvider(card);
+            const d = (0, runtime_1.deployment)(this.rt);
+            return (0, runtime_1.write)(this.rt, {
+                target: d.marketplace,
+                value: BigInt(0),
+                data: (0, viem_1.encodeFunctionData)({
+                    abi: UniversalMarketplace_1.MARKETPLACE_ABI,
+                    functionName: 'setAgentCardActive',
+                    args: [cardId, active],
+                }),
+            }, options.progressHook, 'MARKET', true);
+        },
+    };
+    assertProvider(card) {
+        if ((0, viem_1.getAddress)(card.provider) !== (0, viem_1.getAddress)(this.rt.agw.signerPushAccount()))
+            throw new errors_1.MarketError('NOT_CARD_PROVIDER', 'Connect the provider that registered this card.');
+    }
+    async cardWrite(cardId, card, options) {
+        const d = (0, runtime_1.deployment)(this.rt);
+        card = { ...card };
+        options = { ...options };
+        const rules = (0, rules_1.encodeAgentCardRules)(options.rules, {
+            chain: card.chain,
+            network: this.rt.agw.network,
+        });
+        const template = (0, codec_1.encodeJobSpec)(options.jobSpecTemplate);
+        const mutability = options.jobSpecTemplate.allowedMutability;
+        const s = await (0, runtime_1.snapshot)(this.rt);
+        if (!card.jobType ||
+            !/^eip155:[1-9]\d*$/.test(card.chain) ||
+            !card.metadataURI ||
+            !/^0x[\da-f]{64}$/i.test(card.metadataHash) ||
+            /^0x0{64}$/i.test(card.metadataHash))
+            throw new errors_1.MarketError('INVALID_AGENT_CARD', 'Supply a job type, EVM execution chain, metadata URI and nonzero metadata hash.');
+        for (const v of [card.providerFee, card.principalMin, card.principalMax])
+            if (typeof v !== 'bigint' ||
+                v < BigInt(0) ||
+                v >= BigInt(1) << BigInt(256))
+                throw new errors_1.MarketError('INVALID_AGENT_CARD', 'Card amounts must fit uint256.');
+        if (card.principalMax === BigInt(0) ||
+            card.principalMin > card.principalMax ||
+            [
+                card.minDuration,
+                card.maxDuration,
+                card.minExecuteWindow,
+                card.settleWindow,
+            ].some((n) => !Number.isInteger(n) || n < 0 || n > 0xffffffff) ||
+            card.minDuration < 3600 ||
+            card.minDuration > card.maxDuration ||
+            card.settleWindow < 1 ||
+            card.minExecuteWindow + card.settleWindow > card.maxDuration)
+            throw new errors_1.MarketError('INVALID_AGENT_CARD', 'The principal or duration ranges are invalid.');
+        if (cardId !== undefined) {
+            const current = await this.summaryAt(cardId, s);
+            this.assertProvider(current);
+            if (current.chain !== card.chain)
+                throw new errors_1.MarketError('CARD_IDENTITY_IMMUTABLE', 'An existing card cannot change its execution chain.');
+        }
+        if (mutability !== 'NONE')
+            (0, errors_1.unavailable)('Mutable marketplace criteria');
+        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', 'This deployment accepts only the kernel payment token.');
+        const { chain, ...input } = card;
+        const jobType = /^0x[\da-f]{64}$/i.test(card.jobType)
+            ? card.jobType
+            : (0, viem_1.keccak256)((0, viem_1.stringToHex)(card.jobType));
+        const c = {
+            ...input,
+            jobType,
+            chainNamespace: chain,
+            provider: this.rt.agw.signerPushAccount(),
+            active: true,
+        };
+        const data = cardId === undefined
+            ? (0, viem_1.encodeFunctionData)({
+                abi: UniversalMarketplace_1.MARKETPLACE_ABI,
+                functionName: 'registerAgentCard',
+                args: [c, rules, template],
+            })
+            : (0, viem_1.encodeFunctionData)({
+                abi: UniversalMarketplace_1.MARKETPLACE_ABI,
+                functionName: 'updateAgentCard',
+                args: [cardId, c, rules, template],
+            });
+        if (this.rt.agw.reader.call) {
+            try {
+                await this.rt.agw.reader.call({
+                    to: d.marketplace,
+                    data,
+                    account: this.rt.agw.signerPushAccount(),
+                });
+            }
+            catch (cause) {
+                throw new errors_1.MarketError('CARD_SIMULATION_FAILED', 'The card write failed contract simulation. No transaction was submitted.', { contractError: (0, errors_1.stackError)(cause) }, cause);
+            }
+        }
+        const tx = await (0, runtime_1.write)(this.rt, { target: d.marketplace, value: BigInt(0), data }, options.progressHook, 'MARKET', true);
+        const e = await (0, runtime_1.eventArgs)(this.rt, tx, d.marketplace, UniversalMarketplace_1.MARKETPLACE_ABI, cardId === undefined ? 'AgentCardRegistered' : 'AgentCardUpdated');
+        return {
+            cardId: e['cardId'],
+            version: cardId === undefined ? BigInt(1) : e['version'],
+            tx,
+        };
+    }
+}
+exports.MarketNamespaceImpl = MarketNamespaceImpl;
+//# sourceMappingURL=market.js.map