project-cpu-mcp 0.12.0 → 0.12.2

package/dist/services/market/listing.service.js

@@ -0,0 +1,671 @@
+import { zeroAddress, zeroHash } from 'viem';
+import { MarketActionTool, } from './action.types.js';
+import { narrowInvocationDeadline, waitOnInvocationBudget } from './budget.utils.js';
+import { MS_PER_SECOND, PROVEN_UNPUBLISHED_MARKET_ERROR_CODES, USDG_CENT_BASE_UNITS } from './constants.js';
+import { MarketError } from './error.js';
+import { marketActionKey } from './idempotency.utils.js';
+import { LISTING_NO_IDENTIFIER, LISTING_SINGLE_UNIT, LISTING_START_TIME_SKEW_SECONDS, LISTING_SUBMIT_MAX_ATTEMPTS, MARKET_LISTING_PREPARE_PATH, MARKET_LISTING_SUBMIT_PATH, } from './listing.constants.js';
+import { MarketScanOutcome, prepareListingResponseSchemaFor, submitListingResponseSchemaFor, } from './listing.types.js';
+import { effectiveListingDeadline, isEquivalentActiveListing, listingActionInputs, sameAddress, sameOptionalAddress, seaportSignableOrder, sumBaseUnits, } from './listing.utils.js';
+import { MARKET_PROFILE_CACHE_MS, MARKET_RECONCILE_MAX_PAGES } from './recovery.constants.js';
+import { cellTokenIdSchema, evmAddressSchema, MarketActionStage, MarketActionStatus, MarketErrorCode, MarketTransactionKind, positiveBaseUnitAmountSchema, unixSecondsSchema, } from './types.js';
+import { collectionApprovalCall } from '../../contracts/approval.utils.js';
+import { SeaportSpenderReader } from '../../contracts/seaport-spender.reader.js';
+import { OPENSEA_SIGNED_ZONE_V2, SEAPORT_ADDRESS, SEAPORT_DOMAIN_NAME, SEAPORT_DOMAIN_VERSION, SEAPORT_ORDER_COMPONENTS_TYPES, SEAPORT_ORDER_PRIMARY_TYPE, } from '../../contracts/seaport.constants.js';
+import { SeaportItemType, SeaportOrderType, SeaportSpenderOutcome, } from '../../contracts/seaport.types.js';
+import { TxStatus } from '../../wallet/types.js';
+export class MarketListingService {
+    client;
+    profile;
+    appConfig;
+    wallet;
+    network;
+    singleFlight;
+    recovery;
+    logger;
+    spenders;
+    lastProfileReadAt = null;
+    constructor(options) {
+        this.spenders = new SeaportSpenderReader({ wallet: options.wallet });
+        this.client = options.client;
+        this.profile = options.profile;
+        this.appConfig = options.appConfig;
+        this.wallet = options.wallet;
+        this.network = options.network;
+        this.singleFlight = options.singleFlight;
+        this.recovery = options.recovery;
+        this.logger = options.logger;
+    }
+    async listCell(request) {
+        const validated = this.requireUsableRequest(request);
+        const key = marketActionKey({
+            wallet: this.walletAddress(),
+            network: this.network,
+            tool: MarketActionTool.ListCell,
+            inputs: listingActionInputs(validated),
+        });
+        return this.singleFlight.run(key, async () => this.publish(key, validated));
+    }
+    async publish(key, request) {
+        const unresolved = this.recovery.read(key);
+        if (unresolved !== null && unresolved.payload.prepared !== null) {
+            return this.resume(key, request, unresolved);
+        }
+        this.reserve(key, MarketActionStage.Reconcile, this.emptyPayload());
+        let payload = this.emptyPayload();
+        try {
+            await this.requireNoEquivalentActiveListing(request);
+            const prepared = await this.prepare(request);
+            payload = { prepared, signature: null, approvalTxHashes: [] };
+            this.reserve(key, MarketActionStage.Prepare, payload);
+            payload = { ...payload, approvalTxHashes: await this.broadcastApprovals(prepared) };
+            this.reserve(key, MarketActionStage.Approve, payload);
+            payload = { ...payload, signature: await this.sign(prepared) };
+            this.reserve(key, MarketActionStage.Sign, payload);
+        }
+        catch (error) {
+            this.recovery.forget(key);
+            throw error;
+        }
+        return this.submit(key, request, payload, false);
+    }
+    async resume(key, request, record) {
+        const payload = record.payload;
+        const prepared = payload.prepared;
+        if (prepared === null) {
+            this.recovery.forget(key);
+            return this.publish(key, request);
+        }
+        if (this.nowSeconds() >= effectiveListingDeadline(prepared)) {
+            return this.reconcileExpired(key, request, prepared);
+        }
+        if (payload.signature === null) {
+            const resumed = {
+                ...payload,
+                approvalTxHashes: await this.broadcastApprovals(prepared),
+            };
+            const signed = { ...resumed, signature: await this.sign(prepared) };
+            this.reserve(key, MarketActionStage.Sign, signed);
+            return this.submit(key, request, signed, false);
+        }
+        return this.submit(key, request, payload, record.stage === MarketActionStage.Submit);
+    }
+    async submit(key, request, payload, submittedBefore) {
+        const prepared = this.requirePrepared(payload);
+        let reachedServer = submittedBefore;
+        for (let attempt = 1; attempt <= LISTING_SUBMIT_MAX_ATTEMPTS; attempt += 1) {
+            this.requireWithinDeadline(prepared, MarketActionStage.Submit);
+            const priorSubmission = reachedServer;
+            reachedServer = true;
+            try {
+                const response = await this.client.sendOnce({
+                    path: MARKET_LISTING_SUBMIT_PATH,
+                    method: 'POST',
+                    body: { prepareId: prepared.prepareId, signature: payload.signature },
+                    schema: submitListingResponseSchemaFor(this.wallet.get().getChainId()),
+                    stage: MarketActionStage.Submit,
+                    label: `Publishing the listing for Cell ${request.tokenId}`,
+                });
+                this.recovery.forget(key);
+                return this.result(MarketActionStatus.Completed, request, payload, response.listing);
+            }
+            catch (error) {
+                if (this.provenUnpublished(error, priorSubmission)) {
+                    this.recovery.forget(key);
+                    throw error;
+                }
+                this.reserve(key, MarketActionStage.Submit, payload);
+                this.logger.warn('the listing submit left an uncertain outcome — reconciling before any retry', {
+                    tokenId: request.tokenId,
+                    attempt,
+                });
+                const published = await this.reconcile(request, MarketActionStage.Submit);
+                if (published !== null) {
+                    this.recovery.forget(key);
+                    return this.result(MarketActionStatus.AlreadyCompleted, request, payload, published);
+                }
+                if (error instanceof MarketError && !error.retryable) {
+                    throw this.outcomeUnknown(request, MarketActionStage.Submit);
+                }
+            }
+        }
+        throw this.outcomeUnknown(request, MarketActionStage.Submit);
+    }
+    provenUnpublished(error, priorSubmission) {
+        return (!priorSubmission &&
+            error instanceof MarketError &&
+            !error.retryable &&
+            PROVEN_UNPUBLISHED_MARKET_ERROR_CODES.has(error.code));
+    }
+    async reconcileExpired(key, request, prepared) {
+        const published = await this.reconcile(request, MarketActionStage.Reconcile);
+        if (published !== null) {
+            this.recovery.forget(key);
+            return this.result(MarketActionStatus.AlreadyCompleted, request, { prepared, signature: null, approvalTxHashes: [] }, published);
+        }
+        this.recovery.forget(key);
+        throw new MarketError({
+            code: MarketErrorCode.PreparedIntentExpired,
+            message: `The prepared listing for Cell ${request.tokenId} ran out of time before it could be published, ` +
+                'and no matching listing is active. Call the tool again to prepare a fresh listing.',
+            retryable: false,
+            retryAfterSeconds: null,
+            stage: MarketActionStage.Reconcile,
+            txHash: null,
+        });
+    }
+    async reconcile(request, stage) {
+        await this.waitForProfileCacheHorizon();
+        let scan;
+        try {
+            scan = await this.scanActiveListings(request);
+        }
+        catch (error) {
+            this.logger.error('cannot reconcile an uncertain listing against the marketplace', {
+                tokenId: request.tokenId,
+                error,
+            });
+            throw this.outcomeUnknown(request, stage);
+        }
+        if (scan.outcome === MarketScanOutcome.Exhausted) {
+            this.logger.error('the active listings run past the pages this tool may read, so nothing is settled', {
+                tokenId: request.tokenId,
+                pages: MARKET_RECONCILE_MAX_PAGES,
+            });
+            throw this.outcomeUnknown(request, stage);
+        }
+        return scan.listing;
+    }
+    async requireNoEquivalentActiveListing(request) {
+        const scan = await this.scanActiveListings(request);
+        if (scan.outcome === MarketScanOutcome.Exhausted) {
+            throw new MarketError({
+                code: MarketErrorCode.OutcomeUnknown,
+                message: `Your active listings run past the ${MARKET_RECONCILE_MAX_PAGES} pages this tool reads, so it ` +
+                    `cannot rule out that Cell ${request.tokenId} already carries an equivalent listing, and it ` +
+                    'will not prepare another one blindly. Cancel listings you no longer need, then call the tool ' +
+                    'again.',
+                retryable: true,
+                retryAfterSeconds: null,
+                stage: MarketActionStage.Reconcile,
+                txHash: null,
+            });
+        }
+        const active = scan.listing;
+        if (active === null) {
+            return;
+        }
+        throw new MarketError({
+            code: MarketErrorCode.ActiveOrderExists,
+            message: `Cell ${request.tokenId} already carries an active listing of yours at this price and expiry ` +
+                `(order ${active.orderHash}). A public listing and a listing reserved for one buyer look the same ` +
+                'from outside, so publishing another one could duplicate your order. Cancel that order first if ' +
+                'you meant to replace it.',
+            retryable: false,
+            retryAfterSeconds: null,
+            stage: MarketActionStage.Reconcile,
+            txHash: null,
+        });
+    }
+    async scanActiveListings(request) {
+        const wallet = this.walletAddress();
+        let cursor = null;
+        for (let page = 0; page < MARKET_RECONCILE_MAX_PAGES; page += 1) {
+            const listings = await this.profile.getMyListings(cursor);
+            this.lastProfileReadAt = Date.now();
+            const candidates = listings.items.filter((listing) => listing.tokenId === request.tokenId && listing.price === request.price);
+            for (const candidate of candidates) {
+                try {
+                    const details = await this.profile.getOrderDetails(candidate.orderHash);
+                    if (details.orderKind === 'listing' && isEquivalentActiveListing(details.order, request, wallet)) {
+                        return { outcome: MarketScanOutcome.Found, listing: details.order };
+                    }
+                }
+                catch (error) {
+                    if (error instanceof MarketError &&
+                        (error.code === MarketErrorCode.StaleListing || error.code === MarketErrorCode.StaleOffer)) {
+                        continue;
+                    }
+                    throw error;
+                }
+            }
+            cursor = listings.nextCursor;
+            if (cursor === null) {
+                return { outcome: MarketScanOutcome.Absent, listing: null };
+            }
+        }
+        return { outcome: MarketScanOutcome.Exhausted, listing: null };
+    }
+    async waitForProfileCacheHorizon() {
+        if (this.lastProfileReadAt === null) {
+            return;
+        }
+        const remaining = MARKET_PROFILE_CACHE_MS - (Date.now() - this.lastProfileReadAt);
+        if (remaining > 0) {
+            this.logger.info('waiting for the marketplace read snapshot to advance before reconciling', { remaining });
+            await waitOnInvocationBudget(remaining);
+        }
+    }
+    async prepare(request) {
+        const body = {
+            tokenId: request.tokenId,
+            price: request.price,
+            expirationTime: request.expirationTime,
+        };
+        if (request.buyerAddress !== null) {
+            body.buyerAddress = request.buyerAddress;
+        }
+        const contracts = await this.requireMarketContracts();
+        const prepared = await this.client.send({
+            path: MARKET_LISTING_PREPARE_PATH,
+            method: 'POST',
+            body,
+            schema: prepareListingResponseSchemaFor(request),
+            stage: MarketActionStage.Prepare,
+            label: `Preparing the listing for Cell ${request.tokenId}`,
+        });
+        this.requireSupportedPricePrecision(request, prepared, contracts.usdg);
+        await this.requireTrustworthyPreparation(request, prepared, contracts.collection);
+        return prepared;
+    }
+    async requireMarketContracts() {
+        const config = await this.appConfig.load();
+        const collection = config.contracts.land;
+        if (!evmAddressSchema.safeParse(collection).success) {
+            throw new MarketError({
+                code: MarketErrorCode.InvalidMarketResponse,
+                message: 'The Cell collection contract is not configured for this network, so the order a listing asks ' +
+                    'the wallet to sign cannot be checked against the collection it must offer.',
+                retryable: false,
+                retryAfterSeconds: null,
+                stage: MarketActionStage.Prepare,
+                txHash: null,
+            });
+        }
+        return { collection, usdg: config.contracts.usdg };
+    }
+    requireSupportedPricePrecision(request, prepared, usdg) {
+        if (evmAddressSchema.safeParse(usdg).success &&
+            sameAddress(prepared.listing.currency.address, usdg) &&
+            BigInt(request.price) % USDG_CENT_BASE_UNITS !== 0n) {
+            throw this.rejectedInput(`"${request.price}" is not a valid USDG listing price. Pass a positive decimal integer in whole ` +
+                'cent increments: 10000 base units is $0.01.');
+        }
+    }
+    async requireTrustworthyPreparation(request, prepared, collection) {
+        const wallet = this.walletAddress();
+        const chainId = this.wallet.get().getChainId();
+        if (prepared.chainId !== chainId) {
+            throw this.untrustworthy(MarketErrorCode.ChainMismatch, `it targets chain ${prepared.chainId} while this wallet signs for chain ${chainId}`, request);
+        }
+        if (!sameAddress(prepared.protocolAddress, SEAPORT_ADDRESS)) {
+            throw this.untrustworthy(MarketErrorCode.ProtocolAddressMismatch, `it names protocol contract ${prepared.protocolAddress} instead of the pinned ${SEAPORT_ADDRESS}`, request);
+        }
+        if (!sameAddress(prepared.listing.maker, wallet) || !sameAddress(prepared.order.offerer, wallet)) {
+            throw this.untrustworthy(MarketErrorCode.WrongOwner, `it sells on behalf of ${prepared.listing.maker} rather than this wallet ${wallet}`, request);
+        }
+        this.requireRequestedTerms(request, prepared);
+        this.requireFeeArithmetic(request, prepared);
+        await this.requireApprovalsOnly(request, prepared, collection);
+        this.requireOfferedCell(request, prepared, collection);
+        this.requireOrderShape(request, prepared);
+        this.requireConsideration(request, prepared);
+    }
+    requireRequestedTerms(request, prepared) {
+        const listing = prepared.listing;
+        if (listing.tokenId !== request.tokenId) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, `it sells Cell ${listing.tokenId} instead of Cell ${request.tokenId}`, request);
+        }
+        if (listing.price !== request.price) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, `its gross price is ${listing.price} instead of the requested ${request.price}`, request);
+        }
+        if (listing.expirationTime !== request.expirationTime) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, `it expires at ${listing.expirationTime} instead of the requested ${request.expirationTime}`, request);
+        }
+        if (!sameOptionalAddress(listing.buyerAddress, request.buyerAddress)) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, `its reserved buyer is ${listing.buyerAddress ?? 'nobody'} instead of ` +
+                `${request.buyerAddress ?? 'nobody'}`, request);
+        }
+        if (listing.startTime > this.nowSeconds() + LISTING_START_TIME_SKEW_SECONDS) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, `it does not become fillable until ${listing.startTime}, so it would not be the listing you asked ` +
+                'for now', request);
+        }
+    }
+    requireFeeArithmetic(request, prepared) {
+        const fees = prepared.fees;
+        const total = sumBaseUnits([fees.platformFee, fees.creatorFee, fees.estimatedProceeds]);
+        if (total !== prepared.listing.price) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, `its platform fee, creator fee and proceeds add up to ${total} rather than the gross price ` +
+                `${prepared.listing.price}`, request);
+        }
+    }
+    async requireApprovalsOnly(request, prepared, collection) {
+        const chainId = this.wallet.get().getChainId();
+        const foreign = prepared.transactions.find((transaction) => transaction.kind !== MarketTransactionKind.CollectionApproval || transaction.chainId !== chainId);
+        if (foreign !== undefined) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, `publishing a listing may only need collection approvals, but it asks to send a "${foreign.kind}" ` +
+                `transaction on chain ${foreign.chainId}`, request);
+        }
+        const operators = prepared.transactions.map((transaction) => this.requireCollectionOperator(request, transaction, collection));
+        await this.requireOrderOperator(request, prepared, operators);
+    }
+    requireCollectionOperator(request, transaction, collection) {
+        if (!sameAddress(transaction.to, collection)) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, `it asks the wallet to approve contract ${transaction.to} instead of the Cell collection ` +
+                `${collection}`, request);
+        }
+        const approval = collectionApprovalCall(transaction.data);
+        if (approval === null) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, 'it asks the wallet to send calldata the Cell collection would not read as approving one operator', request);
+        }
+        if (!approval.approved) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, `it asks the wallet to withdraw ${approval.operator}'s approval rather than grant the one a ` +
+                'listing needs', request);
+        }
+        return approval;
+    }
+    async requireOrderOperator(request, prepared, approvals) {
+        if (approvals.length === 0) {
+            return;
+        }
+        const conduitKey = prepared.order.conduitKey;
+        const answer = await this.spenders.spenderForConduitKey(conduitKey);
+        const detail = answer.detail ?? `conduit key ${conduitKey} resolves to nothing`;
+        if (answer.outcome === SeaportSpenderOutcome.Unreachable) {
+            throw new MarketError({
+                code: MarketErrorCode.NetworkFailure,
+                message: `The listing for Cell ${request.tokenId} was not signed because ${detail}. Nothing was ` +
+                    'approved and nothing was published.',
+                retryable: true,
+                retryAfterSeconds: null,
+                stage: MarketActionStage.Prepare,
+                txHash: null,
+            });
+        }
+        if (answer.address === null) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, `the order it asks the wallet to sign settles through an operator this client cannot justify: ` +
+                `${detail}`, request);
+        }
+        const operator = answer.address;
+        const stranger = approvals.find((approval) => !sameAddress(approval.operator, operator));
+        if (stranger !== undefined) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, `it asks the wallet to let ${stranger.operator} move every Cell it owns, while the order it signs ` +
+                `is settled by ${operator}`, request);
+        }
+    }
+    requireOfferedCell(request, prepared, collection) {
+        const order = prepared.order;
+        const sold = order.offer.length === 1 ? (order.offer[0] ?? null) : null;
+        if (sold === null || sold.identifierOrCriteria !== request.tokenId) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, `the order it asks the wallet to sign does not offer exactly Cell ${request.tokenId}`, request);
+        }
+        if (sold.itemType !== SeaportItemType.Erc721) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, `the order it asks the wallet to sign offers item type ${sold.itemType} rather than the ERC-721 Cell`, request);
+        }
+        if (!sameAddress(sold.token, collection)) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, `the order it asks the wallet to sign offers a token of collection ${sold.token} instead of the ` +
+                `Cell collection ${collection}`, request);
+        }
+        if (sold.startAmount !== LISTING_SINGLE_UNIT || sold.endAmount !== LISTING_SINGLE_UNIT) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, `the order it asks the wallet to sign offers ${sold.startAmount} units of the Cell rather than one`, request);
+        }
+    }
+    requireOrderShape(request, prepared) {
+        const order = prepared.order;
+        const reserved = request.buyerAddress !== null;
+        const openPublic = order.orderType === SeaportOrderType.FullOpen &&
+            sameAddress(order.zone, zeroAddress) &&
+            order.zoneHash === zeroHash;
+        const signedZonePublic = order.orderType === SeaportOrderType.FullRestricted &&
+            sameAddress(order.zone, OPENSEA_SIGNED_ZONE_V2) &&
+            order.zoneHash === zeroHash;
+        if (!reserved && !openPublic && !signedZonePublic) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, `the order it asks the wallet to sign is neither a full-open zero-zone listing nor a ` +
+                `full-restricted listing through the pinned signed zone ${OPENSEA_SIGNED_ZONE_V2}`, request);
+        }
+        if (reserved && (order.orderType !== SeaportOrderType.FullRestricted || sameAddress(order.zone, zeroAddress))) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, 'the order it asks the wallet to sign names no zone, so nothing would hold the sale to the buyer ' +
+                'you reserved it for', request);
+        }
+        if (order.startTime !== prepared.listing.startTime.toString()) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, `the order it asks the wallet to sign becomes fillable at ${order.startTime} instead of the ` +
+                `prepared ${prepared.listing.startTime}`, request);
+        }
+        if (order.endTime !== request.expirationTime.toString()) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, `the order it asks the wallet to sign ends at ${order.endTime} instead of ${request.expirationTime}`, request);
+        }
+    }
+    requireConsideration(request, prepared) {
+        const order = prepared.order;
+        const currency = prepared.listing.currency.address;
+        const expected = sameAddress(currency, zeroAddress) ? SeaportItemType.Native : SeaportItemType.Erc20;
+        const payments = [...order.consideration];
+        if (request.buyerAddress !== null) {
+            const marker = payments.pop();
+            const sold = order.offer[0];
+            this.requirePrivateSaleMarker(request, marker, sold);
+        }
+        if (payments.length === 0) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, 'the order it asks the wallet to sign pays the seller side nothing at all', request);
+        }
+        if (order.totalOriginalConsiderationItems !== order.consideration.length) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, `the order it asks the wallet to sign declares ${order.totalOriginalConsiderationItems} original ` +
+                `consideration items while carrying ${order.consideration.length}`, request);
+        }
+        for (const item of payments) {
+            this.requireConsiderationItem(request, item, currency, expected);
+        }
+        const paid = sumBaseUnits(payments.map((item) => item.startAmount));
+        if (paid !== prepared.listing.price) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, `the order it asks the wallet to sign collects ${paid} for the seller side rather than the gross ` +
+                `price ${prepared.listing.price}`, request);
+        }
+        const kept = sumBaseUnits(payments
+            .filter((item) => sameAddress(item.recipient, this.walletAddress()))
+            .map((item) => item.startAmount));
+        if (BigInt(kept) < BigInt(prepared.fees.estimatedProceeds)) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, `the order it asks the wallet to sign pays this wallet ${kept} while its fee preview promises ` +
+                `${prepared.fees.estimatedProceeds}`, request);
+        }
+    }
+    requirePrivateSaleMarker(request, marker, sold) {
+        const buyer = request.buyerAddress;
+        const exactMarker = buyer !== null &&
+            marker !== undefined &&
+            sold !== undefined &&
+            marker.itemType === sold.itemType &&
+            sameAddress(marker.token, sold.token) &&
+            marker.identifierOrCriteria === sold.identifierOrCriteria &&
+            marker.startAmount === sold.startAmount &&
+            marker.endAmount === sold.endAmount &&
+            sameAddress(marker.recipient, buyer);
+        if (!exactMarker) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, 'its last consideration item is not the exact offered Cell delivered to the reserved buyer', request);
+        }
+    }
+    requireConsiderationItem(request, item, currency, expected) {
+        if (!sameAddress(item.token, currency)) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, `the order it asks the wallet to sign pays part of the price in ${item.token} instead of the ` +
+                `listing currency ${currency}`, request);
+        }
+        if (item.itemType !== expected) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, `the order it asks the wallet to sign pays part of the price as item type ${item.itemType} instead ` +
+                `of ${expected}`, request);
+        }
+        if (item.identifierOrCriteria !== LISTING_NO_IDENTIFIER) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, `the order it asks the wallet to sign pays part of the price with token ` +
+                `${item.identifierOrCriteria} rather than a plain amount`, request);
+        }
+        if (item.startAmount !== item.endAmount) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, `the order it asks the wallet to sign starts a payment at ${item.startAmount} and ends it at ` +
+                `${item.endAmount}, so it could be filled for less than the price you set`, request);
+        }
+    }
+    async broadcastApprovals(prepared) {
+        const hashes = [];
+        for (const transaction of prepared.transactions) {
+            hashes.push(await this.broadcast(transaction));
+        }
+        return hashes;
+    }
+    async broadcast(transaction) {
+        const wallet = this.wallet.get();
+        const hash = await wallet.sendTransaction({
+            to: transaction.to,
+            data: transaction.data,
+            value: BigInt(transaction.value),
+            gas: null,
+        });
+        const receipt = await wallet.waitForReceipt(hash);
+        if (receipt.status !== TxStatus.Success) {
+            throw new MarketError({
+                code: MarketErrorCode.TransactionReverted,
+                message: `The collection approval this listing needs reverted on-chain, so the listing was never ` +
+                    'signed or published.',
+                retryable: false,
+                retryAfterSeconds: null,
+                stage: MarketActionStage.Approve,
+                txHash: hash,
+            });
+        }
+        return hash;
+    }
+    async sign(prepared) {
+        this.requireWithinDeadline(prepared, MarketActionStage.Sign);
+        return this.wallet.get().signTypedData({
+            domain: {
+                name: SEAPORT_DOMAIN_NAME,
+                version: SEAPORT_DOMAIN_VERSION,
+                chainId: prepared.chainId,
+                verifyingContract: prepared.protocolAddress,
+            },
+            types: SEAPORT_ORDER_COMPONENTS_TYPES,
+            primaryType: SEAPORT_ORDER_PRIMARY_TYPE,
+            message: seaportSignableOrder(prepared.order),
+        });
+    }
+    requireWithinDeadline(prepared, stage) {
+        const deadline = effectiveListingDeadline(prepared);
+        narrowInvocationDeadline(deadline);
+        if (this.nowSeconds() < deadline) {
+            return;
+        }
+        throw new MarketError({
+            code: MarketErrorCode.PreparedIntentExpired,
+            message: 'This prepared listing is past the earlier of its own deadline and the order expiry, so it can no ' +
+                'longer be signed or published. Call the tool again to prepare a fresh listing.',
+            retryable: false,
+            retryAfterSeconds: null,
+            stage,
+            txHash: null,
+        });
+    }
+    requirePrepared(payload) {
+        if (payload.prepared === null) {
+            throw new MarketError({
+                code: MarketErrorCode.InvalidMarketResponse,
+                message: 'The listing has no prepared order to publish.',
+                retryable: false,
+                retryAfterSeconds: null,
+                stage: MarketActionStage.Submit,
+                txHash: null,
+            });
+        }
+        return payload.prepared;
+    }
+    requireUsableRequest(request) {
+        const tokenId = cellTokenIdSchema.safeParse(request.tokenId);
+        if (!tokenId.success) {
+            throw this.rejectedInput(`"${request.tokenId}" is not a canonical Cell token id. Pass a decimal integer with no leading ` +
+                'zeroes so that one Cell keeps one identity.');
+        }
+        const price = positiveBaseUnitAmountSchema.safeParse(request.price);
+        if (!price.success) {
+            throw this.rejectedInput(`"${request.price}" is not a listing price. Pass the gross amount a buyer pays as a positive ` +
+                'decimal integer of the currency base units, never a decimal fraction.');
+        }
+        const expirationTime = unixSecondsSchema.safeParse(request.expirationTime);
+        if (!expirationTime.success || expirationTime.data <= this.nowSeconds()) {
+            throw this.rejectedInput(`${request.expirationTime} is not a future expiry. Pass the Unix second at which the listing ` +
+                'should stop being fillable.');
+        }
+        const buyerAddress = request.buyerAddress;
+        if (buyerAddress !== null && !evmAddressSchema.safeParse(buyerAddress).success) {
+            throw this.rejectedInput(`"${buyerAddress}" is not an address. Pass the one wallet allowed to buy this listing, or null to ` +
+                'let anyone buy it.');
+        }
+        return {
+            tokenId: tokenId.data,
+            price: price.data,
+            expirationTime: expirationTime.data,
+            buyerAddress,
+        };
+    }
+    reserve(key, stage, payload) {
+        this.recovery.write(key, { tool: MarketActionTool.ListCell, stage, payload });
+    }
+    emptyPayload() {
+        return { prepared: null, signature: null, approvalTxHashes: [] };
+    }
+    result(status, request, payload, listing) {
+        const prepared = this.requirePrepared(payload);
+        this.logger.info('the Cell listing is published', {
+            tokenId: request.tokenId,
+            status,
+            orderHash: listing.orderHash,
+        });
+        return {
+            status,
+            stage: MarketActionStage.Submit,
+            wallet: this.walletAddress(),
+            tokenId: request.tokenId,
+            listing,
+            grossPrice: prepared.listing.price,
+            currency: prepared.listing.currency,
+            platformFee: prepared.fees.platformFee,
+            creatorFee: prepared.fees.creatorFee,
+            estimatedProceeds: prepared.fees.estimatedProceeds,
+            approvalTxHashes: [...payload.approvalTxHashes],
+        };
+    }
+    outcomeUnknown(request, stage) {
+        return new MarketError({
+            code: MarketErrorCode.OutcomeUnknown,
+            message: `The listing for Cell ${request.tokenId} was submitted but its outcome could not be confirmed, and ` +
+                'the marketplace cannot be read to settle the question. The exact prepared order is kept, so ' +
+                'repeating this call republishes the same order rather than creating a second one.',
+            retryable: true,
+            retryAfterSeconds: null,
+            stage,
+            txHash: null,
+        });
+    }
+    untrustworthy(code, detail, request) {
+        this.logger.error('the prepared listing does not match the request', { tokenId: request.tokenId, detail });
+        return new MarketError({
+            code,
+            message: `The prepared listing for Cell ${request.tokenId} cannot be signed: ${detail}.`,
+            retryable: false,
+            retryAfterSeconds: null,
+            stage: MarketActionStage.Prepare,
+            txHash: null,
+        });
+    }
+    rejectedInput(message) {
+        return new MarketError({
+            code: MarketErrorCode.InvalidInput,
+            message,
+            retryable: false,
+            retryAfterSeconds: null,
+            stage: MarketActionStage.Prepare,
+            txHash: null,
+        });
+    }
+    walletAddress() {
+        return this.wallet.get().getAddress();
+    }
+    nowSeconds() {
+        return Math.floor(Date.now() / MS_PER_SECOND);
+    }
+}
+//# sourceMappingURL=listing.service.js.map