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

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

@@ -0,0 +1,106 @@
+import { type Address, type Hex } from 'viem';
+import type { MoveableToken } from '../constants/tokens';
+import { PUSH_NETWORK } from '../constants/enums';
+import { type AssetCapWire, type AllowedCallWire, type UniversalTermsWire } from '../agentic/codec/universal-terms';
+import type { ArgumentPath, WalletMarker } from '../agentic/agentic.types';
+import type { PrincipalMarker } from '../job-spec/types';
+export type MarketAssetToken = MoveableToken | string | {
+    prc20: Address;
+};
+export type MarketPin = {
+    arg: ArgumentPath;
+    expected: Hex | Address | bigint | boolean | WalletMarker | PrincipalMarker;
+    max?: never;
+} | {
+    arg: ArgumentPath;
+    max: bigint | PrincipalMarker;
+    expected?: never;
+};
+export interface AgentCardRules {
+    assets: {
+        token: MarketAssetToken;
+        maxPerCall: bigint | PrincipalMarker;
+        maxTotal?: bigint | PrincipalMarker;
+    }[];
+    principalAsset: number;
+    maxGasPerCall: bigint;
+    allowedCalls: {
+        target: Address;
+        selector: string;
+        pins?: MarketPin[];
+        maxValue?: bigint;
+    }[];
+}
+export interface CardRulesWire {
+    assets: readonly AssetCapWire[];
+    principalAsset: number;
+    maxGasPerCall: bigint;
+    allowedCalls: readonly AllowedCallWire[];
+}
+export declare const MARKER_WALLET: `0x${string}`;
+export declare const MARKER_PRINCIPAL: `0x${string}`;
+export declare const CARD_RULES_PARAM: {
+    readonly type: "tuple";
+    readonly components: readonly [{
+        readonly name: "assets";
+        readonly type: "tuple[]";
+        readonly components: readonly [{
+            readonly name: "token";
+            readonly type: "address";
+        }, {
+            readonly name: "maxPerCall";
+            readonly type: "uint256";
+        }, {
+            readonly name: "maxTotal";
+            readonly type: "uint256";
+        }];
+    }, {
+        readonly name: "principalAsset";
+        readonly type: "uint8";
+    }, {
+        readonly name: "maxGasPerCall";
+        readonly type: "uint256";
+    }, {
+        readonly name: "allowedCalls";
+        readonly type: "tuple[]";
+        readonly components: readonly [{
+            readonly name: "target";
+            readonly type: "address";
+        }, {
+            readonly name: "selector";
+            readonly type: "bytes4";
+        }, {
+            readonly name: "beneficiaryOffset";
+            readonly type: "uint16";
+        }, {
+            readonly name: "hasBeneficiary";
+            readonly type: "bool";
+        }, {
+            readonly name: "maxValue";
+            readonly type: "uint256";
+        }, {
+            readonly name: "pins";
+            readonly type: "tuple[]";
+            readonly components: readonly [{
+                readonly name: "offset";
+                readonly type: "uint16";
+            }, {
+                readonly name: "op";
+                readonly type: "uint8";
+            }, {
+                readonly name: "value";
+                readonly type: "bytes32";
+            }];
+        }];
+    }];
+};
+export declare function validateAgentCardRules(rules: AgentCardRules): void;
+export declare function encodeAgentCardRules(rules: AgentCardRules, options: {
+    chain: string;
+    network?: PUSH_NETWORK;
+}): Hex;
+export declare function decodeCardRulesWire(bytes: Hex): CardRulesWire;
+export declare function decodeAgentCardRules(bytes: Hex, _options?: {
+    chain?: string;
+}): AgentCardRules;
+export declare function fillCardRules(r: CardRulesWire, principal: bigint, wallet: Address, expiredAt: number): UniversalTermsWire;

package/src/lib/market/rules.js

@@ -0,0 +1,293 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CARD_RULES_PARAM = exports.MARKER_PRINCIPAL = exports.MARKER_WALLET = void 0;
+exports.validateAgentCardRules = validateAgentCardRules;
+exports.encodeAgentCardRules = encodeAgentCardRules;
+exports.decodeCardRulesWire = decodeCardRulesWire;
+exports.decodeAgentCardRules = decodeAgentCardRules;
+exports.fillCardRules = fillCardRules;
+const viem_1 = require("viem");
+const enums_1 = require("../constants/enums");
+const prc20_address_1 = require("../universal/prc20-address");
+const abi_layout_1 = require("../agentic/codec/abi-layout");
+const selectors_1 = require("../agentic/codec/selectors");
+const pins_1 = require("../agentic/codec/pins");
+const universal_terms_1 = require("../agentic/codec/universal-terms");
+const constants_1 = require("../job-spec/constants");
+const errors_1 = require("./errors");
+exports.MARKER_WALLET = (0, viem_1.keccak256)((0, viem_1.stringToHex)('push.marketplace.marker.WALLET'));
+exports.MARKER_PRINCIPAL = (0, viem_1.keccak256)((0, viem_1.stringToHex)('push.marketplace.marker.PRINCIPAL'));
+const PRINCIPAL_WORD = BigInt(exports.MARKER_PRINCIPAL);
+const decodedRules = new WeakMap();
+const fingerprint = (r) => JSON.stringify(r, (_, v) => (typeof v === 'bigint' ? v.toString() : v));
+const fields = universal_terms_1.UNIVERSAL_TERMS_PARAM.components;
+exports.CARD_RULES_PARAM = {
+    type: 'tuple',
+    components: [
+        fields[2],
+        { name: 'principalAsset', type: 'uint8' },
+        fields[3],
+        fields[4],
+    ],
+};
+const bad = (message) => {
+    throw new errors_1.MarketError('INVALID_AGENT_CARD_RULES', message);
+};
+function cap(n) {
+    const v = n === constants_1.PRINCIPAL ? PRINCIPAL_WORD : n ?? BigInt(0);
+    if (typeof v !== 'bigint' || v < BigInt(0) || v >= BigInt(1) << BigInt(256))
+        bad('Spending caps must fit uint256.');
+    return v;
+}
+function toWire(input, options) {
+    if (!input ||
+        !Array.isArray(input.assets) ||
+        !Array.isArray(input.allowedCalls))
+        bad('Card rules need assets and allowedCalls arrays.');
+    const saved = decodedRules.get(input);
+    if (saved?.fingerprint === fingerprint(input))
+        return saved.wire;
+    if ('approvals' in input)
+        bad('V2 approvals belong in allowedCalls with spender and amount pins; remove the retired approvals array.');
+    if (input.assets.some((a) => typeof a.token === 'object' &&
+        'prc20' in a.token &&
+        /^0x0{40}$/i.test(a.token.prc20)))
+        bad('An explicit PRC20 reference cannot be zero.');
+    const assets = input.assets.map((a) => ({
+        token: typeof a.token === 'object' && 'prc20' in a.token
+            ? (0, viem_1.getAddress)(a.token.prc20)
+            : (() => {
+                if (options?.structural)
+                    return (0, viem_1.getAddress)(typeof a.token === 'string' ? a.token : a.token.address);
+                if (!options?.chain)
+                    return bad('Encoding destination tokens needs the card chain, or an explicit { prc20 } reference.');
+                try {
+                    return (0, prc20_address_1.getPRC20Address)({
+                        chain: options.chain,
+                        address: typeof a.token === 'string' ? a.token : a.token.address,
+                    }, { network: options.network ?? enums_1.PUSH_NETWORK.TESTNET_DONUT }).address;
+                }
+                catch (cause) {
+                    throw new errors_1.MarketError('TOKEN_ROUTE_UNAVAILABLE', 'This card token has no verified Push route for the selected chain.', { chain: options.chain, token: a.token }, cause);
+                }
+            })(),
+        maxPerCall: cap(a.maxPerCall),
+        maxTotal: cap(a.maxTotal),
+    }));
+    const allowedCalls = input.allowedCalls.map((call) => {
+        const parsed = (0, selectors_1.parseSelector)(call.selector);
+        if (parsed.valueOnly)
+            bad('Marketplace cards support EVM function calls, not Push value-only rules.');
+        const pins = (call.pins ?? []).map((p) => {
+            const location = parsed.inputs
+                ? (0, abi_layout_1.argumentLocation)(parsed.inputs, p.arg, 'Card pin')
+                : {
+                    offset: typeof p.arg === 'number' && Number.isInteger(p.arg) && p.arg >= 0
+                        ? 4 + p.arg * 32
+                        : bad('Raw selector pins need a nonnegative integer word index.'),
+                    param: { type: 'uint256' },
+                };
+            const max = 'max' in p && p.max !== undefined;
+            const value = 'max' in p && p.max !== undefined ? p.max : p.expected;
+            if (value === undefined)
+                return bad('A card pin needs expected or max.');
+            if (value === 'agentic:wallet' && max)
+                bad('WALLET is supported only in equality pins.');
+            const encoded = value === 'agentic:wallet'
+                ? exports.MARKER_WALLET
+                : value === constants_1.PRINCIPAL
+                    ? exports.MARKER_PRINCIPAL
+                    : max
+                        ? (0, viem_1.toHex)(cap(value), { size: 32 })
+                        : (0, abi_layout_1.encodeArgWord)(location.param, value, 'Card pin');
+            return {
+                offset: location.offset,
+                op: max ? 1 : 0,
+                value: encoded,
+            };
+        });
+        return {
+            target: (0, viem_1.getAddress)(call.target),
+            selector: parsed.selector,
+            beneficiaryOffset: 0,
+            hasBeneficiary: false,
+            maxValue: cap(call.maxValue),
+            pins,
+        };
+    });
+    const wire = {
+        assets,
+        principalAsset: input.principalAsset,
+        maxGasPerCall: cap(input.maxGasPerCall),
+        allowedCalls,
+    };
+    validateWire(wire, !!options?.structural);
+    return wire;
+}
+function validateWire(r, structural = false) {
+    if (!Array.isArray(r.assets) || r.assets.length < 1 || r.assets.length > 8)
+        bad('Cards need 1..8 assets.');
+    if (!Number.isInteger(r.principalAsset) ||
+        r.principalAsset < 0 ||
+        r.principalAsset >= r.assets.length)
+        bad('principalAsset is outside the asset list.');
+    const tokens = new Set();
+    r.assets.forEach((a, i) => {
+        if (!(0, viem_1.isAddress)(a.token) ||
+            (!structural && /^0x0{40}$/i.test(a.token)) ||
+            tokens.has(a.token.toLowerCase()))
+            bad('Assets need distinct nonzero PRC20 addresses.');
+        tokens.add(a.token.toLowerCase());
+        cap(a.maxPerCall);
+        cap(a.maxTotal);
+        if (i === r.principalAsset) {
+            if (a.maxTotal !== PRINCIPAL_WORD || a.maxPerCall === BigInt(0))
+                bad('The principal total must be PRINCIPAL and its per-call cap must be positive or PRINCIPAL.');
+        }
+        else if (a.maxPerCall === PRINCIPAL_WORD || a.maxTotal === PRINCIPAL_WORD)
+            bad('PRINCIPAL asset-cap markers belong only on the principal asset.');
+    });
+    cap(r.maxGasPerCall);
+    if (!Array.isArray(r.allowedCalls) ||
+        r.allowedCalls.length < 1 ||
+        r.allowedCalls.length > 32)
+        bad('Cards need 1..32 allowed calls.');
+    if (r.allowedCalls.reduce((n, c) => n + c.pins.length, 0) > 32)
+        bad('A card rule supports at most 32 conditions.');
+    const entries = new Set();
+    const pairs = new Map();
+    for (const c of r.allowedCalls) {
+        if (!(0, viem_1.isAddress)(c.target) ||
+            /^0x0{40}$/i.test(c.target) ||
+            !/^0x[\da-f]{8}$/i.test(c.selector))
+            bad('An allowed app or selector is invalid.');
+        cap(c.maxValue);
+        try {
+            (0, pins_1.validatePins)(c.pins);
+        }
+        catch (cause) {
+            throw new errors_1.MarketError('INVALID_AGENT_CARD_RULES', 'An allowed call has invalid argument conditions.', undefined, cause);
+        }
+        if (c.hasBeneficiary &&
+            (c.beneficiaryOffset < 4 || (c.beneficiaryOffset - 4) % 32 !== 0))
+            bad('Invalid recipient offset.');
+        for (const p of c.pins)
+            if (p.value === exports.MARKER_WALLET && p.op !== 0)
+                bad('WALLET pins must use equality.');
+        const encoded = (0, viem_1.encodeAbiParameters)([{ ...fields[4], type: 'tuple' }], [c]);
+        if (entries.has(encoded))
+            bad('Duplicate allowed call.');
+        entries.add(encoded);
+        const key = `${c.target.toLowerCase()}:${c.selector.toLowerCase()}`;
+        if (pairs.has(key) && (!pairs.get(key) || !c.pins.length))
+            bad('An unpinned alternative would bypass the pinned call.');
+        pairs.set(key, c.pins.length > 0);
+        const pin = (offset, op) => c.pins.find((p) => p.offset === offset && p.op === op);
+        const recipient = (offset) => (c.hasBeneficiary && c.beneficiaryOffset === offset) ||
+            pin(offset, 0)?.value === exports.MARKER_WALLET;
+        if (c.selector === '0x39509351')
+            bad('increaseAllowance is not supported in cards.');
+        if (c.selector === '0x095ea7b3') {
+            const spender = pin(4, 0)?.value;
+            if (!spender ||
+                BigInt(spender) === BigInt(0) ||
+                BigInt(spender) >> BigInt(160) !== BigInt(0))
+                bad('approve needs an EQ pin to a nonzero literal spender.');
+            if (!pin(36, 1))
+                bad('approve needs a MAX amount pin.');
+        }
+        if (c.selector === '0xa9059cbb' && !recipient(4))
+            bad('transfer must pin its recipient to WALLET.');
+        if (c.selector === '0x23b872dd' && !recipient(36))
+            bad('transferFrom must pin its recipient to WALLET.');
+    }
+}
+function validateAgentCardRules(rules) {
+    toWire(rules, { structural: true });
+}
+function encodeAgentCardRules(rules, options) {
+    return (0, viem_1.encodeAbiParameters)([exports.CARD_RULES_PARAM], [toWire(rules, options)]);
+}
+function decodeCardRulesWire(bytes) {
+    try {
+        const wire = (0, viem_1.decodeAbiParameters)([exports.CARD_RULES_PARAM], bytes)[0];
+        validateWire(wire);
+        if ((0, viem_1.encodeAbiParameters)([exports.CARD_RULES_PARAM], [wire]).toLowerCase() !==
+            bytes.toLowerCase())
+            bad('Noncanonical card rules.');
+        return wire;
+    }
+    catch (cause) {
+        if (cause instanceof errors_1.MarketError)
+            throw cause;
+        throw new errors_1.MarketError('INVALID_AGENT_CARD_RULES', 'Unsupported or malformed v2 card-rule encoding.', undefined, cause);
+    }
+}
+function decodeAgentCardRules(bytes, _options) {
+    void _options;
+    const r = decodeCardRulesWire(bytes);
+    // Explicit PRC20 references make unknown/custom registry tokens lossless and unambiguous.
+    const result = {
+        ...r,
+        assets: r.assets.map((a) => ({
+            token: { prc20: a.token },
+            maxPerCall: a.maxPerCall === PRINCIPAL_WORD ? constants_1.PRINCIPAL : a.maxPerCall,
+            maxTotal: a.maxTotal === PRINCIPAL_WORD ? constants_1.PRINCIPAL : a.maxTotal,
+        })),
+        allowedCalls: r.allowedCalls.map((c) => ({
+            target: c.target,
+            selector: c.selector,
+            maxValue: c.maxValue,
+            pins: [
+                ...c.pins.map((p) => {
+                    const value = p.value === exports.MARKER_WALLET
+                        ? 'agentic:wallet'
+                        : p.value === exports.MARKER_PRINCIPAL
+                            ? constants_1.PRINCIPAL
+                            : p.value;
+                    return p.op === 1
+                        ? {
+                            arg: (p.offset - 4) / 32,
+                            max: value === constants_1.PRINCIPAL ? constants_1.PRINCIPAL : BigInt(p.value),
+                        }
+                        : { arg: (p.offset - 4) / 32, expected: value };
+                }),
+                ...(c.hasBeneficiary
+                    ? [
+                        {
+                            arg: (c.beneficiaryOffset - 4) / 32,
+                            expected: 'agentic:wallet',
+                        },
+                    ]
+                    : []),
+            ],
+        })),
+    };
+    decodedRules.set(result, { fingerprint: fingerprint(result), wire: r });
+    return result;
+}
+function fillCardRules(r, principal, wallet, expiredAt) {
+    const walletWord = (0, viem_1.toHex)(BigInt(wallet), { size: 32 });
+    return {
+        validUntil: expiredAt,
+        expectedCEA: wallet,
+        assets: r.assets.map((a, i) => ({
+            ...a,
+            maxPerCall: a.maxPerCall === PRINCIPAL_WORD ? principal : a.maxPerCall,
+            maxTotal: i === r.principalAsset ? principal : a.maxTotal,
+        })),
+        maxGasPerCall: r.maxGasPerCall,
+        allowedCalls: r.allowedCalls.map((c) => ({
+            ...c,
+            pins: c.pins.map((p) => ({
+                ...p,
+                value: p.value === exports.MARKER_WALLET
+                    ? walletWord
+                    : p.value === exports.MARKER_PRINCIPAL
+                        ? (0, viem_1.toHex)(principal, { size: 32 })
+                        : p.value,
+            })),
+        })),
+    };
+}
+//# sourceMappingURL=rules.js.map

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

@@ -0,0 +1,35 @@
+import { type Abi, type Address, type TypedData, type TypedDataDomain } from 'viem';
+import type { AgenticRuntime } from '../agentic/runtime';
+import type { Call } from '../agentic/contracts/v6';
+import type { ExecuteParams, TransactionExecutionOptions, UniversalExecuteParams, UniversalTxResponse } from '../orchestrator/orchestrator.types';
+import type { ProgressEvent } from '../progress-hook/progress-hook.types';
+import { type MarketDeployment } from './deployment';
+export type StackProgressHook = (event: ProgressEvent) => void;
+export interface StackRuntime {
+    agw: AgenticRuntime;
+    account(): Address;
+    wallet(): Address | undefined;
+    send(params: ExecuteParams | UniversalExecuteParams, options?: TransactionExecutionOptions): Promise<UniversalTxResponse>;
+    signTypedData(data: {
+        domain: TypedDataDomain;
+        types: TypedData;
+        primaryType: string;
+        message: Record<string, unknown>;
+    }): Promise<string>;
+    canSignTypedData?(): boolean;
+    /** Internal fixture override; never a public initialization option. */
+    deployment?: MarketDeployment;
+    /** Receipt-confirmed creation blocks accelerate bounded event recovery. */
+    jobBlocks?: Map<bigint, bigint>;
+}
+export declare function deployment(rt: StackRuntime): MarketDeployment;
+export interface MarketSnapshot {
+    blockNumber: bigint;
+    timestamp: number;
+    read<T>(address: Address, abi: Abi, name: string, args?: readonly unknown[]): Promise<T>;
+}
+export declare function snapshot(rt: StackRuntime, atBlock?: bigint): Promise<MarketSnapshot>;
+export declare function progress(rt: StackRuntime, hook: StackProgressHook | undefined, id: string, message: string, response?: object): void;
+export declare function write(rt: StackRuntime, call: Call, hook: StackProgressHook | undefined, family: 'MARKET' | 'JOB', signer?: boolean): Promise<UniversalTxResponse>;
+export declare function ownerBatch(rt: StackRuntime, wallet: Address, calls: Call[], hook?: StackProgressHook): Promise<UniversalTxResponse>;
+export declare function eventArgs(rt: StackRuntime, tx: UniversalTxResponse, address: Address, abi: Abi, name: string): Promise<Record<string, unknown>>;

package/src/lib/market/runtime.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployment = deployment;
+exports.snapshot = snapshot;
+exports.progress = progress;
+exports.write = write;
+exports.ownerBatch = ownerBatch;
+exports.eventArgs = eventArgs;
+const viem_1 = require("viem");
+const common_1 = require("../agentic/management/common");
+const deployments_1 = require("../agentic/deployments");
+const errors_1 = require("./errors");
+const deployment_1 = require("./deployment");
+function deployment(rt) {
+    return rt.deployment ?? (0, deployment_1.marketplaceDeployment)(rt.agw.network);
+}
+async function snapshot(rt, atBlock) {
+    const blockNumber = atBlock ?? (await rt.agw.reader.getBlockNumber());
+    const timestamp = rt.agw.reader.getBlock
+        ? Number((await rt.agw.reader.getBlock({ blockNumber })).timestamp)
+        : rt.agw.nowSeconds();
+    return {
+        blockNumber,
+        timestamp,
+        read: async (address, abi, name, args = []) => {
+            try {
+                return (await rt.agw.reader.readContract({
+                    address,
+                    abi,
+                    functionName: name,
+                    args,
+                    blockNumber,
+                }));
+            }
+            catch (cause) {
+                throw new errors_1.MarketError('READ_FAILED', `Could not load ${name} at block ${blockNumber}.`, { address, functionName: name, blockNumber }, cause);
+            }
+        },
+    };
+}
+function progress(rt, hook, id, message, response = {}) {
+    rt.agw.emit({
+        id,
+        title: message,
+        message,
+        level: id.endsWith('199-02') ? 'ERROR' : 'INFO',
+        response,
+        timestamp: new Date().toISOString(),
+    }, hook);
+}
+async function write(rt, call, hook, family, signer = false) {
+    if (rt.agw.isReadOnly)
+        throw new errors_1.MarketError('READ_ONLY', 'Connect a signing wallet to continue.');
+    progress(rt, hook, `${family}-TX-103`, 'Submitting transaction');
+    try {
+        const tx = await (signer
+            ? rt.agw.execute({ to: call.target, value: call.value, data: call.data }, { progressHook: hook })
+            : rt.send({ to: call.target, value: call.value, data: call.data }, { progressHook: hook }));
+        const originalWait = tx.wait.bind(tx);
+        let terminalReported = false;
+        const wait = async (...args) => {
+            try {
+                const receipt = await originalWait(...args);
+                if (!terminalReported) {
+                    terminalReported = true;
+                    progress(rt, hook, `${family}-TX-199-${receipt.status === 1 ? '01' : '02'}`, receipt.status === 1
+                        ? 'Transaction confirmed'
+                        : 'Transaction reverted', { txHash: tx.hash });
+                }
+                return receipt;
+            }
+            catch (error) {
+                progress(rt, hook, `${family}-TX-199-02`, 'Transaction confirmation unavailable', { txHash: tx.hash });
+                throw error;
+            }
+        };
+        return { ...tx, wait };
+    }
+    catch (error) {
+        const wrapped = (0, errors_1.stackError)(error);
+        progress(rt, hook, `${family}-TX-199-02`, 'Transaction failed', {
+            error: wrapped,
+        });
+        throw wrapped;
+    }
+}
+async function ownerBatch(rt, wallet, calls, hook) {
+    const gen = (0, deployments_1.currentGeneration)(rt.agw.network);
+    const s = await snapshot(rt);
+    const owner = (0, viem_1.getAddress)(await s.read(wallet, gen.contracts.abis.wallet, 'owner'));
+    if (owner !== (0, viem_1.getAddress)(rt.agw.signerPushAccount()))
+        throw new errors_1.MarketError('NOT_CLIENT', 'Connect the owner of the job wallet.');
+    return write(rt, {
+        target: wallet,
+        value: BigInt(0),
+        data: gen.contracts.encodeExecute(calls),
+    }, hook, 'JOB', true);
+}
+async function eventArgs(rt, tx, address, abi, name) {
+    const result = await (0, common_1.confirmedLogs)(rt.agw, tx);
+    const found = [];
+    for (const log of result.logs) {
+        if (log.address.toLowerCase() !== address.toLowerCase())
+            continue;
+        try {
+            const e = (0, viem_1.decodeEventLog)({
+                abi,
+                eventName: name,
+                data: log.data,
+                topics: log.topics,
+                strict: true,
+            });
+            if (e.eventName === name) {
+                found.push(e.args);
+                const args = e.args;
+                if ((name === 'JobCreated' || name === 'JobOpened') &&
+                    typeof args['jobId'] === 'bigint' &&
+                    log.blockNumber !== null)
+                    rt.jobBlocks?.set(args['jobId'], log.blockNumber);
+            }
+        }
+        catch {
+            /* Other contract events are expected in a receipt. */
+        }
+    }
+    if (found.length !== 1)
+        throw new errors_1.MarketError('RECEIPT_MISMATCH', `The submitted transaction did not produce one ${name} event.`, { txHash: tx.hash });
+    return found[0];
+}
+//# sourceMappingURL=runtime.js.map