@patchworkdev/pdk/dist/generate/eventHooks/eventHooks.js

Patchwork Development Kit

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.createPonderEventFile = createPonderEventFile;
exports.generateEntityEventHandlers = generateEntityEventHandlers;
exports.generatePonderOnHandler = generatePonderOnHandler;
exports.transferHandler = transferHandler;
exports.metadataUpdateHandler = metadataUpdateHandler;
exports.genericEventTemplate = genericEventTemplate;
const lodash_1 = __importDefault(require("lodash"));
const file_1 = require("../../common/helpers/file");
async function createPonderEventFile(handlers, eventFile) {
    const output = [];
    output.push(`import { ponder } from "@/generated";`);
    output.push(`import { patchwork } from "./patchwork";`);
    output.push(`import { getMetadata } from "./utils";`);
    output.push(`import {${[...handlers.imports].sort().join(',')}} from "../../ponder.schema";`);
    handlers.handlers.forEach((handler) => {
        output.push(handler);
    });
    await (0, file_1.formatAndSaveFile)(eventFile, output.join('\n'));
}
function generateEntityEventHandlers(projectConfig, ponderSchema, abis) {
    const handlers = { imports: new Set(), handlers: [] };
    const entityEvents = ['Frozen', 'Locked', 'Transfer', 'Unlocked', 'Thawed'];
    Object.entries(projectConfig.contracts).flatMap(([contractName, contractConfig]) => {
        const key = (typeof contractConfig !== 'string' && contractConfig.name.replace(/\s+/g, '')) || contractName;
        const abi = abis[contractName] ?? abis[key];
        const filteredEvents = abi.filter((abiEvent) => abiEvent.type === 'event');
        return filteredEvents
            .map((event) => generatePonderOnHandler(contractName, event, projectConfig, ponderSchema, abis))
            .map((handler) => {
            handler.imports.forEach((item) => handlers.imports.add(item));
            handlers.handlers.push(handler.handler);
        });
    });
    return handlers;
}
function generatePonderOnHandler(entity, event, projectConfig, ponderSchema, abis) {
    const templateFunctions = {
        Transfer: transferHandler,
        MetadataUpdate: metadataUpdateHandler,
    };
    const handler = templateFunctions[event.name]
        ? templateFunctions[event.name]({ entity, event, projectConfig, ponderSchema, abis })
        : genericEventTemplate({ entity, event });
    return handler;
}
// Below are the template functions. Could be moved to a separate file if there are too many.
function transferHandler({ entity, event, projectConfig, ponderSchema, abis, }) {
    const data = {
        owner: 'event.args.to',
        tokenId: 'event.args.tokenId',
        mintTxId: 'event.transaction.hash',
        contractId: 'event.log.address',
        timestamp: 'event.block.timestamp',
    };
    return {
        imports: new Set([lodash_1.default.camelCase(entity)]),
        handler: `ponder.on('${entity}:${event.name}', async ({ event, context }) => {
        if (parseInt(event.args.from, 16) === 0) {
	        const metadata = await getMetadata(event.args.tokenId, '${entity}', context);
            await context.db.insert(${lodash_1.default.camelCase(entity)}).values({
                id: \`\${event.log.address}:\$\{event.args.tokenId}\`,
                ${Object.keys(data)
            .map((key) => {
            return `${key}: ${data[key]}`;
        })
            .join(',\n')},
                ...metadata,
            });
        } else if (parseInt(event.args.to, 16) === 0) {
            await context.db.update(${lodash_1.default.camelCase(entity)}, { id: \`\${event.log.address}:\$\{event.args.tokenId}\` })
                .set((row) => (
                    {
                        owner: event.args.to,
                        burnTxId: event.transaction.hash,
                    }
                ));
        } else {
            await context.db.update(${lodash_1.default.camelCase(entity)}, { id: \`\${event.log.address}:\$\{event.args.tokenId}\` })
                .set((row) => ({ owner: event.args.to }));
        }
	    await patchwork.emit('${entity}:${event.name}', { event, context });
    });`,
    };
}
function metadataUpdateHandler({ entity, event }) {
    return {
        imports: new Set([lodash_1.default.camelCase(entity)]),
        handler: `ponder.on('${entity}:${event.name}', async ({ event, context }) => {
            const metadata = await getMetadata(event.args._tokenId, '${entity}', context);
            await context.db
                .update(${lodash_1.default.camelCase(entity)}, {
                    id: \`\${event.log.address}:\$\{event.args._tokenId}\`,
                })
                .set(() => metadata);
            await patchwork.emit('${entity}:${event.name}', { event, context });
        });`,
    };
}
function genericEventTemplate({ entity, event }) {
    return {
        imports: new Set([lodash_1.default.camelCase(entity)]),
        handler: `ponder.on('${entity}:${event.name}', async ({ event, context }) => {
            await patchwork.emit('${entity}:${event.name}', { event, context });
        });`,
    };
}