pmxt-core 2.50.16 → 2.51.1

package/dist/exchanges/hunch/auth.d.ts

@@ -0,0 +1,36 @@
+import { ExchangeCredentials } from '../../BaseExchange';
+import { type LocalAccount } from 'viem';
+export interface HunchCredentials extends ExchangeCredentials {
+    /** EOA private key that pays the x402 USDC authorization (Base). */
+    privateKey?: string;
+    /** Wallet address for keyless reads (positions/balance). Derived from
+     *  `privateKey` when present; required on its own for read-only use. */
+    walletAddress?: string;
+    /** Optional base URL override (defaults to https://www.playhunch.xyz). */
+    baseUrl?: string;
+}
+/**
+ * Hunch auth holder.
+ *
+ * Reads are KEYLESS — `getHeaders()` returns only a JSON content type, and the
+ * read methods that need a wallet (positions/balance) take the address as a
+ * query param, not an auth header.
+ *
+ * The money path (createOrder) signs an EIP-3009 `transferWithAuthorization`
+ * with the wallet's viem `LocalAccount`, obtained lazily from `privateKey`.
+ */
+export declare class HunchAuth {
+    private readonly credentials;
+    private account?;
+    constructor(credentials: HunchCredentials);
+    /** Reads carry no auth — the wallet IS the account (passed as a param). */
+    getHeaders(): Record<string, string>;
+    /** The wallet address (explicit, or derived from the private key). */
+    get walletAddress(): string | undefined;
+    get hasSigner(): boolean;
+    /** Lazily build (and cache) the viem account that signs the x402 payment. */
+    getAccount(): LocalAccount;
+    requireWalletAddress(method: string): string;
+    private deriveAddress;
+    private normalizePk;
+}

package/dist/exchanges/hunch/auth.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HunchAuth = void 0;
+const errors_1 = require("../../errors");
+const accounts_1 = require("viem/accounts");
+/**
+ * Hunch auth holder.
+ *
+ * Reads are KEYLESS — `getHeaders()` returns only a JSON content type, and the
+ * read methods that need a wallet (positions/balance) take the address as a
+ * query param, not an auth header.
+ *
+ * The money path (createOrder) signs an EIP-3009 `transferWithAuthorization`
+ * with the wallet's viem `LocalAccount`, obtained lazily from `privateKey`.
+ */
+class HunchAuth {
+    credentials;
+    account;
+    constructor(credentials) {
+        this.credentials = credentials;
+    }
+    /** Reads carry no auth — the wallet IS the account (passed as a param). */
+    getHeaders() {
+        return { 'Content-Type': 'application/json' };
+    }
+    /** The wallet address (explicit, or derived from the private key). */
+    get walletAddress() {
+        if (this.credentials.walletAddress)
+            return this.credentials.walletAddress;
+        const derived = this.deriveAddress();
+        return derived;
+    }
+    get hasSigner() {
+        return !!this.credentials.privateKey;
+    }
+    /** Lazily build (and cache) the viem account that signs the x402 payment. */
+    getAccount() {
+        if (this.account)
+            return this.account;
+        if (!this.credentials.privateKey) {
+            throw new errors_1.AuthenticationError('Placing a real Hunch bet requires a privateKey to sign the x402 USDC ' +
+                'payment. Initialize HunchExchange with { privateKey }.', 'Hunch');
+        }
+        this.account = (0, accounts_1.privateKeyToAccount)(this.normalizePk(this.credentials.privateKey));
+        return this.account;
+    }
+    requireWalletAddress(method) {
+        const addr = this.walletAddress;
+        if (!addr) {
+            throw new errors_1.AuthenticationError(`${method} requires a wallet address. Pass { walletAddress } or { privateKey } in credentials.`, 'Hunch');
+        }
+        return addr;
+    }
+    deriveAddress() {
+        if (!this.credentials.privateKey)
+            return undefined;
+        return (0, accounts_1.privateKeyToAccount)(this.normalizePk(this.credentials.privateKey)).address;
+    }
+    normalizePk(pk) {
+        return (pk.startsWith('0x') ? pk : `0x${pk}`);
+    }
+}
+exports.HunchAuth = HunchAuth;

package/dist/exchanges/hunch/errors.d.ts

@@ -0,0 +1,26 @@
+import { ErrorMapper } from '../../utils/error-mapper';
+import { BadRequest } from '../../errors';
+/**
+ * Maps Hunch agent-API error bodies to pmxt unified errors.
+ *
+ * Hunch follows an "errors-as-documentation" convention: every 4xx/5xx carries
+ * `{ error, message, hint?, docsUrl?, retriable? }` where `error` is a STABLE
+ * machine code (the AGENT_ERROR_CODES catalogue). We branch on that code first
+ * (precise), then fall back to the base mapper's status-code routing.
+ *
+ * Catalogue (src/agent/errors.ts): invalid_wallet, invalid_request,
+ * market_not_found, market_closed, market_resolved, invalid_side,
+ * size_below_min, size_above_simple_tier, quote_required, quote_expired,
+ * quote_mismatch, slippage_exceeded, insufficient_balance, payment_required,
+ * payment_invalid, pool_impact_exceeded, trading_paused, rate_limited,
+ * internal_error.
+ */
+export declare class HunchErrorMapper extends ErrorMapper {
+    constructor();
+    mapError(error: unknown): ReturnType<ErrorMapper['mapError']>;
+    protected extractErrorMessage(error: unknown): string;
+    protected mapBadRequestError(message: string, data: unknown): BadRequest;
+    /** Pull Hunch's stable machine code out of the response body. */
+    private extractCode;
+}
+export declare const hunchErrorMapper: HunchErrorMapper;

package/dist/exchanges/hunch/errors.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hunchErrorMapper = exports.HunchErrorMapper = void 0;
+const axios_1 = __importDefault(require("axios"));
+const error_mapper_1 = require("../../utils/error-mapper");
+const errors_1 = require("../../errors");
+/**
+ * Maps Hunch agent-API error bodies to pmxt unified errors.
+ *
+ * Hunch follows an "errors-as-documentation" convention: every 4xx/5xx carries
+ * `{ error, message, hint?, docsUrl?, retriable? }` where `error` is a STABLE
+ * machine code (the AGENT_ERROR_CODES catalogue). We branch on that code first
+ * (precise), then fall back to the base mapper's status-code routing.
+ *
+ * Catalogue (src/agent/errors.ts): invalid_wallet, invalid_request,
+ * market_not_found, market_closed, market_resolved, invalid_side,
+ * size_below_min, size_above_simple_tier, quote_required, quote_expired,
+ * quote_mismatch, slippage_exceeded, insufficient_balance, payment_required,
+ * payment_invalid, pool_impact_exceeded, trading_paused, rate_limited,
+ * internal_error.
+ */
+class HunchErrorMapper extends error_mapper_1.ErrorMapper {
+    constructor() {
+        super('Hunch');
+    }
+    mapError(error) {
+        const code = this.extractCode(error);
+        const message = this.extractErrorMessage(error);
+        if (code) {
+            switch (code) {
+                case 'insufficient_balance':
+                    return new errors_1.InsufficientFunds(message, this.exchangeName);
+                case 'invalid_side':
+                case 'size_below_min':
+                case 'size_above_simple_tier':
+                case 'quote_required':
+                case 'quote_expired':
+                case 'quote_mismatch':
+                case 'slippage_exceeded':
+                case 'pool_impact_exceeded':
+                    return new errors_1.InvalidOrder(message, this.exchangeName);
+                case 'market_not_found':
+                    return new errors_1.NotFound(`Market not found: ${message}`, this.exchangeName);
+                // market_closed / market_resolved / trading_paused / payment_* /
+                // invalid_wallet / invalid_request / rate_limited / internal_error
+                // fall through to the status-code base mapping below.
+                default:
+                    break;
+            }
+        }
+        return super.mapError(error);
+    }
+    extractErrorMessage(error) {
+        if (axios_1.default.isAxiosError(error) && error.response?.data) {
+            const data = error.response.data;
+            if (typeof data.message === 'string')
+                return data.message;
+            if (typeof data.error === 'string')
+                return data.error;
+        }
+        return super.extractErrorMessage(error);
+    }
+    mapBadRequestError(message, data) {
+        const lower = message.toLowerCase();
+        if (lower.includes('insufficient') || lower.includes('balance')) {
+            return new errors_1.InsufficientFunds(message, this.exchangeName);
+        }
+        if (lower.includes('side') || lower.includes('slippage') || lower.includes('quote')) {
+            return new errors_1.InvalidOrder(message, this.exchangeName);
+        }
+        return super.mapBadRequestError(message, data);
+    }
+    /** Pull Hunch's stable machine code out of the response body. */
+    extractCode(error) {
+        if (axios_1.default.isAxiosError(error) && error.response?.data) {
+            const data = error.response.data;
+            if (typeof data.error === 'string')
+                return data.error;
+        }
+        if (error && typeof error === 'object') {
+            const maybe = error;
+            if (maybe.body && typeof maybe.body.error === 'string')
+                return maybe.body.error;
+            if (typeof maybe.code === 'string')
+                return maybe.code;
+        }
+        return undefined;
+    }
+}
+exports.HunchErrorMapper = HunchErrorMapper;
+exports.hunchErrorMapper = new HunchErrorMapper();

package/dist/exchanges/hunch/fetcher.d.ts

@@ -0,0 +1,204 @@
+import { MarketFilterParams, EventFetchParams, OHLCVParams, TradesParams } from '../../BaseExchange';
+import { IExchangeFetcher, FetcherContext } from '../interfaces';
+export interface HunchRawOutcome {
+    key: string;
+    label: string;
+    shortLabel: string;
+    lowerUsd: number | null;
+    upperUsd: number | null;
+    startAt?: string | null;
+    endAt?: string | null;
+}
+export interface HunchRawMarketLinks {
+    app: string;
+    quote: string;
+    trade: string;
+    research: string;
+}
+export interface HunchRawMarket {
+    id: string;
+    slug: string;
+    question: string;
+    shortTitle: string;
+    summary: string;
+    category: string;
+    tokenSymbol: string;
+    chainId: string;
+    deadlineAt: string;
+    deadlineLabel: string;
+    status: string;
+    feeBps: number;
+    feeRecipientLabel: string;
+    defaultTicketUsd: number;
+    virtualLiquidityUsd: number;
+    /** Present in the schema; absent on the bare list endpoint — optional. */
+    volumeUsd?: number;
+    totalBets?: number;
+    targetMarketCapUsd: number | null;
+    outcomes: HunchRawOutcome[] | null;
+    headline?: string | null;
+    links: HunchRawMarketLinks;
+    [key: string]: unknown;
+}
+export interface HunchRawBinaryOdds {
+    yesPriceCents: number | null;
+    noPriceCents: number | null;
+}
+export interface HunchRawLadderOutcome extends HunchRawOutcome {
+    impliedPct: number;
+    backedUsd: number;
+    isCurrent: boolean;
+}
+export interface HunchRawLadder {
+    outcomes: HunchRawLadderOutcome[];
+    currentBucketKey: string | null;
+    currentMarketCapUsd: number | null;
+    totalBackedUsd: number;
+}
+export interface HunchRawTokenSnapshot {
+    tokenSymbol: string;
+    currentMarketCapUsd: number;
+    currentPriceUsd: number | null;
+    targetMarketCapUsd: number;
+    distanceToTargetPct: number;
+    reachedTarget: boolean;
+    source: string;
+    sourceUrl: string;
+    observedAt: string;
+}
+export interface HunchRawMarketStats {
+    totalBets: number;
+    totalPoolUsd: number;
+    yesPoolUsd: number;
+    noPoolUsd: number;
+    feeUsd: number;
+}
+export interface HunchRawOddsHistoryPoint {
+    at: string;
+    yesPct: number | null;
+    outcomeKey: string | null;
+    sizeUsd: number;
+}
+export interface HunchRawResearch {
+    market: HunchRawMarket;
+    resolutionRules: {
+        source: string;
+        sourceUrl: string | null;
+        metric: string;
+        comparator: string | null;
+        thresholdLabel: string | null;
+        deadlineAt: string;
+        earlyResolvable: boolean;
+        description: string;
+    };
+    odds: HunchRawBinaryOdds;
+    stats: HunchRawMarketStats | null;
+    ladder: HunchRawLadder | null;
+    tokenSnapshot: HunchRawTokenSnapshot | null;
+    oddsHistory: HunchRawOddsHistoryPoint[];
+    observations: {
+        observedAt: string;
+        value: number | null;
+        label: string | null;
+        sourceUrl: string | null;
+    }[];
+    related: {
+        id: string;
+        slug: string;
+        question: string;
+        category: string;
+        deadlineAt: string;
+    }[];
+    impact: {
+        sizeUsd: number;
+        priceCents: number | null;
+        impactPct: number | null;
+    }[];
+    [key: string]: unknown;
+}
+export interface HunchRawQuote {
+    marketId: string;
+    side: string;
+    sizeUsd: number;
+    tier: 'simple' | 'locked';
+    quoteId: string;
+    expiresAt: string;
+    bookVersion: string;
+    priceCents: number;
+    estimatedShares: number;
+    suggestedMinSharesOut: number;
+    feeBps: number;
+    feeUsd: number;
+    netStakeUsd: number;
+    postTradeOdds: HunchRawBinaryOdds;
+    impactPct: number | null;
+    ladder: HunchRawLadder | null;
+    tokenSnapshot: HunchRawTokenSnapshot | null;
+    stats: HunchRawMarketStats | null;
+    [key: string]: unknown;
+}
+export interface HunchRawPosition {
+    marketId: string;
+    slug: string;
+    question: string;
+    side: string;
+    outcomeLabel: string;
+    shares: number;
+    stakedUsd: number;
+    avgEntryCents: number;
+    currentCents: number;
+    pnlUsd: number;
+    maxPayoutUsd: number;
+    status: 'open' | 'resolved-won' | 'resolved-lost';
+    appUrl: string;
+    proofUrl: string | null;
+    filledAt: string | null;
+    [key: string]: unknown;
+}
+export interface HunchRawReadiness {
+    wallet: string;
+    usdcBalanceUsd: number | null;
+    canBetMin: boolean | null;
+    minBetUsd: number;
+    simpleTierMaxUsd: number;
+    gasNeeded: false;
+    reason: string;
+    funding: {
+        network: 'base';
+        usdcAddress: string;
+        docsUrl: string;
+    };
+    hint: string | null;
+    [key: string]: unknown;
+}
+/**
+ * HunchFetcher — raw GETs against the live agent API. Hunch reads are keyless,
+ * so we hit the HTTP client directly (clearer + more robust than the implicit
+ * `callApi` for these path/query-param GETs). The trade POST (x402 money path)
+ * is handled in index.ts createOrder, not here.
+ */
+export declare class HunchFetcher implements IExchangeFetcher<HunchRawMarket, HunchRawMarket, HunchRawPosition[]> {
+    private readonly ctx;
+    private readonly baseUrl;
+    constructor(ctx: FetcherContext, baseUrl?: string);
+    fetchRawMarkets(params?: MarketFilterParams): Promise<HunchRawMarket[]>;
+    /**
+     * Hunch has no Event tier (markets stand alone). `fetchRawEvents` returns
+     * the raw markets so the exchange can wrap each as a single-market event
+     * when the event API is used; honoring `series` by returning [].
+     */
+    fetchRawEvents(params: EventFetchParams): Promise<HunchRawMarket[]>;
+    /** Research payload — carries oddsHistory, the source for OHLCV/trades. */
+    fetchRawOHLCV(id: string, _params: OHLCVParams): Promise<HunchRawResearch>;
+    /** Quote + research drive the emulated orderbook (implied price + pool). */
+    fetchRawOrderBook(id: string): Promise<HunchRawResearch>;
+    /** oddsHistory (from research) doubles as the public trade tape. */
+    fetchRawTrades(id: string, _params: TradesParams): Promise<HunchRawOddsHistoryPoint[]>;
+    fetchRawPositions(walletAddress: string): Promise<HunchRawPosition[]>;
+    fetchRawBalance(walletAddress: string): Promise<HunchRawReadiness>;
+    fetchRawResearch(marketId: string): Promise<HunchRawResearch>;
+    fetchRawQuote(marketId: string, side: string, sizeUsd: number, wallet?: string): Promise<HunchRawQuote>;
+    private fetchRawMarketById;
+    /** outcomeId is `${marketId}:${side}`; strip the side to get the market id. */
+    private outcomeIdToMarketId;
+}

package/dist/exchanges/hunch/fetcher.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HunchFetcher = void 0;
+const utils_1 = require("./utils");
+const errors_1 = require("./errors");
+const AGENT_PREFIX = '/api/agent/v1';
+const DEFAULT_LIMIT = 200;
+/**
+ * HunchFetcher — raw GETs against the live agent API. Hunch reads are keyless,
+ * so we hit the HTTP client directly (clearer + more robust than the implicit
+ * `callApi` for these path/query-param GETs). The trade POST (x402 money path)
+ * is handled in index.ts createOrder, not here.
+ */
+class HunchFetcher {
+    ctx;
+    baseUrl;
+    constructor(ctx, baseUrl) {
+        this.ctx = ctx;
+        this.baseUrl = (baseUrl || utils_1.DEFAULT_BASE_URL).replace(/\/$/, '');
+    }
+    async fetchRawMarkets(params) {
+        try {
+            if (params?.marketId) {
+                const one = await this.fetchRawMarketById(params.marketId);
+                return one ? [one] : [];
+            }
+            if (params?.slug) {
+                const one = await this.fetchRawMarketById(params.slug);
+                return one ? [one] : [];
+            }
+            const query = {
+                limit: params?.limit ?? DEFAULT_LIMIT,
+            };
+            const status = (0, utils_1.mapStatusToHunch)(params?.status);
+            if (status)
+                query.status = status;
+            if (params?.query)
+                query.token = params.query;
+            const res = await this.ctx.http.get(`${this.baseUrl}${AGENT_PREFIX}/markets`, {
+                params: query,
+                headers: this.ctx.getHeaders(),
+            });
+            const markets = res.data?.markets ?? [];
+            return markets;
+        }
+        catch (error) {
+            throw errors_1.hunchErrorMapper.mapError(error);
+        }
+    }
+    /**
+     * Hunch has no Event tier (markets stand alone). `fetchRawEvents` returns
+     * the raw markets so the exchange can wrap each as a single-market event
+     * when the event API is used; honoring `series` by returning [].
+     */
+    async fetchRawEvents(params) {
+        if (params.series !== undefined)
+            return [];
+        return this.fetchRawMarkets({
+            limit: params.limit,
+            status: params.status,
+            query: params.query,
+        });
+    }
+    /** Research payload — carries oddsHistory, the source for OHLCV/trades. */
+    async fetchRawOHLCV(id, _params) {
+        return this.fetchRawResearch(this.outcomeIdToMarketId(id));
+    }
+    /** Quote + research drive the emulated orderbook (implied price + pool). */
+    async fetchRawOrderBook(id) {
+        return this.fetchRawResearch(this.outcomeIdToMarketId(id));
+    }
+    /** oddsHistory (from research) doubles as the public trade tape. */
+    async fetchRawTrades(id, _params) {
+        const research = await this.fetchRawResearch(this.outcomeIdToMarketId(id));
+        return research.oddsHistory ?? [];
+    }
+    async fetchRawPositions(walletAddress) {
+        try {
+            const res = await this.ctx.http.get(`${this.baseUrl}${AGENT_PREFIX}/positions`, {
+                params: { wallet: walletAddress },
+                headers: this.ctx.getHeaders(),
+            });
+            return res.data?.positions ?? [];
+        }
+        catch (error) {
+            throw errors_1.hunchErrorMapper.mapError(error);
+        }
+    }
+    async fetchRawBalance(walletAddress) {
+        try {
+            const res = await this.ctx.http.get(`${this.baseUrl}${AGENT_PREFIX}/wallet/${encodeURIComponent(walletAddress)}/readiness`, { headers: this.ctx.getHeaders() });
+            return res.data?.readiness ?? res.data;
+        }
+        catch (error) {
+            throw errors_1.hunchErrorMapper.mapError(error);
+        }
+    }
+    // -- Shared raw reads -----------------------------------------------------
+    async fetchRawResearch(marketId) {
+        try {
+            const res = await this.ctx.http.get(`${this.baseUrl}${AGENT_PREFIX}/markets/${encodeURIComponent(marketId)}/research`, { headers: this.ctx.getHeaders() });
+            return res.data?.research ?? res.data;
+        }
+        catch (error) {
+            throw errors_1.hunchErrorMapper.mapError(error);
+        }
+    }
+    async fetchRawQuote(marketId, side, sizeUsd, wallet) {
+        try {
+            const res = await this.ctx.http.get(`${this.baseUrl}${AGENT_PREFIX}/quote`, {
+                params: { marketId, side, sizeUsd, ...(wallet ? { wallet } : {}) },
+                headers: this.ctx.getHeaders(),
+            });
+            return res.data?.quote ?? res.data;
+        }
+        catch (error) {
+            throw errors_1.hunchErrorMapper.mapError(error);
+        }
+    }
+    async fetchRawMarketById(id) {
+        const res = await this.ctx.http.get(`${this.baseUrl}${AGENT_PREFIX}/markets/${encodeURIComponent(id)}`, { headers: this.ctx.getHeaders() });
+        return res.data?.market ?? res.data ?? null;
+    }
+    /** outcomeId is `${marketId}:${side}`; strip the side to get the market id. */
+    outcomeIdToMarketId(id) {
+        const idx = id.lastIndexOf(':');
+        return idx > 0 ? id.slice(0, idx) : id;
+    }
+}
+exports.HunchFetcher = HunchFetcher;

package/dist/exchanges/hunch/index.d.ts

@@ -0,0 +1,51 @@
+import { PredictionMarketExchange, MarketFilterParams, HistoryFilterParams, OHLCVParams, TradesParams, EventFetchParams } from '../../BaseExchange';
+import { UnifiedMarket, UnifiedEvent, PriceCandle, OrderBook, Trade, Balance, Order, Position, CreateOrderParams } from '../../types';
+import { HunchCredentials } from './auth';
+export declare class HunchExchange extends PredictionMarketExchange {
+    protected readonly capabilityOverrides: {
+        fetchOrderBook: "emulated";
+        createOrder: true;
+        cancelOrder: false;
+        fetchOrder: false;
+        fetchOpenOrders: false;
+        fetchBalance: true;
+        fetchPositions: true;
+        fetchSeries: false;
+        watchOrderBook: "emulated";
+        watchTrades: "emulated";
+    };
+    private readonly auth;
+    private readonly fetcher;
+    private readonly normalizer;
+    private readonly hunchBaseUrl;
+    private ws?;
+    constructor(credentials?: HunchCredentials);
+    get name(): string;
+    private getHeaders;
+    protected sign(_method: string, _path: string, _params: Record<string, any>): Record<string, string>;
+    protected mapImplicitApiError(error: any): any;
+    protected fetchMarketsImpl(params?: MarketFilterParams): Promise<UnifiedMarket[]>;
+    protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
+    fetchOHLCV(outcomeId: string, params: OHLCVParams): Promise<PriceCandle[]>;
+    fetchOrderBook(outcomeId: string, _limit?: number, _params?: Record<string, any>): Promise<OrderBook>;
+    fetchTrades(outcomeId: string, params: TradesParams | HistoryFilterParams): Promise<Trade[]>;
+    createOrder(params: CreateOrderParams): Promise<Order>;
+    cancelOrder(_orderId: string): Promise<Order>;
+    fetchOrder(_orderId: string): Promise<Order>;
+    fetchOpenOrders(_marketId?: string): Promise<Order[]>;
+    fetchPositions(): Promise<Position[]>;
+    fetchBalance(): Promise<Balance[]>;
+    watchOrderBook(outcomeId: string, _limit?: number, _params?: Record<string, any>): Promise<OrderBook>;
+    watchTrades(outcomeId: string, _address?: string, _since?: number, _limit?: number): Promise<Trade[]>;
+    close(): Promise<void>;
+    private makeWs;
+    /**
+     * POST the trade body via the axios client, NOT throwing on non-2xx so the
+     * 402 challenge can be read (validateStatus: always-true). Mirrors the SDK's
+     * fetch-based `post()` that inspects `res.status === 402`.
+     */
+    private postTrade;
+    /** Deterministic-but-unique idempotency key (≥8 chars per the schema). */
+    private buildIdemKey;
+    private receiptToOrder;
+}