Contract Events

event MarketCreated(
    uint256 indexed marketId,
    string actorHandle,
    uint256 endTime,
    address creator
)

// Listen for new markets
predictionMarket.on("MarketCreated", (marketId, actorHandle, endTime, creator) => {
  console.log(`New market ${marketId} for ${actorHandle}`);
  console.log(`Ends at: ${new Date(endTime * 1000)}`);
});

event SubmissionCreated(
    uint256 indexed submissionId,
    uint256 indexed marketId,
    address submitter,
    string predictedText,
    uint256 amount
)

// Listen for submissions on a specific market
const marketFilter = predictionMarket.filters.SubmissionCreated(null, marketId);
predictionMarket.on(marketFilter, (submissionId, marketId, submitter, predictedText, amount) => {
  console.log(`New submission ${submissionId}: "${predictedText}"`);
  console.log(`Stake: ${ethers.formatEther(amount)} ETH`);
});

event MarketResolved(
    uint256 indexed marketId,
    uint256 winningSubmissionId,
    string actualText,
    uint256 winningDistance
)

// Listen for market resolutions
predictionMarket.on("MarketResolved", (marketId, winningSubmissionId, actualText, winningDistance) => {
  console.log(`Market ${marketId} resolved!`);
  console.log(`Winner: Submission #${winningSubmissionId}`);
  console.log(`Actual text: "${actualText}"`);
  console.log(`Edit distance: ${winningDistance}`);
});

event PayoutClaimed(
    uint256 indexed submissionId,
    address indexed claimer,
    uint256 amount
)

// Listen for payout claims
predictionMarket.on("PayoutClaimed", (submissionId, claimer, amount) => {
  console.log(`Submission ${submissionId} claimed!`);
  console.log(`Winner: ${claimer}`);
  console.log(`Payout: ${ethers.formatEther(amount)} ETH`);
});

event SingleSubmissionRefunded(
    uint256 indexed marketId,
    uint256 indexed submissionId,
    address submitter,
    uint256 amount
)

// Listen for single submission refunds
predictionMarket.on("SingleSubmissionRefunded", (marketId, submissionId, submitter, amount) => {
  console.log(`Market ${marketId} had only one submission`);
  console.log(`Refunded ${ethers.formatEther(amount)} ETH to ${submitter}`);
});

event FeesWithdrawn(
    address indexed recipient,
    uint256 amount
)

// Listen for fee withdrawals
predictionMarket.on("FeesWithdrawn", (recipient, amount) => {
  console.log(`${recipient} withdrew ${ethers.formatEther(amount)} ETH in fees`);
});

event GenesisNFTMinted(
    address indexed to,
    uint256 tokenId
)

// Listen for Genesis NFT mints
genesisNFT.on("GenesisNFTMinted", (to, tokenId) => {
  console.log(`Genesis #${tokenId} minted to ${to}`);
});

event MintingFinalized(
    uint256 totalMinted
)

// Listen for minting finalization
genesisNFT.on("MintingFinalized", (totalMinted) => {
  console.log(`Minting finalized with ${totalMinted} Genesis NFTs`);
});

event Transfer(
    address indexed from,
    address indexed to,
    uint256 indexed tokenId
)

event Approval(
    address indexed owner,
    address indexed approved,
    uint256 indexed tokenId
)

event ApprovalForAll(
    address indexed owner,
    address indexed operator,
    bool approved
)

// Get all markets created in the last 24 hours
const currentBlock = await provider.getBlockNumber();
const blocksPerDay = 7200; // ~12 second blocks
const fromBlock = currentBlock - blocksPerDay;

const marketEvents = await predictionMarket.queryFilter(
  predictionMarket.filters.MarketCreated(),
  fromBlock
);

marketEvents.forEach(event => {
  console.log(`Market ${event.args.marketId}: ${event.args.actorHandle}`);
});

// Get all submissions by a specific user
const userAddress = "0x...";
const allSubmissions = await predictionMarket.queryFilter(
  predictionMarket.filters.SubmissionCreated(null, null, userAddress)
);

console.log(`User has made ${allSubmissions.length} predictions`);

// Wait for a specific market to be resolved
const marketId = 42;
const resolvedEvent = await new Promise((resolve) => {
  predictionMarket.once(
    predictionMarket.filters.MarketResolved(marketId),
    resolve
  );
});

console.log(`Market ${marketId} resolved!`);
console.log(`Winner: ${resolvedEvent.args.winningSubmissionId}`);

type Market @entity {
  id: ID!
  marketId: BigInt!
  actorHandle: String!
  endTime: BigInt!
  creator: Bytes!
  submissions: [Submission!]! @derivedFrom(field: "market")
  resolved: Boolean!
  winningSubmission: Submission
  totalPool: BigInt!
}

type Submission @entity {
  id: ID!
  submissionId: BigInt!
  market: Market!
  submitter: Bytes!
  predictedText: String!
  amount: BigInt!
  claimed: Boolean!
}