Verify listings on-chain

curl "https://exclusivo.one/v1/collections/{id}/sales?limit=1"
# → data[0].tx        the transaction hash
# → data[0].orderId   the Seaport order hash we claim it filled

import { createPublicClient, http, parseAbiItem, decodeEventLog } from "viem";
import { mainnet } from "viem/chains";

const SEAPORT = new Set([
  "0x00000000000000adc04c56bf30ac9d3c0aaf14dc", // 1.5
  "0x0000000000000068f116a894984e2db1123eb395", // 1.6
]);
const EXCLUSIVO_ZONE = "0xcd93552140bf932842dbc767d0c6cc75f2ba680c";

const ORDER_FULFILLED = parseAbiItem(
  "event OrderFulfilled(bytes32 orderHash, address indexed offerer, address indexed zone, address recipient, (uint8 itemType, address token, uint256 identifier, uint256 amount)[] offer, (uint8 itemType, address token, uint256 identifier, uint256 amount, address recipient)[] consideration)"
);

const client = createPublicClient({ chain: mainnet, transport: http(RPC_URL) });
const receipt = await client.getTransactionReceipt({ hash });

const fills = [];
for (const log of receipt.logs) {
  if (!SEAPORT.has(log.address.toLowerCase())) continue;

  let decoded;
  try {
    decoded = decodeEventLog({ abi: [ORDER_FULFILLED], data: log.data, topics: log.topics });
  } catch {
    continue; // some other Seaport event
  }

  // The whole attribution check is this one comparison.
  if (decoded.args.zone.toLowerCase() !== EXCLUSIVO_ZONE) continue;
  fills.push(decoded.args);
}

const sum = (items) => items.reduce((total, item) => total + item.amount, 0n);

function decodeListingFill(args) {
  const { orderHash, offerer, recipient, offer, consideration } = args;

  // itemType 2 = ERC721, 3 = ERC1155
  const nft = offer.find((item) => item.itemType === 2 || item.itemType === 3);

  const seller = offerer.toLowerCase();
  const toSeller = consideration.filter((c) => c.recipient.toLowerCase() === seller);
  const toPlatform = consideration.filter((c) => c.recipient.toLowerCase() === EXCLUSIVO_ZONE);
  const toRoyalty = consideration.filter(
    (c) => !toSeller.includes(c) && !toPlatform.includes(c)
  );

  const price = sum(toSeller);            // seller ask = seller proceeds
  const marketplaceFee = sum(toPlatform); // 200 bps of price
  const royaltyAmount = sum(toRoyalty);

  return {
    orderId: orderHash,
    collection: nft.token.toLowerCase(),
    tokenId: nft.identifier.toString(),
    seller,
    buyer: recipient.toLowerCase(),
    // Seaport ItemType: 0 = NATIVE, 1 = ERC20, 2 = ERC721, 3 = ERC1155.
    // Only 0 is native; 1 carries the token address (WETH on accepted offers).
    currency:
      consideration[0].itemType === 0 ? "native" : consideration[0].token.toLowerCase(),
    price: price.toString(),
    marketplaceFee: marketplaceFee.toString(),
    royaltyAmount: royaltyAmount.toString(),
    royaltyRecipient: toRoyalty[0]?.recipient.toLowerCase() ?? null,
  };
}

// Sanity check: our EVM marketplace fee is exactly 200 bps of the ask.
const fill = decodeListingFill(fills[0]);
const bps = (BigInt(fill.marketplaceFee) * 10000n) / BigInt(fill.price);
console.assert(bps === 200n, "unexpected fee ratio", bps);

import { Connection } from "@solana/web3.js";

const connection = new Connection(RPC_URL, "confirmed");
const tx = await connection.getParsedTransaction(signature, {
  maxSupportedTransactionVersion: 0,
});

const MEMO_PROGRAM_ID = "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr";
const PREFIX = "exclusivo:v1:";

const memoIx = tx.transaction.message.instructions.find(
  (ix) => ix.programId.toBase58() === MEMO_PROGRAM_ID
);
const memo = typeof memoIx?.parsed === "string" ? memoIx.parsed : null;
if (!memo?.startsWith(PREFIX)) throw new Error("not an Exclusivo marketplace transaction");

const event = JSON.parse(memo.slice(PREFIX.length));
// e.g. { t: "sale", lid, m, c, p, cur, s, b, f, r, rt, std }

const ESCROW = "HUxx919u8CSpyzLcmDYvBrvzBNt7caCdgDv2Ucjm4fge";

const keys = tx.transaction.message.accountKeys;
const escrowKey = keys.find((k) => k.pubkey.toBase58() === ESCROW);
if (!escrowKey) throw new Error("escrow wallet not involved — the memo alone proves nothing");

// escrow signs the release / cancel legs; the buyer signs the payment leg.
const escrowSigned = Boolean(escrowKey.signer);

function lamportDelta(tx, address) {
  const index = tx.transaction.message.accountKeys.findIndex(
    (k) => k.pubkey.toBase58() === address
  );
  if (index < 0) return null;
  return BigInt(tx.meta.postBalances[index]) - BigInt(tx.meta.preBalances[index]);
}

// On a "sale" / "sale_pay", the seller should receive exactly the recorded ask.
const sellerDelta = lamportDelta(tx, event.s);
console.assert(sellerDelta === BigInt(event.p), "seller proceeds do not match the memo");