@bananapus/nana-sdk-core 2.28.0 → 2.29.0

package/dist/cjs/v6/defifa.js

@@ -0,0 +1,684 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefifaNftTransactionRevertedError = exports.MAX_DEFIFA_ACTION_NFTS = void 0;
+exports.defifaPhaseAllowsPay = defifaPhaseAllowsPay;
+exports.defifaPhaseAllowsCashOut = defifaPhaseAllowsCashOut;
+exports.buildDefifaPayMetadata = buildDefifaPayMetadata;
+exports.prepareDefifaPay = prepareDefifaPay;
+exports.prepareDefifaCashOut = prepareDefifaCashOut;
+exports.prepareDefifaTransfer = prepareDefifaTransfer;
+exports.restoreDefifaNftReceiptContext = restoreDefifaNftReceiptContext;
+exports.verifyDefifaNftReceipt = verifyDefifaNftReceipt;
+exports.verifyDefifaNftTransaction = verifyDefifaNftTransaction;
+const viem_1 = require("viem");
+const juicebox_js_1 = require("../generated/juicebox.js");
+const hook_js_1 = require("../utils/hook.js");
+const cashOut_js_1 = require("./cashOut.js");
+const nft_js_1 = require("./nft.js");
+const nftInventory_js_1 = require("./nftInventory.js");
+const pay_js_1 = require("./pay.js");
+const terminals_js_1 = require("./terminals.js");
+const defifaDeployments_js_1 = require("./defifaDeployments.js");
+const relayr_js_1 = require("../review/relayr.js");
+const writeRecovery_js_1 = require("../review/writeRecovery.js");
+// @ballkidz/defifa 1.0.2 native getters. Provenance belongs to nftInventory.
+const defifaActionAbi = (0, viem_1.parseAbi)([
+    "function defaultAttestationDelegate() view returns (address)",
+    "function getTierDelegateOf(address,uint256) view returns (address)",
+    "function gamePhaseReporter() view returns (address)",
+    "function noContestTriggeredFor(uint256) view returns (bool)",
+    "function tokensClaimableFor(uint256[]) view returns (uint256,uint256)",
+    "function DEFIFA_TOKEN() view returns (address)",
+    "function BASE_PROTOCOL_TOKEN() view returns (address)",
+]);
+/** Adapter RPC/review budget, not a native protocol supply or metadata limit. */
+exports.MAX_DEFIFA_ACTION_NFTS = 128;
+/** Phase-only display eligibility; preparation still authenticates current rules. */
+function defifaPhaseAllowsPay(phase) {
+    return phase === 1;
+}
+/** NO_CONTEST additionally requires native activation, checked by preparation. */
+function defifaPhaseAllowsCashOut(phase) {
+    return phase === 1 || phase === 2 || phase === 4 || phase === 5;
+}
+function assertActionSize(count) {
+    if (count < 1 || count > exports.MAX_DEFIFA_ACTION_NFTS)
+        throw new Error(`Defifa preparations accept 1–${exports.MAX_DEFIFA_ACTION_NFTS} NFTs per action.`);
+}
+function address(value, label, allowZero = false) {
+    if (!(0, viem_1.isAddress)(value) || (!allowZero && value === viem_1.zeroAddress))
+        throw new Error(`${label} must be a valid${allowZero ? "" : " nonzero"} address.`);
+    return value;
+}
+function sameAddress(left, right) {
+    return left.toLowerCase() === right.toLowerCase();
+}
+/**
+ * Native Defifa pay payload: (address attestationDelegate, uint16[] tierIds).
+ * Resolve metadataIdTarget from an authenticated inventory's CODE_ORIGIN, never
+ * its clone address. This pure encoder validates inputs, not contract identity.
+ * Zero delegates through the game's configured default, or to the beneficiary.
+ * For a self-payment this updates delegation for ALL holdings in selected tiers.
+ * Generic build721PayMetadata is incompatible: its true boolean becomes address 1.
+ */
+function buildDefifaPayMetadata({ metadataIdTarget, tierIdsToMint, attestationDelegate = viem_1.zeroAddress, }) {
+    address(metadataIdTarget, "Defifa metadataIdTarget");
+    address(attestationDelegate, "Defifa attestation delegate", true);
+    if (tierIdsToMint.length === 0 ||
+        tierIdsToMint.some((id, index) => typeof id !== "bigint" ||
+            id < 1n ||
+            id > 65535n ||
+            (index > 0 && id < tierIdsToMint[index - 1]))) {
+        throw new Error("Defifa tier IDs must be nonempty, ascending positive uint16 values; repeats mint multiple NFTs.");
+    }
+    return (0, hook_js_1.createHookMetadata)([(0, hook_js_1.hookMetadataId)(metadataIdTarget, "pay")], [
+        (0, viem_1.encodeAbiParameters)([{ type: "address" }, { type: "uint16[]" }], [attestationDelegate, tierIdsToMint.map(Number)]),
+    ]);
+}
+async function actionContext(client, args, blockNumber) {
+    address(args.account, "Defifa account");
+    if (args.expectedHook)
+        address(args.expectedHook, "Defifa expected hook");
+    if (args.projectId <= 0n)
+        throw new Error("Defifa projectId must be positive.");
+    const inventory = await (0, nftInventory_js_1.getProjectNftInventory)(client, {
+        chainId: args.chainId,
+        projectId: args.projectId,
+        tierLimit: 1,
+        blockNumber,
+    });
+    if (inventory?.protocol !== "defifa")
+        throw new Error("Project is not an authenticated native Defifa game.");
+    if (args.expectedHook && !sameAddress(inventory.hook, args.expectedHook))
+        throw new Error("Defifa collection changed since review.");
+    const snapshot = {
+        ...client,
+        readContract: (parameters) => client.readContract({
+            ...parameters,
+            blockNumber: inventory.blockNumber,
+        }),
+    };
+    return { inventory, snapshot };
+}
+async function paymentTerminal(snapshot, args, inventory) {
+    const terminal = await (0, terminals_js_1.resolvePaymentTerminal)(snapshot, {
+        chainId: args.chainId,
+        projectId: args.projectId,
+        token: inventory.pricing.token,
+    });
+    if (terminal.isRouter)
+        throw new Error("Defifa settlement token has no primary terminal.");
+    const context = await snapshot.readContract({
+        address: terminal.address,
+        abi: juicebox_js_1.jbMultiTerminalAbi,
+        functionName: "accountingContextForTokenOf",
+        args: [args.projectId, inventory.pricing.token],
+    });
+    if (!sameAddress(context.token, inventory.pricing.token) ||
+        Number(context.currency) !== inventory.pricing.currency ||
+        Number(context.decimals) !== inventory.pricing.decimals)
+        throw new Error("Defifa terminal accounting does not match native pricing.");
+    return terminal.address;
+}
+/**
+ * Fresh native identity, MINT phase, selected supply and exact tier cost at one
+ * block. Re-run after review and compare the entire request before execution.
+ * ERC20 payments need allowance; after approval, simulate this EXACT request
+ * with account before sending. Preparation does not grant execution authority.
+ * Donations are separate addToBalanceOf calls: native Defifa rejects overpayment.
+ */
+async function prepareDefifaPay(client, args) {
+    assertActionSize(args.tierIdsToMint.length);
+    args = { ...args, tierIdsToMint: [...args.tierIdsToMint] };
+    const beneficiary = address(args.beneficiary ?? args.account, "Defifa beneficiary");
+    const attestationDelegate = args.attestationDelegate ?? viem_1.zeroAddress;
+    // Validate before any RPC. The real metadata target comes from fresh identity.
+    buildDefifaPayMetadata({
+        metadataIdTarget: beneficiary,
+        tierIdsToMint: args.tierIdsToMint,
+        attestationDelegate,
+    });
+    const { inventory, snapshot } = await actionContext(client, args);
+    if (!defifaPhaseAllowsPay(inventory.phase) ||
+        inventory.ruleset.metadata.pausePay ||
+        !inventory.ruleset.metadata.useDataHookForPay)
+        throw new Error("Defifa NFT entry is not open.");
+    const counts = new Map();
+    for (const tierId of args.tierIdsToMint)
+        counts.set(tierId, (counts.get(tierId) ?? 0n) + 1n);
+    const [terminal, configuredDelegate, selectedTiers] = await Promise.all([
+        paymentTerminal(snapshot, args, inventory),
+        snapshot.readContract({
+            address: inventory.hook,
+            abi: defifaActionAbi,
+            functionName: "defaultAttestationDelegate",
+        }),
+        Promise.all([...counts].map(async ([tierId, count]) => {
+            const tier = await snapshot.readContract({
+                address: inventory.store,
+                abi: juicebox_js_1.jb721TiersHookStoreAbi,
+                functionName: "tierOf",
+                args: [inventory.hook, tierId, false],
+            });
+            if (BigInt(tier.id) !== tierId || BigInt(tier.remainingSupply) < count)
+                throw new Error(`Defifa tier ${tierId} is unavailable for the selected quantity.`);
+            return {
+                tierId,
+                count,
+                unitPrice: (0, nft_js_1.effectiveTierPrice)(tier.price, tier.discountPercent),
+            };
+        })),
+    ]);
+    const amount = selectedTiers.reduce((sum, tier) => sum + tier.unitPrice * tier.count, 0n);
+    const metadata = buildDefifaPayMetadata({
+        metadataIdTarget: inventory.implementation,
+        tierIdsToMint: args.tierIdsToMint,
+        attestationDelegate,
+    });
+    const resolvedDelegate = attestationDelegate !== viem_1.zeroAddress
+        ? attestationDelegate
+        : configuredDelegate !== viem_1.zeroAddress
+            ? configuredDelegate
+            : beneficiary;
+    const effectiveDelegates = await Promise.all([...counts.keys()].map(async (tierId) => {
+        if (sameAddress(args.account, beneficiary))
+            return { tierId, delegate: resolvedDelegate };
+        const prior = await snapshot.readContract({
+            address: inventory.hook,
+            abi: defifaActionAbi,
+            functionName: "getTierDelegateOf",
+            args: [beneficiary, tierId],
+        });
+        return { tierId, delegate: prior === viem_1.zeroAddress ? beneficiary : prior };
+    }));
+    return {
+        inventory,
+        amount,
+        selectedTiers,
+        attestationDelegate,
+        effectiveAttestationDelegate: new Set(effectiveDelegates.map(({ delegate }) => delegate.toLowerCase()))
+            .size === 1
+            ? effectiveDelegates[0].delegate
+            : null,
+        effectiveDelegates,
+        transaction: (0, pay_js_1.buildPayTx)({
+            chainId: args.chainId,
+            terminal,
+            projectId: args.projectId,
+            token: inventory.pricing.token,
+            amount,
+            beneficiary,
+            minReturnedTokens: 0n,
+            memo: args.memo,
+            metadata,
+        }),
+    };
+}
+async function requireOwner(snapshot, hook, tokenId, account) {
+    const owner = await snapshot.readContract({
+        address: hook,
+        abi: viem_1.erc721Abi,
+        functionName: "ownerOf",
+        args: [tokenId],
+    });
+    if (!sameAddress(owner, account))
+        throw new Error(`Defifa NFT ${tokenId} is not owned by the sender.`);
+}
+/** Fresh owner/phase checks and exact cashOutTokensOf simulation, with no ERC721 approval. */
+async function prepareDefifaCashOut(client, args) {
+    assertActionSize(args.tokenIds.length);
+    args = { ...args, tokenIds: [...args.tokenIds] };
+    const beneficiary = address(args.beneficiary ?? args.account, "Defifa beneficiary");
+    const minimumReclaim = args.minimumReclaim ?? 0n;
+    if (minimumReclaim < 0n)
+        throw new Error("Defifa minimum reclaim cannot be negative.");
+    const tokenIds = [...args.tokenIds];
+    (0, cashOut_js_1.build721CashOutMetadata)({ metadataIdTarget: beneficiary, tokenIds });
+    const { inventory, snapshot } = await actionContext(client, args);
+    if (!defifaPhaseAllowsCashOut(inventory.phase))
+        throw new Error("Defifa NFT cash-out is not available in this phase.");
+    if (inventory.phase === 5) {
+        const reporter = await snapshot.readContract({
+            address: inventory.hook,
+            abi: defifaActionAbi,
+            functionName: "gamePhaseReporter",
+        });
+        const activated = await snapshot.readContract({
+            address: reporter,
+            abi: defifaActionAbi,
+            functionName: "noContestTriggeredFor",
+            args: [args.projectId],
+        });
+        if (!activated)
+            throw new Error("Defifa no-contest must be activated before refunds.");
+    }
+    await Promise.all(tokenIds.map((tokenId) => requireOwner(snapshot, inventory.hook, tokenId, args.account)));
+    const terminal = await paymentTerminal(snapshot, args, inventory);
+    const transaction = (0, cashOut_js_1.buildCashOutTx)({
+        chainId: args.chainId,
+        terminal,
+        holder: args.account,
+        projectId: args.projectId,
+        cashOutCount: 0n,
+        tokenToReclaim: inventory.pricing.token,
+        minTokensReclaimed: minimumReclaim,
+        beneficiary,
+        metadata: (0, cashOut_js_1.build721CashOutMetadata)({
+            metadataIdTarget: inventory.implementation,
+            tokenIds,
+        }),
+    });
+    const [simulation, rewards, defifaToken, baseProtocolToken] = await Promise.all([
+        client.simulateContract({
+            ...transaction,
+            account: args.account,
+            blockNumber: inventory.blockNumber,
+        }),
+        snapshot.readContract({
+            address: inventory.hook,
+            abi: defifaActionAbi,
+            functionName: "tokensClaimableFor",
+            args: [tokenIds],
+        }),
+        snapshot.readContract({
+            address: inventory.hook,
+            abi: defifaActionAbi,
+            functionName: "DEFIFA_TOKEN",
+        }),
+        snapshot.readContract({
+            address: inventory.hook,
+            abi: defifaActionAbi,
+            functionName: "BASE_PROTOCOL_TOKEN",
+        }),
+    ]);
+    const [defifaDecimals, baseProtocolDecimals] = await Promise.all([
+        snapshot.readContract({
+            address: defifaToken,
+            abi: viem_1.erc20Abi,
+            functionName: "decimals",
+        }),
+        snapshot.readContract({
+            address: baseProtocolToken,
+            abi: viem_1.erc20Abi,
+            functionName: "decimals",
+        }),
+    ]);
+    return {
+        inventory,
+        transaction,
+        reclaimAmount: simulation.result,
+        protocolRewards: {
+            defifaToken,
+            defifaAmount: rewards[0],
+            defifaDecimals,
+            baseProtocolToken,
+            baseProtocolAmount: rewards[1],
+            baseProtocolDecimals,
+        },
+    };
+}
+/** Standard NFT transfer; native pause flags and receiver callbacks are simulated exactly. */
+async function prepareDefifaTransfer(client, args) {
+    args = { ...args };
+    address(args.recipient, "Defifa recipient");
+    if (args.tokenId <= 0n)
+        throw new Error("Defifa tokenId must be positive.");
+    const { inventory, snapshot } = await actionContext(client, args);
+    await requireOwner(snapshot, inventory.hook, args.tokenId, args.account);
+    const transaction = {
+        chainId: args.chainId,
+        address: inventory.hook,
+        abi: viem_1.erc721Abi,
+        functionName: "safeTransferFrom",
+        args: [args.account, args.recipient, args.tokenId],
+    };
+    await client.simulateContract({
+        ...transaction,
+        account: args.account,
+        blockNumber: inventory.blockNumber,
+    });
+    return { inventory, transaction };
+}
+const defifaEffectAbi = (0, viem_1.parseAbi)([
+    "event Mint(uint256 indexed tokenId,uint256 indexed tierId,address indexed beneficiary,uint256 totalAmountContributed,address caller)",
+    "event ClaimedTokens(address indexed beneficiary,uint256 defifaTokenAmount,uint256 baseProtocolTokenAmount,address caller)",
+]);
+function requireNativeMetadata(metadata, expected) {
+    if (expected.toLowerCase() !== metadata.toLowerCase())
+        throw new Error("Receipt does not prove the exact reviewed Defifa NFT effects.");
+}
+function payTierIds(metadata, implementation) {
+    const [delegate, ids] = (0, viem_1.decodeAbiParameters)([{ type: "address" }, { type: "uint16[]" }], `0x${metadata.slice(130)}`);
+    const tierIds = ids.map(BigInt);
+    requireNativeMetadata(metadata, buildDefifaPayMetadata({
+        metadataIdTarget: implementation,
+        attestationDelegate: delegate,
+        tierIdsToMint: tierIds,
+    }));
+    return tierIds;
+}
+function cashOutTokenIds(metadata, implementation) {
+    const [tokenIds] = (0, viem_1.decodeAbiParameters)([{ type: "uint256[]" }], `0x${metadata.slice(130)}`);
+    requireNativeMetadata(metadata, (0, cashOut_js_1.build721CashOutMetadata)({
+        metadataIdTarget: implementation,
+        tokenIds: [...tokenIds],
+    }));
+    return [...tokenIds];
+}
+/**
+ * Reconstruct native verification context from an existing reviewed-write
+ * journal. Authenticate the project/terminal at the receipt's historical block;
+ * never prepare, simulate or send a new action. The wallet-returned identity is
+ * required: a hashless uncertain write cannot be matched to an old receipt.
+ * Call verifyDefifaNftTransaction afterward; restoration alone proves no outcome.
+ */
+async function restoreDefifaNftReceiptContext(client, args) {
+    args = { ...args, receipt: { ...args.receipt } };
+    const saved = (0, writeRecovery_js_1.parseReviewedWriteRecoveryRecord)(args.record);
+    function fail() {
+        throw new Error("Saved call is not the reviewed native Defifa action. Keep this attempt pending.");
+    }
+    if (saved.chainId !== args.chainId ||
+        !saved.hash ||
+        (!saved.safe &&
+            saved.hash.toLowerCase() !==
+                args.receipt.transactionHash.toLowerCase()) ||
+        typeof args.receipt.blockNumber !== "bigint" ||
+        args.receipt.blockNumber < 0n)
+        fail();
+    const identity = {
+        chainId: args.chainId,
+        projectId: args.projectId,
+        account: saved.account,
+        expectedHook: args.expectedHook,
+    };
+    const { inventory, snapshot } = await actionContext(client, identity, args.receipt.blockNumber);
+    let transaction;
+    if (sameAddress(saved.call.to, inventory.hook)) {
+        const call = (0, viem_1.decodeFunctionData)({ abi: viem_1.erc721Abi, data: saved.call.data });
+        if (call.functionName !== "safeTransferFrom" || call.args.length !== 3)
+            fail();
+        const [from, recipient, tokenId] = call.args;
+        if (!sameAddress(from, saved.account) || tokenId <= 0n)
+            fail();
+        address(recipient, "Defifa recipient");
+        transaction = {
+            chainId: args.chainId,
+            address: inventory.hook,
+            abi: viem_1.erc721Abi,
+            functionName: "safeTransferFrom",
+            args: [from, recipient, tokenId],
+        };
+    }
+    else {
+        const terminal = await paymentTerminal(snapshot, identity, inventory);
+        if (!sameAddress(saved.call.to, terminal))
+            fail();
+        const call = (0, viem_1.decodeFunctionData)({
+            abi: juicebox_js_1.jbMultiTerminalAbi,
+            data: saved.call.data,
+        });
+        if (call.functionName === "pay") {
+            const [projectId, token, amount, beneficiary, minimum, memo, metadata] = call.args;
+            if (projectId !== args.projectId ||
+                !sameAddress(token, inventory.pricing.token))
+                fail();
+            payTierIds(metadata, inventory.implementation);
+            transaction = (0, pay_js_1.buildPayTx)({
+                chainId: args.chainId,
+                terminal,
+                projectId,
+                token,
+                amount,
+                beneficiary,
+                minReturnedTokens: minimum,
+                memo,
+                metadata,
+            });
+        }
+        else if (call.functionName === "cashOutTokensOf") {
+            const [holder, projectId, count, token, minimum, beneficiary, metadata] = call.args;
+            if (projectId !== args.projectId ||
+                !sameAddress(holder, saved.account) ||
+                !sameAddress(token, inventory.pricing.token) ||
+                count !== 0n)
+                fail();
+            cashOutTokenIds(metadata, inventory.implementation);
+            transaction = (0, cashOut_js_1.buildCashOutTx)({
+                chainId: args.chainId,
+                terminal,
+                projectId,
+                holder,
+                cashOutCount: count,
+                tokenToReclaim: token,
+                minTokensReclaimed: minimum,
+                beneficiary,
+                metadata,
+            });
+        }
+        else
+            fail();
+    }
+    const data = transaction.functionName === "safeTransferFrom"
+        ? (0, viem_1.encodeFunctionData)(transaction)
+        : (0, viem_1.encodeFunctionData)(transaction);
+    if (data.toLowerCase() !== saved.call.data.toLowerCase() ||
+        ("value" in transaction ? transaction.value : 0n) !==
+            BigInt(saved.call.value))
+        fail();
+    return {
+        hook: inventory.hook,
+        implementation: inventory.implementation,
+        account: saved.account,
+        transaction,
+        ...(saved.safe ? { safe: { proposalHash: saved.hash } } : {}),
+    };
+}
+/**
+ * Verify native NFT effects of one exact reviewed call; throw if proof is missing.
+ * The execution engine MUST first authenticate the canonical receipt and actual
+ * chain/account/call/value (including the executed inner call for Safe routes).
+ * This pure check is also usable during recovery without preparing a new action.
+ * Receipt logs, not end-of-block ownership, prove transfers: a receiver may
+ * forward an NFT in its callback or a later transaction in the same block.
+ */
+function verifyDefifaNftReceipt({ hook, implementation, account, transaction }, receipt) {
+    address(hook, "Defifa receipt hook");
+    address(account, "Defifa receipt account");
+    const deployment = defifaDeployments_js_1.defifaDeployments[transaction.chainId];
+    if (!deployment || !sameAddress(implementation, deployment.implementation))
+        throw new Error("Defifa receipt context does not match the pinned chain implementation.");
+    if (receipt.status !== "success")
+        throw new Error("Defifa transaction did not succeed.");
+    const hookLogs = receipt.logs.filter((log) => sameAddress(log.address, hook));
+    const transfers = (0, viem_1.parseEventLogs)({
+        abi: viem_1.erc721Abi,
+        eventName: "Transfer",
+        logs: hookLogs,
+    });
+    const fail = () => {
+        throw new Error("Receipt does not prove the exact reviewed Defifa NFT effects.");
+    };
+    if (transaction.functionName === "safeTransferFrom") {
+        const [from, recipient, tokenId] = transaction.args;
+        if (!sameAddress(transaction.address, hook) || !sameAddress(from, account))
+            fail();
+        if (transfers.filter(({ args }) => sameAddress(args.from, from) &&
+            sameAddress(args.to, recipient) &&
+            args.tokenId === tokenId).length !== 1)
+            fail();
+        return;
+    }
+    const terminalLogs = receipt.logs.filter((log) => sameAddress(log.address, transaction.address));
+    if (transaction.functionName === "pay") {
+        const [projectId, , amount, beneficiary, , memo, metadata] = transaction.args;
+        const tierIds = payTierIds(metadata, implementation);
+        const payments = (0, viem_1.parseEventLogs)({
+            abi: juicebox_js_1.jbMultiTerminalAbi,
+            eventName: "Pay",
+            logs: terminalLogs,
+        }).filter(({ args }) => args.projectId === projectId &&
+            sameAddress(args.payer, account) &&
+            sameAddress(args.beneficiary, beneficiary) &&
+            args.amount === amount &&
+            args.memo === memo &&
+            args.metadata.toLowerCase() === metadata.toLowerCase() &&
+            sameAddress(args.caller, account));
+        const mints = (0, viem_1.parseEventLogs)({
+            abi: defifaEffectAbi,
+            eventName: "Mint",
+            logs: hookLogs,
+        });
+        if (payments.length !== 1 ||
+            mints.length !== tierIds.length ||
+            new Set(mints.map(({ args }) => args.tokenId)).size !== mints.length)
+            fail();
+        for (const [index, mint] of mints.entries()) {
+            if (mint.args.tierId !== tierIds[index] ||
+                !sameAddress(mint.args.beneficiary, beneficiary) ||
+                mint.args.totalAmountContributed !== amount ||
+                !sameAddress(mint.args.caller, transaction.address))
+                fail();
+            if (transfers.filter(({ args }) => args.from === viem_1.zeroAddress &&
+                sameAddress(args.to, beneficiary) &&
+                args.tokenId === mint.args.tokenId).length !== 1)
+                fail();
+        }
+        return;
+    }
+    const [holder, projectId, cashOutCount, , minimum, beneficiary, metadata] = transaction.args;
+    const tokenIds = cashOutTokenIds(metadata, implementation);
+    if (!sameAddress(holder, account) || cashOutCount !== 0n)
+        fail();
+    const cashOuts = (0, viem_1.parseEventLogs)({
+        abi: juicebox_js_1.jbMultiTerminalAbi,
+        eventName: "CashOutTokens",
+        logs: terminalLogs,
+    }).filter(({ args }) => args.projectId === projectId &&
+        sameAddress(args.holder, holder) &&
+        sameAddress(args.beneficiary, beneficiary) &&
+        args.cashOutCount === 0n &&
+        args.reclaimAmount >= minimum &&
+        args.metadata.toLowerCase() === metadata.toLowerCase() &&
+        sameAddress(args.caller, account));
+    const burns = transfers.filter(({ args }) => sameAddress(args.from, holder) && args.to === viem_1.zeroAddress);
+    if (cashOuts.length !== 1 ||
+        burns.length !== tokenIds.length ||
+        tokenIds.some((id) => burns.filter(({ args }) => args.tokenId === id).length !== 1))
+        fail();
+    if (cashOuts[0].args.reclaimAmount === 0n) {
+        const claims = (0, viem_1.parseEventLogs)({
+            abi: defifaEffectAbi,
+            eventName: "ClaimedTokens",
+            logs: hookLogs,
+        });
+        if (!claims.some(({ args }) => sameAddress(args.beneficiary, beneficiary) &&
+            sameAddress(args.caller, transaction.address) &&
+            (args.defifaTokenAmount > 0n || args.baseProtocolTokenAmount > 0n)))
+            fail();
+    }
+}
+/**
+ * The exact reviewed action failed in a canonical finalized block. This closes
+ * only that attempt; retain its evidence and review any new intent separately.
+ * A reverted Safe outer executor alone does not establish this outcome.
+ */
+class DefifaNftTransactionRevertedError extends Error {
+    constructor(hash, chainId) {
+        super("The reviewed Defifa transaction failed onchain and is finalized.");
+        this.hash = hash;
+        this.chainId = chainId;
+        this.name = "DefifaNftTransactionRevertedError";
+    }
+}
+exports.DefifaNftTransactionRevertedError = DefifaNftTransactionRevertedError;
+/**
+ * Authenticate canonical execution using the SDK's existing transaction/Safe
+ * proof owners, then prove native NFT effects. Only
+ * DefifaNftTransactionRevertedError proves finalized failure. Retain context
+ * and receipt on other errors and retry this read-only function; do not resend.
+ */
+async function verifyDefifaNftTransaction(client, context, receipt) {
+    const { transaction, account } = context;
+    const call = {
+        to: transaction.address,
+        data: transaction.functionName === "safeTransferFrom"
+            ? (0, viem_1.encodeFunctionData)(transaction)
+            : (0, viem_1.encodeFunctionData)(transaction),
+        value: "value" in transaction ? transaction.value : 0n,
+    };
+    const actualPromise = client.getTransaction({
+        hash: receipt.transactionHash,
+    });
+    const canonicalPromise = client.getTransactionReceipt({
+        hash: receipt.transactionHash,
+    });
+    const [chainId, actual, canonical] = await Promise.all([
+        client.getChainId(),
+        actualPromise,
+        canonicalPromise,
+    ]);
+    if (chainId !== transaction.chainId ||
+        canonical.blockHash !== receipt.blockHash ||
+        canonical.blockNumber !== receipt.blockNumber ||
+        canonical.transactionHash.toLowerCase() !==
+            receipt.transactionHash.toLowerCase())
+        throw new Error("Defifa receipt identity is unavailable or changed; keep this transaction pending.");
+    // Both existing proof owners read this same exact transaction/receipt. Reuse
+    // the fetched evidence rather than issue duplicate RPC reads or copy checks.
+    const proofClient = {
+        ...client,
+        getTransaction: async () => actual,
+        getTransactionReceipt: async () => canonical,
+    };
+    const record = {
+        version: 1,
+        id: "defifa-nft",
+        chainId: transaction.chainId,
+        account,
+        safe: Boolean(context.safe),
+        hash: context.safe?.proposalHash ?? receipt.transactionHash,
+        call: { ...call, value: call.value.toString() },
+    };
+    if (context.safe) {
+        const status = await (0, writeRecovery_js_1.verifyReviewedWriteReceipt)(proofClient, record, canonical);
+        if (status !== "success")
+            throw new DefifaNftTransactionRevertedError(canonical.transactionHash, chainId);
+    }
+    else {
+        if (!sameAddress(actual.from, account))
+            throw new Error("Defifa transaction sender does not match the reviewed account.");
+        try {
+            await (0, relayr_js_1.verifyRelayrDestination)(proofClient, {
+                entry: {
+                    chain: transaction.chainId,
+                    target: call.to,
+                    data: call.data,
+                    value: call.value.toString(),
+                },
+                hash: receipt.transactionHash,
+            });
+        }
+        catch (error) {
+            if (!(error instanceof relayr_js_1.RelayrDestinationRevertedError))
+                throw error;
+            // Exact call/account proof precedes finality. The existing reviewed-write
+            // owner rejects nonfinal receipts and reorgs before this attempt releases.
+            const status = await (0, writeRecovery_js_1.verifyReviewedWriteReceipt)(proofClient, record, canonical);
+            if (status !== "failed")
+                throw error;
+            throw new DefifaNftTransactionRevertedError(canonical.transactionHash, chainId);
+        }
+    }
+    // The caller's supplied logs may be stale or fabricated. Only fresh canonical
+    // logs are admitted to the native effect verifier, including log identities.
+    if (canonical.logs.some((log) => log.removed !== false ||
+        log.transactionHash?.toLowerCase() !==
+            canonical.transactionHash.toLowerCase() ||
+        log.blockHash?.toLowerCase() !== canonical.blockHash.toLowerCase() ||
+        log.blockNumber !== canonical.blockNumber ||
+        log.transactionIndex !== canonical.transactionIndex))
+        throw new Error("Defifa receipt logs are not bound to the canonical transaction.");
+    verifyDefifaNftReceipt(context, canonical);
+}
+//# sourceMappingURL=defifa.js.map