@claw-network/protocol 0.1.0

package/dist/markets/events.js

@@ -0,0 +1,1074 @@
+import { multibaseEncode } from '@claw-network/core/encoding';
+import { publicKeyFromDid } from '@claw-network/core/identity';
+import { eventHashHex, signEvent } from '@claw-network/core/protocol';
+import { isDeliveryStatus, isListingStatus, isListingVisibility, isMarketType, isOrderStatus, isPaymentStatus, isPricingType, } from './types.js';
+function requireNonEmpty(value, field) {
+    if (!value || value.trim().length === 0) {
+        throw new Error(`${field} is required`);
+    }
+}
+function assertRecord(value, field) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`${field} must be an object`);
+    }
+    return value;
+}
+function assertValidDid(value, field) {
+    requireNonEmpty(value, field);
+    try {
+        publicKeyFromDid(value);
+    }
+    catch {
+        throw new Error(`${field} must be a valid did:claw identifier`);
+    }
+}
+function normalizeTokenAmount(value, field) {
+    let parsed;
+    if (typeof value === 'bigint') {
+        parsed = value;
+    }
+    else if (typeof value === 'number') {
+        if (!Number.isFinite(value) || !Number.isInteger(value)) {
+            throw new Error(`${field} must be an integer`);
+        }
+        parsed = BigInt(value);
+    }
+    else if (typeof value === 'string') {
+        if (value.trim().length === 0) {
+            throw new Error(`${field} is required`);
+        }
+        parsed = BigInt(value);
+    }
+    else {
+        throw new Error(`${field} must be a token amount`);
+    }
+    if (parsed < 0n) {
+        throw new Error(`${field} must be >= 0`);
+    }
+    return parsed.toString();
+}
+function parseStringArray(value, field) {
+    if (!Array.isArray(value)) {
+        throw new Error(`${field} must be an array`);
+    }
+    const result = [];
+    for (const entry of value) {
+        if (typeof entry !== 'string') {
+            throw new Error(`${field} must contain strings`);
+        }
+        const trimmed = entry.trim();
+        if (trimmed.length) {
+            result.push(trimmed);
+        }
+    }
+    if (result.length === 0) {
+        throw new Error(`${field} must contain at least one tag`);
+    }
+    return result;
+}
+const CAPABILITY_PLAN_TYPES = ['pay_per_use', 'time_based', 'subscription', 'credits'];
+function parseCapabilityLeasePlan(value) {
+    const record = assertRecord(value, 'plan');
+    const typeValue = String(record.type ?? '');
+    if (!CAPABILITY_PLAN_TYPES.includes(typeValue)) {
+        throw new Error('plan.type is invalid');
+    }
+    let details;
+    if (record.details !== undefined) {
+        details = assertRecord(record.details, 'plan.details');
+    }
+    return {
+        type: typeValue,
+        details,
+    };
+}
+function parsePricingModel(value) {
+    const pricing = assertRecord(value, 'pricing');
+    const typeValue = String(pricing.type ?? '');
+    if (!isPricingType(typeValue)) {
+        throw new Error('pricing.type is invalid');
+    }
+    const currencyValue = pricing.currency ?? 'TOKEN';
+    if (currencyValue !== 'TOKEN') {
+        throw new Error('pricing.currency must be TOKEN');
+    }
+    const negotiable = pricing.negotiable;
+    if (typeof negotiable !== 'boolean') {
+        throw new Error('pricing.negotiable must be a boolean');
+    }
+    const model = {
+        type: typeValue,
+        currency: 'TOKEN',
+        negotiable,
+    };
+    if (pricing.fixedPrice !== undefined) {
+        model.fixedPrice = normalizeTokenAmount(pricing.fixedPrice, 'pricing.fixedPrice');
+    }
+    if (pricing.priceRange) {
+        const range = assertRecord(pricing.priceRange, 'pricing.priceRange');
+        model.priceRange = {
+            min: normalizeTokenAmount(range.min, 'pricing.priceRange.min'),
+            max: normalizeTokenAmount(range.max, 'pricing.priceRange.max'),
+        };
+    }
+    if (pricing.usagePrice) {
+        const usage = assertRecord(pricing.usagePrice, 'pricing.usagePrice');
+        model.usagePrice = {
+            ...usage,
+            unit: String(usage.unit ?? ''),
+            pricePerUnit: normalizeTokenAmount(usage.pricePerUnit, 'pricing.usagePrice.pricePerUnit'),
+        };
+    }
+    if (pricing.subscriptionPrice) {
+        const sub = assertRecord(pricing.subscriptionPrice, 'pricing.subscriptionPrice');
+        model.subscriptionPrice = {
+            ...sub,
+            period: String(sub.period ?? ''),
+            price: normalizeTokenAmount(sub.price, 'pricing.subscriptionPrice.price'),
+            trialPeriod: typeof sub.trialPeriod === 'number' ? sub.trialPeriod : undefined,
+        };
+    }
+    if (pricing.auction) {
+        const auction = assertRecord(pricing.auction, 'pricing.auction');
+        model.auction = {
+            ...auction,
+            startingPrice: normalizeTokenAmount(auction.startingPrice, 'pricing.auction.startingPrice'),
+            reservePrice: auction.reservePrice !== undefined
+                ? normalizeTokenAmount(auction.reservePrice, 'pricing.auction.reservePrice')
+                : undefined,
+            bidIncrement: normalizeTokenAmount(auction.bidIncrement, 'pricing.auction.bidIncrement'),
+            duration: Number(auction.duration ?? 0),
+            endTime: Number(auction.endTime ?? 0),
+        };
+    }
+    if (pricing.discounts) {
+        if (!Array.isArray(pricing.discounts)) {
+            throw new Error('pricing.discounts must be an array');
+        }
+        model.discounts = pricing.discounts;
+        for (const discount of model.discounts ?? []) {
+            if (discount.condition?.minValue !== undefined) {
+                discount.condition.minValue = normalizeTokenAmount(discount.condition.minValue, 'pricing.discounts.minValue');
+            }
+        }
+    }
+    return model;
+}
+function parseOrderPricing(value) {
+    const pricing = assertRecord(value, 'pricing');
+    const subtotal = normalizeTokenAmount(pricing.subtotal, 'pricing.subtotal');
+    const total = normalizeTokenAmount(pricing.total, 'pricing.total');
+    let discounts;
+    if (pricing.discounts !== undefined) {
+        if (!Array.isArray(pricing.discounts)) {
+            throw new Error('pricing.discounts must be an array');
+        }
+        discounts = pricing.discounts.map((entry) => {
+            if (!entry || typeof entry !== 'object') {
+                throw new Error('pricing.discounts entries must be objects');
+            }
+            const record = entry;
+            return {
+                ...record,
+                amount: normalizeTokenAmount(record.amount, 'pricing.discounts.amount'),
+            };
+        });
+    }
+    let fees;
+    if (pricing.fees !== undefined) {
+        if (!Array.isArray(pricing.fees)) {
+            throw new Error('pricing.fees must be an array');
+        }
+        fees = pricing.fees.map((entry) => {
+            if (!entry || typeof entry !== 'object') {
+                throw new Error('pricing.fees entries must be objects');
+            }
+            const record = entry;
+            return {
+                ...record,
+                amount: normalizeTokenAmount(record.amount, 'pricing.fees.amount'),
+            };
+        });
+    }
+    return {
+        subtotal,
+        discounts,
+        fees,
+        total,
+    };
+}
+function parseOrderPayment(value, field, requireStatus) {
+    const payment = assertRecord(value, field);
+    const statusValue = payment.status;
+    if (statusValue === undefined && requireStatus) {
+        throw new Error(`${field}.status is required`);
+    }
+    const statusString = statusValue !== undefined ? String(statusValue) : 'pending';
+    if (!isPaymentStatus(statusString)) {
+        throw new Error(`${field}.status is invalid`);
+    }
+    return {
+        ...payment,
+        status: statusString,
+    };
+}
+function parseOrderDelivery(value, field, requireStatus) {
+    const delivery = assertRecord(value, field);
+    const statusValue = delivery.status;
+    if (statusValue === undefined && requireStatus) {
+        throw new Error(`${field}.status is required`);
+    }
+    const statusString = statusValue !== undefined ? String(statusValue) : 'pending';
+    if (!isDeliveryStatus(statusString)) {
+        throw new Error(`${field}.status is invalid`);
+    }
+    return {
+        ...delivery,
+        status: statusString,
+    };
+}
+function parseOrderItems(orderId, value) {
+    if (!Array.isArray(value)) {
+        throw new Error('items must be an array');
+    }
+    if (value.length === 0) {
+        throw new Error('items must not be empty');
+    }
+    return value.map((entry, index) => {
+        const record = assertRecord(entry, `items[${index}]`);
+        const listingId = String(record.listingId ?? '');
+        requireNonEmpty(listingId, `items[${index}].listingId`);
+        const quantity = Number(record.quantity ?? 0);
+        if (!Number.isInteger(quantity) || quantity <= 0) {
+            throw new Error(`items[${index}].quantity must be a positive integer`);
+        }
+        const unitPrice = normalizeTokenAmount(record.unitPrice, `items[${index}].unitPrice`);
+        const totalPrice = record.totalPrice !== undefined
+            ? normalizeTokenAmount(record.totalPrice, `items[${index}].totalPrice`)
+            : (BigInt(unitPrice) * BigInt(quantity)).toString();
+        const id = typeof record.id === 'string' && record.id.trim().length > 0
+            ? record.id
+            : `${orderId}:${index}`;
+        return {
+            id,
+            listingId,
+            title: typeof record.title === 'string' ? record.title : undefined,
+            description: typeof record.description === 'string' ? record.description : undefined,
+            quantity,
+            unitPrice,
+            totalPrice,
+            itemData: typeof record.itemData === 'object' && record.itemData !== null
+                ? record.itemData
+                : undefined,
+        };
+    });
+}
+function buildEnvelope(type, issuer, publicKey, payload, ts, nonce, prev) {
+    return {
+        v: 1,
+        type,
+        issuer,
+        ts,
+        nonce,
+        payload,
+        prev,
+        sig: '',
+        pub: multibaseEncode(publicKey),
+        hash: '',
+    };
+}
+export function parseMarketListingPublishPayload(payload) {
+    const listingId = String(payload.listingId ?? '');
+    requireNonEmpty(listingId, 'listingId');
+    const marketTypeValue = String(payload.marketType ?? '');
+    if (!isMarketType(marketTypeValue)) {
+        throw new Error('marketType is invalid');
+    }
+    const sellerRecord = assertRecord(payload.seller, 'seller');
+    const sellerDid = String(sellerRecord.did ?? '');
+    assertValidDid(sellerDid, 'seller.did');
+    const title = String(payload.title ?? '').trim();
+    requireNonEmpty(title, 'title');
+    const description = String(payload.description ?? '').trim();
+    requireNonEmpty(description, 'description');
+    const category = String(payload.category ?? '').trim();
+    requireNonEmpty(category, 'category');
+    const tags = parseStringArray(payload.tags, 'tags');
+    const pricing = parsePricingModel(payload.pricing);
+    const visibilityValue = String(payload.visibility ?? '');
+    if (!isListingVisibility(visibilityValue)) {
+        throw new Error('visibility is invalid');
+    }
+    const marketData = assertRecord(payload.marketData, 'marketData');
+    const restrictions = payload.restrictions
+        ? assertRecord(payload.restrictions, 'restrictions')
+        : undefined;
+    const metadata = payload.metadata
+        ? assertRecord(payload.metadata, 'metadata')
+        : undefined;
+    const expiresAt = payload.expiresAt;
+    if (expiresAt !== undefined && typeof expiresAt !== 'number') {
+        throw new Error('expiresAt must be a number');
+    }
+    const statusValue = payload.status !== undefined ? String(payload.status) : undefined;
+    if (statusValue !== undefined && !isListingStatus(statusValue)) {
+        throw new Error('status is invalid');
+    }
+    if (payload.resourcePrev !== undefined && payload.resourcePrev !== null) {
+        throw new Error('resourcePrev must be null for listing publish');
+    }
+    return {
+        listingId,
+        marketType: marketTypeValue,
+        seller: {
+            did: sellerDid,
+            name: typeof sellerRecord.name === 'string' ? sellerRecord.name : undefined,
+        },
+        title,
+        description,
+        category,
+        tags,
+        pricing,
+        visibility: visibilityValue,
+        marketData,
+        restrictions,
+        expiresAt: typeof expiresAt === 'number' ? expiresAt : undefined,
+        metadata,
+        status: statusValue,
+        resourcePrev: undefined,
+    };
+}
+export function parseMarketListingUpdatePayload(payload) {
+    const listingId = String(payload.listingId ?? '');
+    requireNonEmpty(listingId, 'listingId');
+    const resourcePrev = String(payload.resourcePrev ?? '');
+    requireNonEmpty(resourcePrev, 'resourcePrev');
+    const statusValue = String(payload.status ?? '');
+    if (!isListingStatus(statusValue)) {
+        throw new Error('status is invalid');
+    }
+    const metadata = payload.metadata
+        ? assertRecord(payload.metadata, 'metadata')
+        : undefined;
+    return {
+        listingId,
+        resourcePrev,
+        status: statusValue,
+        metadata,
+    };
+}
+export function parseMarketListingRemovePayload(payload) {
+    const listingId = String(payload.listingId ?? '');
+    requireNonEmpty(listingId, 'listingId');
+    const resourcePrev = String(payload.resourcePrev ?? '');
+    requireNonEmpty(resourcePrev, 'resourcePrev');
+    return {
+        listingId,
+        resourcePrev,
+    };
+}
+export function parseMarketOrderCreatePayload(payload) {
+    const orderId = String(payload.orderId ?? '');
+    requireNonEmpty(orderId, 'orderId');
+    const listingId = String(payload.listingId ?? '');
+    requireNonEmpty(listingId, 'listingId');
+    const marketTypeValue = String(payload.marketType ?? '');
+    if (!isMarketType(marketTypeValue)) {
+        throw new Error('marketType is invalid');
+    }
+    const buyerRecord = assertRecord(payload.buyer, 'buyer');
+    const buyerDid = String(buyerRecord.did ?? '');
+    assertValidDid(buyerDid, 'buyer.did');
+    const sellerRecord = payload.seller !== undefined
+        ? assertRecord(payload.seller, 'seller')
+        : undefined;
+    if (sellerRecord) {
+        const sellerDid = String(sellerRecord.did ?? '');
+        assertValidDid(sellerDid, 'seller.did');
+    }
+    const items = parseOrderItems(orderId, payload.items);
+    const pricing = parseOrderPricing(payload.pricing);
+    const payment = parseOrderPayment(payload.payment, 'payment', true);
+    const delivery = parseOrderDelivery(payload.delivery, 'delivery', true);
+    const statusValue = payload.status !== undefined ? String(payload.status) : undefined;
+    if (statusValue !== undefined && !isOrderStatus(statusValue)) {
+        throw new Error('status is invalid');
+    }
+    if (payload.resourcePrev !== undefined && payload.resourcePrev !== null) {
+        throw new Error('resourcePrev must be null for order create');
+    }
+    return {
+        orderId,
+        listingId,
+        marketType: marketTypeValue,
+        buyer: {
+            did: buyerDid,
+            name: typeof buyerRecord.name === 'string' ? buyerRecord.name : undefined,
+        },
+        seller: sellerRecord
+            ? {
+                did: String(sellerRecord.did ?? ''),
+                name: typeof sellerRecord.name === 'string' ? sellerRecord.name : undefined,
+            }
+            : undefined,
+        items,
+        pricing,
+        payment,
+        delivery,
+        status: statusValue,
+        resourcePrev: undefined,
+    };
+}
+export function parseMarketOrderUpdatePayload(payload) {
+    const orderId = String(payload.orderId ?? '');
+    requireNonEmpty(orderId, 'orderId');
+    const resourcePrev = String(payload.resourcePrev ?? '');
+    requireNonEmpty(resourcePrev, 'resourcePrev');
+    const statusValue = String(payload.status ?? '');
+    if (!isOrderStatus(statusValue)) {
+        throw new Error('status is invalid');
+    }
+    const payment = payload.payment
+        ? parseOrderPayment(payload.payment, 'payment', false)
+        : undefined;
+    const delivery = payload.delivery
+        ? parseOrderDelivery(payload.delivery, 'delivery', false)
+        : undefined;
+    const review = payload.review
+        ? assertRecord(payload.review, 'review')
+        : undefined;
+    return {
+        orderId,
+        resourcePrev,
+        status: statusValue,
+        payment,
+        delivery,
+        review,
+    };
+}
+function parseBidder(value) {
+    const bidder = assertRecord(value, 'bidder');
+    const bidderDid = String(bidder.did ?? '');
+    assertValidDid(bidderDid, 'bidder.did');
+    return {
+        did: bidderDid,
+        name: typeof bidder.name === 'string' ? bidder.name : undefined,
+    };
+}
+function parseBidProposal(value) {
+    const proposal = assertRecord(value, 'proposal');
+    const price = normalizeTokenAmount(proposal.price, 'proposal.price');
+    const timeline = Number(proposal.timeline ?? NaN);
+    if (!Number.isFinite(timeline)) {
+        throw new Error('proposal.timeline must be a number');
+    }
+    const approach = String(proposal.approach ?? '').trim();
+    requireNonEmpty(approach, 'proposal.approach');
+    let milestones;
+    if (proposal.milestones !== undefined) {
+        if (!Array.isArray(proposal.milestones)) {
+            throw new Error('proposal.milestones must be an array');
+        }
+        milestones = proposal.milestones.map((entry, index) => {
+            return assertRecord(entry, `proposal.milestones[${index}]`);
+        });
+    }
+    return {
+        price,
+        timeline,
+        approach,
+        milestones,
+    };
+}
+function parseSubmissionDeliverables(value) {
+    if (!Array.isArray(value)) {
+        throw new Error('deliverables must be an array');
+    }
+    return value.map((entry, index) => assertRecord(entry, `deliverables[${index}]`));
+}
+export function parseMarketBidSubmitPayload(payload) {
+    const bidId = String(payload.bidId ?? '');
+    requireNonEmpty(bidId, 'bidId');
+    const taskId = String(payload.taskId ?? '');
+    requireNonEmpty(taskId, 'taskId');
+    const bidder = parseBidder(payload.bidder);
+    const proposal = parseBidProposal(payload.proposal);
+    if (payload.resourcePrev !== undefined && payload.resourcePrev !== null) {
+        throw new Error('resourcePrev must be null for bid submit');
+    }
+    return {
+        bidId,
+        taskId,
+        bidder,
+        proposal,
+        resourcePrev: undefined,
+    };
+}
+export function parseMarketBidUpdatePayload(payload) {
+    const bidId = String(payload.bidId ?? '');
+    requireNonEmpty(bidId, 'bidId');
+    const resourcePrev = String(payload.resourcePrev ?? '');
+    requireNonEmpty(resourcePrev, 'resourcePrev');
+    return {
+        bidId,
+        resourcePrev,
+    };
+}
+export function parseMarketSubmissionSubmitPayload(payload) {
+    const orderId = String(payload.orderId ?? '');
+    requireNonEmpty(orderId, 'orderId');
+    const submissionId = String(payload.submissionId ?? '');
+    requireNonEmpty(submissionId, 'submissionId');
+    const worker = String(payload.worker ?? '');
+    assertValidDid(worker, 'worker');
+    const deliverables = parseSubmissionDeliverables(payload.deliverables);
+    const notes = typeof payload.notes === 'string' ? payload.notes : undefined;
+    if (payload.resourcePrev !== undefined && payload.resourcePrev !== null) {
+        throw new Error('resourcePrev must be null for submission submit');
+    }
+    return {
+        orderId,
+        submissionId,
+        worker,
+        deliverables,
+        notes,
+        resourcePrev: undefined,
+    };
+}
+export function parseMarketSubmissionReviewPayload(payload) {
+    const submissionId = String(payload.submissionId ?? '');
+    requireNonEmpty(submissionId, 'submissionId');
+    const resourcePrev = String(payload.resourcePrev ?? '');
+    requireNonEmpty(resourcePrev, 'resourcePrev');
+    const approved = payload.approved;
+    if (typeof approved !== 'boolean') {
+        throw new Error('approved must be a boolean');
+    }
+    const feedback = String(payload.feedback ?? '').trim();
+    requireNonEmpty(feedback, 'feedback');
+    const ratingValue = payload.rating;
+    if (ratingValue !== undefined && typeof ratingValue !== 'number') {
+        throw new Error('rating must be a number');
+    }
+    const revisionDeadline = payload.revisionDeadline;
+    if (revisionDeadline !== undefined && typeof revisionDeadline !== 'number') {
+        throw new Error('revisionDeadline must be a number');
+    }
+    return {
+        submissionId,
+        resourcePrev,
+        approved,
+        feedback,
+        rating: typeof ratingValue === 'number' ? ratingValue : undefined,
+        revisionDeadline: typeof revisionDeadline === 'number' ? revisionDeadline : undefined,
+    };
+}
+export function parseMarketSubscriptionStartPayload(payload) {
+    const subscriptionId = String(payload.subscriptionId ?? '');
+    requireNonEmpty(subscriptionId, 'subscriptionId');
+    const listingId = String(payload.listingId ?? '');
+    requireNonEmpty(listingId, 'listingId');
+    const buyerRecord = assertRecord(payload.buyer, 'buyer');
+    const buyerDid = String(buyerRecord.did ?? '');
+    assertValidDid(buyerDid, 'buyer.did');
+    if (payload.resourcePrev !== undefined && payload.resourcePrev !== null) {
+        throw new Error('resourcePrev must be null for subscription start');
+    }
+    return {
+        subscriptionId,
+        listingId,
+        buyer: {
+            did: buyerDid,
+            name: typeof buyerRecord.name === 'string' ? buyerRecord.name : undefined,
+        },
+        resourcePrev: undefined,
+    };
+}
+export function parseMarketSubscriptionCancelPayload(payload) {
+    const subscriptionId = String(payload.subscriptionId ?? '');
+    requireNonEmpty(subscriptionId, 'subscriptionId');
+    const resourcePrev = String(payload.resourcePrev ?? '');
+    requireNonEmpty(resourcePrev, 'resourcePrev');
+    return {
+        subscriptionId,
+        resourcePrev,
+    };
+}
+export function parseMarketDisputeOpenPayload(payload) {
+    const disputeId = String(payload.disputeId ?? '');
+    requireNonEmpty(disputeId, 'disputeId');
+    const orderId = String(payload.orderId ?? '');
+    requireNonEmpty(orderId, 'orderId');
+    const type = String(payload.type ?? '').trim();
+    requireNonEmpty(type, 'type');
+    const description = String(payload.description ?? '').trim();
+    requireNonEmpty(description, 'description');
+    let claimAmount;
+    if (payload.claimAmount !== undefined) {
+        claimAmount = normalizeTokenAmount(payload.claimAmount, 'claimAmount');
+    }
+    if (payload.resourcePrev !== undefined && payload.resourcePrev !== null) {
+        throw new Error('resourcePrev must be null for dispute open');
+    }
+    return {
+        disputeId,
+        orderId,
+        type,
+        description,
+        claimAmount,
+        resourcePrev: undefined,
+    };
+}
+export function parseMarketDisputeResponsePayload(payload) {
+    const disputeId = String(payload.disputeId ?? '');
+    requireNonEmpty(disputeId, 'disputeId');
+    const resourcePrev = String(payload.resourcePrev ?? '');
+    requireNonEmpty(resourcePrev, 'resourcePrev');
+    const response = String(payload.response ?? '').trim();
+    requireNonEmpty(response, 'response');
+    let evidence;
+    if (payload.evidence !== undefined) {
+        if (!Array.isArray(payload.evidence)) {
+            throw new Error('evidence must be an array');
+        }
+        evidence = payload.evidence.map((entry, index) => assertRecord(entry, `evidence[${index}]`));
+    }
+    return {
+        disputeId,
+        resourcePrev,
+        response,
+        evidence,
+    };
+}
+export function parseMarketDisputeResolvePayload(payload) {
+    const disputeId = String(payload.disputeId ?? '');
+    requireNonEmpty(disputeId, 'disputeId');
+    const resourcePrev = String(payload.resourcePrev ?? '');
+    requireNonEmpty(resourcePrev, 'resourcePrev');
+    const resolution = String(payload.resolution ?? '').trim();
+    requireNonEmpty(resolution, 'resolution');
+    const notes = typeof payload.notes === 'string' ? payload.notes : undefined;
+    return {
+        disputeId,
+        resourcePrev,
+        resolution,
+        notes,
+    };
+}
+export function parseMarketCapabilityLeaseStartPayload(payload) {
+    const listingId = String(payload.listingId ?? '');
+    requireNonEmpty(listingId, 'listingId');
+    const leaseId = String(payload.leaseId ?? '');
+    requireNonEmpty(leaseId, 'leaseId');
+    const lessee = String(payload.lessee ?? '');
+    assertValidDid(lessee, 'lessee');
+    const plan = parseCapabilityLeasePlan(payload.plan);
+    const credentials = payload.credentials
+        ? assertRecord(payload.credentials, 'credentials')
+        : undefined;
+    const metadata = payload.metadata
+        ? assertRecord(payload.metadata, 'metadata')
+        : undefined;
+    const expiresAt = payload.expiresAt;
+    if (expiresAt !== undefined && typeof expiresAt !== 'number') {
+        throw new Error('expiresAt must be a number');
+    }
+    if (payload.resourcePrev !== undefined && payload.resourcePrev !== null) {
+        throw new Error('resourcePrev must be null for lease start');
+    }
+    return {
+        listingId,
+        leaseId,
+        lessee,
+        plan,
+        credentials,
+        metadata,
+        expiresAt: typeof expiresAt === 'number' ? expiresAt : undefined,
+        resourcePrev: undefined,
+    };
+}
+export function parseMarketCapabilityLeaseUpdatePayload(payload) {
+    const leaseId = String(payload.leaseId ?? '');
+    requireNonEmpty(leaseId, 'leaseId');
+    const resourcePrev = String(payload.resourcePrev ?? '');
+    requireNonEmpty(resourcePrev, 'resourcePrev');
+    return {
+        leaseId,
+        resourcePrev,
+    };
+}
+export function parseMarketCapabilityInvokePayload(payload) {
+    const leaseId = String(payload.leaseId ?? '');
+    requireNonEmpty(leaseId, 'leaseId');
+    const resource = String(payload.resource ?? '').trim();
+    requireNonEmpty(resource, 'resource');
+    const unitsValue = Number(payload.units ?? NaN);
+    if (!Number.isFinite(unitsValue) || !Number.isInteger(unitsValue) || unitsValue <= 0) {
+        throw new Error('units must be a positive integer');
+    }
+    const latencyValue = Number(payload.latency ?? NaN);
+    if (!Number.isFinite(latencyValue) || latencyValue < 0) {
+        throw new Error('latency must be a non-negative number');
+    }
+    const successValue = payload.success;
+    if (typeof successValue !== 'boolean') {
+        throw new Error('success must be a boolean');
+    }
+    let cost;
+    if (payload.cost !== undefined) {
+        cost = normalizeTokenAmount(payload.cost, 'cost');
+    }
+    return {
+        leaseId,
+        resource,
+        units: unitsValue,
+        latency: latencyValue,
+        success: successValue,
+        cost,
+    };
+}
+export async function createMarketListingPublishEnvelope(params) {
+    const sellerDid = params.sellerDid ?? params.issuer;
+    assertValidDid(params.issuer, 'issuer');
+    if (sellerDid !== params.issuer) {
+        throw new Error('issuer must match seller.did');
+    }
+    const payload = parseMarketListingPublishPayload({
+        listingId: params.listingId,
+        marketType: params.marketType,
+        seller: {
+            did: sellerDid,
+            name: params.sellerName,
+        },
+        title: params.title,
+        description: params.description,
+        category: params.category,
+        tags: params.tags,
+        pricing: params.pricing,
+        visibility: params.visibility,
+        marketData: params.marketData,
+        restrictions: params.restrictions,
+        expiresAt: params.expiresAt,
+        metadata: params.metadata,
+        status: params.status,
+        resourcePrev: params.resourcePrev,
+    });
+    const publicKey = publicKeyFromDid(params.issuer);
+    const baseEnvelope = buildEnvelope('market.listing.publish', params.issuer, publicKey, payload, params.ts, params.nonce, params.prev);
+    const hash = eventHashHex(baseEnvelope);
+    const sig = await signEvent(baseEnvelope, params.privateKey);
+    return { ...baseEnvelope, hash, sig };
+}
+export async function createMarketListingUpdateEnvelope(params) {
+    assertValidDid(params.issuer, 'issuer');
+    const payload = parseMarketListingUpdatePayload({
+        listingId: params.listingId,
+        resourcePrev: params.resourcePrev,
+        status: params.status,
+        metadata: params.metadata,
+    });
+    const publicKey = publicKeyFromDid(params.issuer);
+    const baseEnvelope = buildEnvelope('market.listing.update', params.issuer, publicKey, payload, params.ts, params.nonce, params.prev);
+    const hash = eventHashHex(baseEnvelope);
+    const sig = await signEvent(baseEnvelope, params.privateKey);
+    return { ...baseEnvelope, hash, sig };
+}
+export async function createMarketListingRemoveEnvelope(params) {
+    assertValidDid(params.issuer, 'issuer');
+    const payload = parseMarketListingRemovePayload({
+        listingId: params.listingId,
+        resourcePrev: params.resourcePrev,
+    });
+    const publicKey = publicKeyFromDid(params.issuer);
+    const baseEnvelope = buildEnvelope('market.listing.remove', params.issuer, publicKey, payload, params.ts, params.nonce, params.prev);
+    const hash = eventHashHex(baseEnvelope);
+    const sig = await signEvent(baseEnvelope, params.privateKey);
+    return { ...baseEnvelope, hash, sig };
+}
+export async function createMarketOrderCreateEnvelope(params) {
+    const buyerDid = params.buyerDid ?? params.issuer;
+    assertValidDid(params.issuer, 'issuer');
+    if (buyerDid !== params.issuer) {
+        throw new Error('issuer must match buyer.did');
+    }
+    const sellerDid = params.sellerDid;
+    const payload = parseMarketOrderCreatePayload({
+        orderId: params.orderId,
+        listingId: params.listingId,
+        marketType: params.marketType,
+        buyer: {
+            did: buyerDid,
+            name: params.buyerName,
+        },
+        seller: sellerDid
+            ? {
+                did: sellerDid,
+                name: params.sellerName,
+            }
+            : undefined,
+        items: params.items,
+        pricing: params.pricing,
+        payment: {
+            status: params.payment?.status ?? 'pending',
+            ...params.payment,
+        },
+        delivery: {
+            status: params.delivery?.status ?? 'pending',
+            ...params.delivery,
+        },
+        status: params.status,
+        resourcePrev: params.resourcePrev,
+    });
+    const publicKey = publicKeyFromDid(params.issuer);
+    const baseEnvelope = buildEnvelope('market.order.create', params.issuer, publicKey, payload, params.ts, params.nonce, params.prev);
+    const hash = eventHashHex(baseEnvelope);
+    const sig = await signEvent(baseEnvelope, params.privateKey);
+    return { ...baseEnvelope, hash, sig };
+}
+export async function createMarketOrderUpdateEnvelope(params) {
+    assertValidDid(params.issuer, 'issuer');
+    const payload = parseMarketOrderUpdatePayload({
+        orderId: params.orderId,
+        resourcePrev: params.resourcePrev,
+        status: params.status,
+        payment: params.payment,
+        delivery: params.delivery,
+        review: params.review,
+    });
+    const publicKey = publicKeyFromDid(params.issuer);
+    const baseEnvelope = buildEnvelope('market.order.update', params.issuer, publicKey, payload, params.ts, params.nonce, params.prev);
+    const hash = eventHashHex(baseEnvelope);
+    const sig = await signEvent(baseEnvelope, params.privateKey);
+    return { ...baseEnvelope, hash, sig };
+}
+export async function createMarketBidSubmitEnvelope(params) {
+    const bidderDid = params.bidderDid ?? params.issuer;
+    assertValidDid(params.issuer, 'issuer');
+    if (bidderDid !== params.issuer) {
+        throw new Error('issuer must match bidder.did');
+    }
+    const payload = parseMarketBidSubmitPayload({
+        bidId: params.bidId,
+        taskId: params.taskId,
+        bidder: {
+            did: bidderDid,
+            name: params.bidderName,
+        },
+        proposal: params.proposal,
+        resourcePrev: params.resourcePrev,
+    });
+    const publicKey = publicKeyFromDid(params.issuer);
+    const baseEnvelope = buildEnvelope('market.bid.submit', params.issuer, publicKey, payload, params.ts, params.nonce, params.prev);
+    const hash = eventHashHex(baseEnvelope);
+    const sig = await signEvent(baseEnvelope, params.privateKey);
+    return { ...baseEnvelope, hash, sig };
+}
+export async function createMarketBidAcceptEnvelope(params) {
+    assertValidDid(params.issuer, 'issuer');
+    const payload = parseMarketBidUpdatePayload({
+        bidId: params.bidId,
+        resourcePrev: params.resourcePrev,
+    });
+    const publicKey = publicKeyFromDid(params.issuer);
+    const baseEnvelope = buildEnvelope('market.bid.accept', params.issuer, publicKey, payload, params.ts, params.nonce, params.prev);
+    const hash = eventHashHex(baseEnvelope);
+    const sig = await signEvent(baseEnvelope, params.privateKey);
+    return { ...baseEnvelope, hash, sig };
+}
+export async function createMarketBidRejectEnvelope(params) {
+    assertValidDid(params.issuer, 'issuer');
+    const payload = parseMarketBidUpdatePayload({
+        bidId: params.bidId,
+        resourcePrev: params.resourcePrev,
+    });
+    const publicKey = publicKeyFromDid(params.issuer);
+    const baseEnvelope = buildEnvelope('market.bid.reject', params.issuer, publicKey, payload, params.ts, params.nonce, params.prev);
+    const hash = eventHashHex(baseEnvelope);
+    const sig = await signEvent(baseEnvelope, params.privateKey);
+    return { ...baseEnvelope, hash, sig };
+}
+export async function createMarketBidWithdrawEnvelope(params) {
+    assertValidDid(params.issuer, 'issuer');
+    const payload = parseMarketBidUpdatePayload({
+        bidId: params.bidId,
+        resourcePrev: params.resourcePrev,
+    });
+    const publicKey = publicKeyFromDid(params.issuer);
+    const baseEnvelope = buildEnvelope('market.bid.withdraw', params.issuer, publicKey, payload, params.ts, params.nonce, params.prev);
+    const hash = eventHashHex(baseEnvelope);
+    const sig = await signEvent(baseEnvelope, params.privateKey);
+    return { ...baseEnvelope, hash, sig };
+}
+export async function createMarketSubmissionSubmitEnvelope(params) {
+    const workerDid = params.workerDid ?? params.issuer;
+    assertValidDid(params.issuer, 'issuer');
+    if (workerDid !== params.issuer) {
+        throw new Error('issuer must match worker');
+    }
+    const payload = parseMarketSubmissionSubmitPayload({
+        orderId: params.orderId,
+        submissionId: params.submissionId,
+        worker: workerDid,
+        deliverables: params.deliverables,
+        notes: params.notes,
+        resourcePrev: params.resourcePrev,
+    });
+    const publicKey = publicKeyFromDid(params.issuer);
+    const baseEnvelope = buildEnvelope('market.submission.submit', params.issuer, publicKey, payload, params.ts, params.nonce, params.prev);
+    const hash = eventHashHex(baseEnvelope);
+    const sig = await signEvent(baseEnvelope, params.privateKey);
+    return { ...baseEnvelope, hash, sig };
+}
+export async function createMarketSubmissionReviewEnvelope(params) {
+    assertValidDid(params.issuer, 'issuer');
+    const payload = parseMarketSubmissionReviewPayload({
+        submissionId: params.submissionId,
+        resourcePrev: params.resourcePrev,
+        approved: params.approved,
+        feedback: params.feedback,
+        rating: params.rating,
+        revisionDeadline: params.revisionDeadline,
+    });
+    const publicKey = publicKeyFromDid(params.issuer);
+    const baseEnvelope = buildEnvelope('market.submission.review', params.issuer, publicKey, payload, params.ts, params.nonce, params.prev);
+    const hash = eventHashHex(baseEnvelope);
+    const sig = await signEvent(baseEnvelope, params.privateKey);
+    return { ...baseEnvelope, hash, sig };
+}
+export async function createMarketSubscriptionStartEnvelope(params) {
+    const buyerDid = params.buyerDid ?? params.issuer;
+    assertValidDid(params.issuer, 'issuer');
+    if (buyerDid !== params.issuer) {
+        throw new Error('issuer must match buyer.did');
+    }
+    const payload = parseMarketSubscriptionStartPayload({
+        subscriptionId: params.subscriptionId,
+        listingId: params.listingId,
+        buyer: {
+            did: buyerDid,
+            name: params.buyerName,
+        },
+        resourcePrev: params.resourcePrev,
+    });
+    const publicKey = publicKeyFromDid(params.issuer);
+    const baseEnvelope = buildEnvelope('market.subscription.start', params.issuer, publicKey, payload, params.ts, params.nonce, params.prev);
+    const hash = eventHashHex(baseEnvelope);
+    const sig = await signEvent(baseEnvelope, params.privateKey);
+    return { ...baseEnvelope, hash, sig };
+}
+export async function createMarketSubscriptionCancelEnvelope(params) {
+    assertValidDid(params.issuer, 'issuer');
+    const payload = parseMarketSubscriptionCancelPayload({
+        subscriptionId: params.subscriptionId,
+        resourcePrev: params.resourcePrev,
+    });
+    const publicKey = publicKeyFromDid(params.issuer);
+    const baseEnvelope = buildEnvelope('market.subscription.cancel', params.issuer, publicKey, payload, params.ts, params.nonce, params.prev);
+    const hash = eventHashHex(baseEnvelope);
+    const sig = await signEvent(baseEnvelope, params.privateKey);
+    return { ...baseEnvelope, hash, sig };
+}
+export async function createMarketDisputeOpenEnvelope(params) {
+    assertValidDid(params.issuer, 'issuer');
+    const payload = parseMarketDisputeOpenPayload({
+        disputeId: params.disputeId,
+        orderId: params.orderId,
+        type: params.type,
+        description: params.description,
+        claimAmount: params.claimAmount,
+        resourcePrev: params.resourcePrev,
+    });
+    const publicKey = publicKeyFromDid(params.issuer);
+    const baseEnvelope = buildEnvelope('market.dispute.open', params.issuer, publicKey, payload, params.ts, params.nonce, params.prev);
+    const hash = eventHashHex(baseEnvelope);
+    const sig = await signEvent(baseEnvelope, params.privateKey);
+    return { ...baseEnvelope, hash, sig };
+}
+export async function createMarketDisputeResponseEnvelope(params) {
+    assertValidDid(params.issuer, 'issuer');
+    const payload = parseMarketDisputeResponsePayload({
+        disputeId: params.disputeId,
+        resourcePrev: params.resourcePrev,
+        response: params.response,
+        evidence: params.evidence,
+    });
+    const publicKey = publicKeyFromDid(params.issuer);
+    const baseEnvelope = buildEnvelope('market.dispute.response', params.issuer, publicKey, payload, params.ts, params.nonce, params.prev);
+    const hash = eventHashHex(baseEnvelope);
+    const sig = await signEvent(baseEnvelope, params.privateKey);
+    return { ...baseEnvelope, hash, sig };
+}
+export async function createMarketDisputeResolveEnvelope(params) {
+    assertValidDid(params.issuer, 'issuer');
+    const payload = parseMarketDisputeResolvePayload({
+        disputeId: params.disputeId,
+        resourcePrev: params.resourcePrev,
+        resolution: params.resolution,
+        notes: params.notes,
+    });
+    const publicKey = publicKeyFromDid(params.issuer);
+    const baseEnvelope = buildEnvelope('market.dispute.resolve', params.issuer, publicKey, payload, params.ts, params.nonce, params.prev);
+    const hash = eventHashHex(baseEnvelope);
+    const sig = await signEvent(baseEnvelope, params.privateKey);
+    return { ...baseEnvelope, hash, sig };
+}
+export async function createMarketCapabilityLeaseStartEnvelope(params) {
+    const lessee = params.lessee ?? params.issuer;
+    assertValidDid(params.issuer, 'issuer');
+    if (lessee !== params.issuer) {
+        throw new Error('issuer must match lessee');
+    }
+    const payload = parseMarketCapabilityLeaseStartPayload({
+        listingId: params.listingId,
+        leaseId: params.leaseId,
+        lessee,
+        plan: params.plan,
+        credentials: params.credentials,
+        metadata: params.metadata,
+        expiresAt: params.expiresAt,
+        resourcePrev: params.resourcePrev,
+    });
+    const publicKey = publicKeyFromDid(params.issuer);
+    const baseEnvelope = buildEnvelope('market.capability.lease.start', params.issuer, publicKey, payload, params.ts, params.nonce, params.prev);
+    const hash = eventHashHex(baseEnvelope);
+    const sig = await signEvent(baseEnvelope, params.privateKey);
+    return { ...baseEnvelope, hash, sig };
+}
+async function createMarketCapabilityLeaseUpdateEnvelope(type, params) {
+    assertValidDid(params.issuer, 'issuer');
+    const payload = parseMarketCapabilityLeaseUpdatePayload({
+        leaseId: params.leaseId,
+        resourcePrev: params.resourcePrev,
+    });
+    const publicKey = publicKeyFromDid(params.issuer);
+    const baseEnvelope = buildEnvelope(type, params.issuer, publicKey, payload, params.ts, params.nonce, params.prev);
+    const hash = eventHashHex(baseEnvelope);
+    const sig = await signEvent(baseEnvelope, params.privateKey);
+    return { ...baseEnvelope, hash, sig };
+}
+export async function createMarketCapabilityLeasePauseEnvelope(params) {
+    return createMarketCapabilityLeaseUpdateEnvelope('market.capability.lease.pause', params);
+}
+export async function createMarketCapabilityLeaseResumeEnvelope(params) {
+    return createMarketCapabilityLeaseUpdateEnvelope('market.capability.lease.resume', params);
+}
+export async function createMarketCapabilityLeaseTerminateEnvelope(params) {
+    return createMarketCapabilityLeaseUpdateEnvelope('market.capability.lease.terminate', params);
+}
+export async function createMarketCapabilityInvokeEnvelope(params) {
+    assertValidDid(params.issuer, 'issuer');
+    const payload = parseMarketCapabilityInvokePayload({
+        leaseId: params.leaseId,
+        resource: params.resource,
+        units: params.units,
+        latency: params.latency,
+        success: params.success,
+        cost: params.cost,
+    });
+    const publicKey = publicKeyFromDid(params.issuer);
+    const baseEnvelope = buildEnvelope('market.capability.invoke', params.issuer, publicKey, payload, params.ts, params.nonce, params.prev);
+    const hash = eventHashHex(baseEnvelope);
+    const sig = await signEvent(baseEnvelope, params.privateKey);
+    return { ...baseEnvelope, hash, sig };
+}
+//# sourceMappingURL=events.js.map