project-cpu-mcp 0.12.0 → 0.12.2

package/dist/services/market/profile.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile.schemas.js","sourceRoot":"","sources":["../../../src/services/market/profile.schemas.ts"],"names":[],"mappings":"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"}

package/dist/services/market/profile.utils.d.ts

@@ -0,0 +1,2 @@
+export declare function pagePath(basePath: string, cursor: string | null): string;
+//# sourceMappingURL=profile.utils.d.ts.map

package/dist/services/market/profile.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile.utils.d.ts","sourceRoot":"","sources":["../../../src/services/market/profile.utils.ts"],"names":[],"mappings":"AAEA,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAMxE"}

package/dist/services/market/profile.utils.js

@@ -0,0 +1,8 @@
+import { MARKET_CURSOR_PARAM } from './constants.js';
+export function pagePath(basePath, cursor) {
+    if (cursor === null) {
+        return basePath;
+    }
+    return `${basePath}?${new URLSearchParams({ [MARKET_CURSOR_PARAM]: cursor }).toString()}`;
+}
+//# sourceMappingURL=profile.utils.js.map

package/dist/services/market/profile.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile.utils.js","sourceRoot":"","sources":["../../../src/services/market/profile.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAErD,MAAM,UAAU,QAAQ,CAAC,QAAgB,EAAE,MAAqB;IAC5D,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;QAClB,OAAO,QAAQ,CAAC;IACpB,CAAC;IAED,OAAO,GAAG,QAAQ,IAAI,IAAI,eAAe,CAAC,EAAE,CAAC,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC;AAC9F,CAAC"}

package/dist/services/market/purchase.constants.d.ts

@@ -0,0 +1,5 @@
+export declare const MARKET_PURCHASE_PREPARE_PATH = "/api/v1/market/purchases/prepare";
+export declare const PURCHASE_START_TIME_SKEW_SECONDS = 300;
+export declare const PURCHASE_EMPTY_CALLDATA = "0x";
+export declare const PURCHASE_NO_VALUE = "0";
+//# sourceMappingURL=purchase.constants.d.ts.map

package/dist/services/market/purchase.constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"purchase.constants.d.ts","sourceRoot":"","sources":["../../../src/services/market/purchase.constants.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,4BAA4B,qCAA0C,CAAC;AAEpF,eAAO,MAAM,gCAAgC,MAAM,CAAC;AAEpD,eAAO,MAAM,uBAAuB,OAAO,CAAC;AAE5C,eAAO,MAAM,iBAAiB,MAAM,CAAC"}

package/dist/services/market/purchase.constants.js

@@ -0,0 +1,6 @@
+import { MARKET_BASE_PATH } from './constants.js';
+export const MARKET_PURCHASE_PREPARE_PATH = `${MARKET_BASE_PATH}/purchases/prepare`;
+export const PURCHASE_START_TIME_SKEW_SECONDS = 300;
+export const PURCHASE_EMPTY_CALLDATA = '0x';
+export const PURCHASE_NO_VALUE = '0';
+//# sourceMappingURL=purchase.constants.js.map

package/dist/services/market/purchase.constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"purchase.constants.js","sourceRoot":"","sources":["../../../src/services/market/purchase.constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAElD,MAAM,CAAC,MAAM,4BAA4B,GAAG,GAAG,gBAAgB,oBAAoB,CAAC;AAEpF,MAAM,CAAC,MAAM,gCAAgC,GAAG,GAAG,CAAC;AAEpD,MAAM,CAAC,MAAM,uBAAuB,GAAG,IAAI,CAAC;AAE5C,MAAM,CAAC,MAAM,iBAAiB,GAAG,GAAG,CAAC"}

package/dist/services/market/purchase.service.d.ts

@@ -0,0 +1,48 @@
+import { type BuyCellRequest, type BuyCellResult, type IMarketPurchaseService, type MarketPurchaseServiceOptions } from './purchase.types.js';
+export declare class MarketPurchaseService implements IMarketPurchaseService {
+    private readonly client;
+    private readonly proof;
+    private readonly appConfig;
+    private readonly wallet;
+    private readonly network;
+    private readonly singleFlight;
+    private readonly recovery;
+    private readonly logger;
+    private readonly spenders;
+    constructor(options: MarketPurchaseServiceOptions);
+    buyCell(request: BuyCellRequest): Promise<BuyCellResult>;
+    private purchase;
+    private fulfil;
+    private settleKnownFulfilment;
+    private settle;
+    private forgetIfSettled;
+    private confirm;
+    private requireOwnedCell;
+    private prepare;
+    private requireTrustworthyPreparation;
+    private requirePinnedOrder;
+    private requireAffordableOrder;
+    private requireFulfilmentShape;
+    private requireCurrencyTransactions;
+    private requireExactApprovalAmount;
+    private requireRegisteredSpender;
+    private broadcastApproval;
+    private send;
+    private requireCellCollection;
+    private requireFulfilmentTransaction;
+    private requireWithinDeadline;
+    private requirePrepared;
+    private requireFulfilmentHash;
+    private requireUsableRequest;
+    private reserve;
+    private emptyPayload;
+    private result;
+    private lostBroadcast;
+    private knownHashes;
+    private unavailable;
+    private untrustworthy;
+    private rejectedInput;
+    private walletAddress;
+    private nowSeconds;
+}
+//# sourceMappingURL=purchase.service.d.ts.map

package/dist/services/market/purchase.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"purchase.service.d.ts","sourceRoot":"","sources":["../../../src/services/market/purchase.service.ts"],"names":[],"mappings":"AAqBA,OAAO,EAEH,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,sBAAsB,EAC3B,KAAK,4BAA4B,EAGpC,MAAM,qBAAqB,CAAC;AAiC7B,qBAAa,qBAAsB,YAAW,sBAAsB;IAChE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA0B;IACjD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAyB;IAC/C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAa;IACvC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;IACxC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAsB;IACnD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAuB;IAChD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAU;IACjC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAwB;gBAErC,OAAO,EAAE,4BAA4B;IAY3C,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC;YAYhD,QAAQ;YAmCR,MAAM;YA6BN,qBAAqB;YAcrB,MAAM;IAgCpB,OAAO,CAAC,eAAe;YAMT,OAAO;YAyCP,gBAAgB;YA0ChB,OAAO;YAkBP,6BAA6B;IAoC3C,OAAO,CAAC,kBAAkB;IA2B1B,OAAO,CAAC,sBAAsB;YAqBhB,sBAAsB;YA6DtB,2BAA2B;IAyCzC,OAAO,CAAC,0BAA0B;YA4BpB,wBAAwB;YA8BxB,iBAAiB;YAoBjB,IAAI;YASJ,qBAAqB;IAoBnC,OAAO,CAAC,4BAA4B;IAgBpC,OAAO,CAAC,qBAAqB;IAoB7B,OAAO,CAAC,eAAe;IAevB,OAAO,CAAC,qBAAqB;IAe7B,OAAO,CAAC,oBAAoB;IA4B5B,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,MAAM;IA+Bd,OAAO,CAAC,aAAa;IAqBrB,OAAO,CAAC,WAAW;IAQnB,OAAO,CAAC,WAAW;IAoBnB,OAAO,CAAC,aAAa;IAiBrB,OAAO,CAAC,aAAa;IAWrB,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,UAAU;CAGrB"}

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

@@ -0,0 +1,564 @@
+import { MarketActionTool, } from './action.types.js';
+import { narrowInvocationDeadline } from './budget.utils.js';
+import { MS_PER_SECOND } from './constants.js';
+import { MarketError } from './error.js';
+import { marketActionKey } from './idempotency.utils.js';
+import { sameAddress } from './listing.utils.js';
+import { MARKET_PURCHASE_PREPARE_PATH, PURCHASE_EMPTY_CALLDATA, PURCHASE_NO_VALUE, PURCHASE_START_TIME_SKEW_SECONDS, } from './purchase.constants.js';
+import { preparePurchaseResponseSchema, } from './purchase.types.js';
+import { effectivePurchaseDeadline, exceedsCeiling, isNativeCurrency, preparedNativeTotal, purchaseActionInputs, purchaseApprovals, purchaseFulfilment, sameOrderHash, } from './purchase.utils.js';
+import { cellTokenIdSchema, evmAddressSchema, MarketActionStage, MarketActionStatus, MarketErrorCode, MarketTransactionKind, orderHashSchema, positiveBaseUnitAmountSchema, } from './types.js';
+import { currencyApprovalCall } from '../../contracts/approval.utils.js';
+import { ERC721_OWNERSHIP_ABI } from '../../contracts/erc721.abi.js';
+import { SeaportSpenderReader } from '../../contracts/seaport-spender.reader.js';
+import { SEAPORT_ADDRESS } from '../../contracts/seaport.constants.js';
+import { SeaportSpenderOutcome } from '../../contracts/seaport.types.js';
+import { errorMessage } from '../../utils/error.utils.js';
+import { TxStatus } from '../../wallet/types.js';
+export class MarketPurchaseService {
+    client;
+    proof;
+    appConfig;
+    wallet;
+    network;
+    singleFlight;
+    recovery;
+    logger;
+    spenders;
+    constructor(options) {
+        this.spenders = new SeaportSpenderReader({ wallet: options.wallet });
+        this.client = options.client;
+        this.proof = options.proof;
+        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 buyCell(request) {
+        const validated = this.requireUsableRequest(request);
+        const key = marketActionKey({
+            wallet: this.walletAddress(),
+            network: this.network,
+            tool: MarketActionTool.BuyCell,
+            inputs: purchaseActionInputs(validated),
+        });
+        return this.singleFlight.run(key, async () => this.purchase(key, validated));
+    }
+    async purchase(key, request) {
+        const unresolved = this.recovery.read(key);
+        if (unresolved !== null && unresolved.payload.fulfilmentTxHash !== null) {
+            return this.settleKnownFulfilment(key, request, unresolved);
+        }
+        this.reserve(key, MarketActionStage.Prepare, this.emptyPayload());
+        let prepared;
+        try {
+            prepared = await this.prepare(request);
+        }
+        catch (error) {
+            this.recovery.forget(key);
+            throw error;
+        }
+        let payload = { prepared, approvalTxHashes: [], fulfilmentTxHash: null };
+        this.reserve(key, MarketActionStage.Prepare, payload);
+        for (const approval of purchaseApprovals(prepared)) {
+            let hash;
+            try {
+                hash = await this.broadcastApproval(approval, request);
+            }
+            catch (error) {
+                this.recovery.forget(key);
+                throw error;
+            }
+            payload = { ...payload, approvalTxHashes: [...payload.approvalTxHashes, hash] };
+            this.reserve(key, MarketActionStage.Approve, payload);
+        }
+        return this.fulfil(key, request, payload);
+    }
+    async fulfil(key, request, payload) {
+        let transaction;
+        try {
+            const prepared = this.requirePrepared(payload);
+            this.requireWithinDeadline(prepared, MarketActionStage.Fulfil);
+            transaction = this.requireFulfilmentTransaction(prepared, request);
+        }
+        catch (error) {
+            this.recovery.forget(key);
+            throw error;
+        }
+        let hash;
+        try {
+            hash = await this.send(transaction);
+        }
+        catch (error) {
+            this.reserve(key, MarketActionStage.Fulfil, payload);
+            throw this.lostBroadcast(request, payload, errorMessage(error));
+        }
+        const sent = { ...payload, fulfilmentTxHash: hash };
+        this.reserve(key, MarketActionStage.Fulfil, sent);
+        return this.settle(key, request, sent, MarketActionStatus.Completed);
+    }
+    async settleKnownFulfilment(key, request, record) {
+        this.logger.info('a purchase of this exact order is already on-chain — proving it instead of sending again', {
+            tokenId: request.tokenId,
+            orderHash: request.expectedOrderHash,
+            txHash: record.payload.fulfilmentTxHash,
+        });
+        return this.settle(key, request, record.payload, MarketActionStatus.AlreadyCompleted);
+    }
+    async settle(key, request, payload, status) {
+        const hash = this.requireFulfilmentHash(payload);
+        const receipt = await this.confirm(key, request, payload, hash);
+        try {
+            const collection = await this.requireCellCollection(MarketActionStage.Verify);
+            await this.proof.requireFulfilment({
+                receipt,
+                orderHash: request.expectedOrderHash,
+                wallet: this.walletAddress(),
+                stage: MarketActionStage.Verify,
+                boundCell: { collection, tokenId: request.tokenId },
+            });
+            await this.requireOwnedCell(request, hash);
+        }
+        catch (error) {
+            this.forgetIfSettled(key, error);
+            throw error;
+        }
+        this.recovery.forget(key);
+        return this.result(status, request, payload, hash);
+    }
+    // A terminal proof failure is the end of this intent: the transaction is mined and will never
+    // prove anything else, so holding its record would strand one of the bounded slots for the life
+    // of the process. A retryable one keeps its record, because repeating re-checks that same
+    // transaction instead of sending another.
+    forgetIfSettled(key, error) {
+        if (error instanceof MarketError && !error.retryable) {
+            this.recovery.forget(key);
+        }
+    }
+    async confirm(key, request, payload, hash) {
+        let receipt;
+        try {
+            receipt = await this.wallet.get().waitForReceipt(hash);
+        }
+        catch (error) {
+            throw new MarketError({
+                code: MarketErrorCode.OutcomeUnknown,
+                message: `The fulfilment of order ${request.expectedOrderHash} was broadcast as ${hash}, but its receipt ` +
+                    `could not be read: ${errorMessage(error)}. The transaction is kept, so repeating this call ` +
+                    're-checks that exact transaction instead of buying anything else.',
+                retryable: true,
+                retryAfterSeconds: null,
+                stage: MarketActionStage.Fulfil,
+                txHash: hash,
+            });
+        }
+        if (receipt.status === TxStatus.Success) {
+            return receipt;
+        }
+        this.recovery.forget(key);
+        throw new MarketError({
+            code: MarketErrorCode.TransactionReverted,
+            message: `The fulfilment of order ${request.expectedOrderHash} reverted on-chain, so Cell ${request.tokenId} ` +
+                `was not bought and nothing was paid beyond gas. ${this.knownHashes(payload, hash)} The order may ` +
+                'have been filled or cancelled meanwhile; read the market again and pick an exact order.',
+            retryable: false,
+            retryAfterSeconds: null,
+            stage: MarketActionStage.Fulfil,
+            txHash: hash,
+        });
+    }
+    async requireOwnedCell(request, hash) {
+        const collection = await this.requireCellCollection(MarketActionStage.Verify);
+        let owner;
+        try {
+            owner = (await this.wallet.get().readContract({
+                address: collection,
+                abi: ERC721_OWNERSHIP_ABI,
+                functionName: 'ownerOf',
+                args: [BigInt(request.tokenId)],
+            }));
+        }
+        catch (error) {
+            throw new MarketError({
+                code: MarketErrorCode.OutcomeUnknown,
+                message: `Order ${request.expectedOrderHash} was fulfilled by transaction ${hash}, but who owns Cell ` +
+                    `${request.tokenId} now could not be read: ${errorMessage(error)}. The transaction is kept, so ` +
+                    'repeating this call re-checks it instead of buying anything else.',
+                retryable: true,
+                retryAfterSeconds: null,
+                stage: MarketActionStage.Verify,
+                txHash: hash,
+            });
+        }
+        if (sameAddress(owner, this.walletAddress())) {
+            return;
+        }
+        throw new MarketError({
+            code: MarketErrorCode.WrongOwner,
+            message: `Order ${request.expectedOrderHash} was fulfilled by transaction ${hash}, but Cell ` +
+                `${request.tokenId} is owned by ${owner} rather than this wallet ${this.walletAddress()}. ` +
+                'The purchase is not reported as yours on that evidence.',
+            retryable: false,
+            retryAfterSeconds: null,
+            stage: MarketActionStage.Verify,
+            txHash: hash,
+        });
+    }
+    async prepare(request) {
+        const prepared = await this.client.sendOnce({
+            path: MARKET_PURCHASE_PREPARE_PATH,
+            method: 'POST',
+            body: {
+                tokenId: request.tokenId,
+                expectedOrderHash: request.expectedOrderHash,
+                maxAmount: request.maxAmount,
+            },
+            schema: preparePurchaseResponseSchema(this.wallet.get().getChainId()),
+            stage: MarketActionStage.Prepare,
+            label: `Preparing the purchase of order ${request.expectedOrderHash}`,
+        });
+        await this.requireTrustworthyPreparation(request, prepared);
+        return prepared;
+    }
+    async requireTrustworthyPreparation(request, prepared) {
+        const wallet = this.walletAddress();
+        const chainId = this.wallet.get().getChainId();
+        if (prepared.listing.chainId !== chainId) {
+            throw this.untrustworthy(MarketErrorCode.ChainMismatch, `it targets chain ${prepared.listing.chainId} while this wallet buys on chain ${chainId}`, request);
+        }
+        if (!sameAddress(prepared.listing.protocolAddress, SEAPORT_ADDRESS)) {
+            throw this.untrustworthy(MarketErrorCode.ProtocolAddressMismatch, `it names protocol contract ${prepared.listing.protocolAddress} instead of the pinned ${SEAPORT_ADDRESS}`, request);
+        }
+        this.requirePinnedOrder(request, prepared);
+        this.requireAffordableOrder(request, prepared);
+        if (sameAddress(prepared.listing.maker, wallet)) {
+            throw this.untrustworthy(MarketErrorCode.WrongOwner, `it is your own listing — this wallet ${wallet} is both the seller and the buyer`, request);
+        }
+        await this.requireFulfilmentShape(request, prepared);
+    }
+    requirePinnedOrder(request, prepared) {
+        const listing = prepared.listing;
+        if (!sameOrderHash(listing.orderHash, request.expectedOrderHash)) {
+            throw this.unavailable(request, `the marketplace answered with order ${listing.orderHash} instead of the order you pinned`);
+        }
+        if (listing.tokenId !== request.tokenId) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, `order ${listing.orderHash} sells Cell ${listing.tokenId} rather than the Cell ${request.tokenId} ` +
+                'you named', request);
+        }
+        const now = this.nowSeconds();
+        if (listing.expirationTime <= now) {
+            throw this.unavailable(request, `it expired at ${listing.expirationTime} and is no longer fillable`);
+        }
+        if (listing.startTime > now + PURCHASE_START_TIME_SKEW_SECONDS) {
+            throw this.unavailable(request, `it does not become fillable until ${listing.startTime}`);
+        }
+    }
+    requireAffordableOrder(request, prepared) {
+        const listing = prepared.listing;
+        if (exceedsCeiling(listing.price, request.maxAmount)) {
+            throw this.unavailable(request, `it now costs ${listing.price} ${listing.currency.symbol} base units, above the maxAmount ` +
+                `${request.maxAmount} you set — nothing was sent`);
+        }
+        const native = preparedNativeTotal(prepared);
+        if (exceedsCeiling(native, request.maxAmount)) {
+            throw this.unavailable(request, `its transactions would send ${native} native base units, above the maxAmount ` +
+                `${request.maxAmount} you set — nothing was sent`);
+        }
+    }
+    async requireFulfilmentShape(request, prepared) {
+        const chainId = this.wallet.get().getChainId();
+        const transactions = prepared.transactions;
+        const last = transactions.at(-1) ?? null;
+        if (last === null || last.kind !== MarketTransactionKind.Fulfillment) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, 'it does not end with the one fulfilment transaction that buys the Cell', request);
+        }
+        if (purchaseFulfilment(prepared) === null) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, 'it asks to send more than one fulfilment transaction for a single order', request);
+        }
+        if (last.data === PURCHASE_EMPTY_CALLDATA) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, 'its fulfilment transaction carries no calldata, so it would buy nothing', request);
+        }
+        if (!sameAddress(last.to, SEAPORT_ADDRESS)) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, `its fulfilment transaction would send the wallet's money to ${last.to} rather than to the pinned ` +
+                `protocol contract ${SEAPORT_ADDRESS}`, request);
+        }
+        const foreignChain = transactions.find((transaction) => transaction.chainId !== chainId);
+        if (foreignChain !== undefined) {
+            throw this.untrustworthy(MarketErrorCode.ChainMismatch, `it asks to send a "${foreignChain.kind}" transaction on chain ${foreignChain.chainId} while this ` +
+                `wallet buys on chain ${chainId}`, request);
+        }
+        const foreignKind = transactions
+            .slice(0, -1)
+            .find((transaction) => transaction.kind !== MarketTransactionKind.CurrencyApproval);
+        if (foreignKind !== undefined) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, `buying a listing may only need currency approvals before the fulfilment, but it asks to send a ` +
+                `"${foreignKind.kind}" transaction first`, request);
+        }
+        await this.requireCurrencyTransactions(request, prepared);
+    }
+    async requireCurrencyTransactions(request, prepared) {
+        const currency = prepared.listing.currency.address;
+        const approvals = purchaseApprovals(prepared);
+        if (isNativeCurrency(currency)) {
+            if (approvals.length > 0) {
+                throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, 'it asks to approve a currency for an order that is paid in the chain native coin', request);
+            }
+            return;
+        }
+        const foreignApproval = approvals.find((approval) => !sameAddress(approval.to, currency));
+        if (foreignApproval !== undefined) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, `it asks to approve contract ${foreignApproval.to} instead of the listing currency ${currency}`, request);
+        }
+        const valued = prepared.transactions.find((transaction) => transaction.value !== PURCHASE_NO_VALUE);
+        if (valued !== undefined) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, `it asks to send ${valued.value} native base units for an order priced in ` +
+                `${prepared.listing.currency.symbol}`, request);
+        }
+        const calls = approvals.map((approval) => this.requireExactApprovalAmount(request, approval, prepared));
+        await this.requireRegisteredSpender(request, calls);
+    }
+    requireExactApprovalAmount(request, transaction, prepared) {
+        const approval = currencyApprovalCall(transaction.data);
+        const price = prepared.listing.price;
+        if (approval === null) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, 'it asks to send calldata the listing currency would not read as an approval of a single exact ' +
+                'amount', request);
+        }
+        if (approval.amount !== BigInt(price)) {
+            throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, `it asks to approve ${approval.amount.toString()} of ${prepared.listing.currency.symbol} rather ` +
+                `than exactly the ${price} this listing costs`, request);
+        }
+        return approval;
+    }
+    async requireRegisteredSpender(request, approvals) {
+        for (const approval of approvals) {
+            const answer = await this.spenders.registeredSpender(approval.spender);
+            const detail = answer.detail ?? `${approval.spender} cannot be traced to the protocol`;
+            if (answer.outcome === SeaportSpenderOutcome.Unreachable) {
+                throw new MarketError({
+                    code: MarketErrorCode.NetworkFailure,
+                    message: `Order ${request.expectedOrderHash} was not fulfilled because ${detail}. Nothing was ` +
+                        'approved and nothing was paid.',
+                    retryable: true,
+                    retryAfterSeconds: null,
+                    stage: MarketActionStage.Prepare,
+                    txHash: null,
+                });
+            }
+            if (answer.outcome !== SeaportSpenderOutcome.Resolved) {
+                throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, `it asks the wallet to let ${approval.spender} spend the listing currency, and ${detail}`, request);
+            }
+        }
+    }
+    async broadcastApproval(transaction, request) {
+        const hash = await this.send(transaction);
+        const receipt = await this.wallet.get().waitForReceipt(hash);
+        if (receipt.status !== TxStatus.Success) {
+            throw new MarketError({
+                code: MarketErrorCode.TransactionReverted,
+                message: `The currency approval this purchase needs reverted on-chain, so order ` +
+                    `${request.expectedOrderHash} was never fulfilled and nothing was paid beyond gas.`,
+                retryable: false,
+                retryAfterSeconds: null,
+                stage: MarketActionStage.Approve,
+                txHash: hash,
+            });
+        }
+        return hash;
+    }
+    async send(transaction) {
+        return this.wallet.get().sendTransaction({
+            to: transaction.to,
+            data: transaction.data,
+            value: BigInt(transaction.value),
+            gas: null,
+        });
+    }
+    async requireCellCollection(stage) {
+        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 who owns the Cell after a ' +
+                    'purchase cannot be checked.',
+                retryable: false,
+                retryAfterSeconds: null,
+                stage,
+                txHash: null,
+            });
+        }
+        return collection;
+    }
+    requireFulfilmentTransaction(prepared, request) {
+        const fulfilment = purchaseFulfilment(prepared);
+        if (fulfilment !== null) {
+            return fulfilment;
+        }
+        throw this.untrustworthy(MarketErrorCode.InvalidMarketResponse, 'it carries no single fulfilment transaction to send', request);
+    }
+    requireWithinDeadline(prepared, stage) {
+        const deadline = effectivePurchaseDeadline(prepared);
+        narrowInvocationDeadline(deadline);
+        if (this.nowSeconds() < deadline) {
+            return;
+        }
+        throw new MarketError({
+            code: MarketErrorCode.PreparedIntentExpired,
+            message: 'This prepared purchase is past the earlier of its own deadline and the order expiry, so it can no ' +
+                'longer be sent. Nothing was bought. Call the tool again for the same exact order.',
+            retryable: false,
+            retryAfterSeconds: null,
+            stage,
+            txHash: null,
+        });
+    }
+    requirePrepared(payload) {
+        if (payload.prepared === null) {
+            throw new MarketError({
+                code: MarketErrorCode.InvalidMarketResponse,
+                message: 'The purchase has no prepared order to fulfil.',
+                retryable: false,
+                retryAfterSeconds: null,
+                stage: MarketActionStage.Fulfil,
+                txHash: null,
+            });
+        }
+        return payload.prepared;
+    }
+    requireFulfilmentHash(payload) {
+        if (payload.fulfilmentTxHash === null) {
+            throw new MarketError({
+                code: MarketErrorCode.InvalidMarketResponse,
+                message: 'The purchase has no broadcast fulfilment transaction to verify.',
+                retryable: false,
+                retryAfterSeconds: null,
+                stage: MarketActionStage.Verify,
+                txHash: null,
+            });
+        }
+        return payload.fulfilmentTxHash;
+    }
+    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 expectedOrderHash = orderHashSchema.safeParse(request.expectedOrderHash);
+        if (!expectedOrderHash.success) {
+            throw this.rejectedInput(`"${request.expectedOrderHash}" is not a Market order hash. Pass the exact 32-byte 0x-prefixed ` +
+                '`orderHash` of the listing you decided to buy — this tool never picks a listing for you.');
+        }
+        const maxAmount = positiveBaseUnitAmountSchema.safeParse(request.maxAmount);
+        if (!maxAmount.success) {
+            throw this.rejectedInput(`"${request.maxAmount}" is not a spending ceiling. Pass the most you are willing to pay as a ` +
+                'positive decimal integer of the currency base units, never a decimal fraction.');
+        }
+        return { tokenId: tokenId.data, expectedOrderHash: expectedOrderHash.data, maxAmount: maxAmount.data };
+    }
+    reserve(key, stage, payload) {
+        this.recovery.write(key, { tool: MarketActionTool.BuyCell, stage, payload });
+    }
+    emptyPayload() {
+        return { prepared: null, approvalTxHashes: [], fulfilmentTxHash: null };
+    }
+    result(status, request, payload, hash) {
+        const prepared = this.requirePrepared(payload);
+        this.logger.info('the Cell purchase is confirmed', {
+            tokenId: request.tokenId,
+            status,
+            orderHash: request.expectedOrderHash,
+            txHash: hash,
+        });
+        return {
+            status,
+            stage: MarketActionStage.Verify,
+            wallet: this.walletAddress(),
+            tokenId: request.tokenId,
+            orderHash: request.expectedOrderHash,
+            seller: prepared.listing.maker,
+            price: prepared.listing.price,
+            currency: prepared.listing.currency,
+            maxAmount: request.maxAmount,
+            approvalTxHashes: [...payload.approvalTxHashes],
+            fulfilmentTxHash: hash,
+            txHashes: [...payload.approvalTxHashes, hash],
+        };
+    }
+    lostBroadcast(request, payload, reason) {
+        this.logger.error('the fulfilment broadcast left an uncertain outcome', {
+            tokenId: request.tokenId,
+            orderHash: request.expectedOrderHash,
+            reason,
+        });
+        return new MarketError({
+            code: MarketErrorCode.NetworkFailure,
+            message: `The fulfilment of order ${request.expectedOrderHash} could not be confirmed as broadcast: ` +
+                `${reason}. No second fulfilment was sent in this call. ${this.knownHashes(payload, null)} ` +
+                'Repeating this call targets that same exact order and can never buy another listing; at worst it ' +
+                'spends gas on a transaction the protocol rejects.',
+            retryable: true,
+            retryAfterSeconds: null,
+            stage: MarketActionStage.Fulfil,
+            txHash: null,
+        });
+    }
+    knownHashes(payload, hash) {
+        const hashes = [...payload.approvalTxHashes, ...(hash === null ? [] : [hash])];
+        return hashes.length === 0
+            ? 'No transaction was broadcast.'
+            : `Transactions broadcast in order: ${hashes.join(', ')}.`;
+    }
+    unavailable(request, detail) {
+        this.logger.error('the pinned Market order cannot be bought', {
+            tokenId: request.tokenId,
+            orderHash: request.expectedOrderHash,
+            detail,
+        });
+        return new MarketError({
+            code: MarketErrorCode.OrderUnavailable,
+            message: `Order ${request.expectedOrderHash} cannot be bought: ${detail}. No replacement listing was ` +
+                'selected and nothing was bought. Read the market again and pass another exact `expectedOrderHash` ' +
+                'if you still want that Cell.',
+            retryable: false,
+            retryAfterSeconds: null,
+            stage: MarketActionStage.Prepare,
+            txHash: null,
+        });
+    }
+    untrustworthy(code, detail, request) {
+        this.logger.error('the prepared purchase does not match the request', {
+            tokenId: request.tokenId,
+            orderHash: request.expectedOrderHash,
+            detail,
+        });
+        return new MarketError({
+            code,
+            message: `The prepared purchase of order ${request.expectedOrderHash} cannot be sent: ${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=purchase.service.js.map