@patchworkdev/pdk/dist/commands/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.frozenHandler = frozenHandler;
exports.lockedHandler = lockedHandler;
exports.unlockedHandler = unlockedHandler;
exports.thawedHandler = thawedHandler;
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 {${[...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')?.filter((abiEvent) => entityEvents.includes(abiEvent.name));
        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 = {
        Frozen: frozenHandler,
        Locked: lockedHandler,
        Transfer: transferHandler,
        Unlocked: unlockedHandler,
        Thawed: thawedHandler,
    };
    const handler = templateFunctions[event.name]({ entity, event, projectConfig, ponderSchema, abis });
    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) {
            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')}
    
            });
        } 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 }));
        }
    });`,
    };
}
function frozenHandler({ entity, event }) {
    return {
        imports: new Set(),
        handler: `ponder.on('${entity}:${event.name}', async ({ event, context }) => {

    
})`,
    };
}
function lockedHandler({ entity, event }) {
    return {
        imports: new Set(),
        handler: `ponder.on('${entity}:${event.name}', async ({ event, context }) => {

    
})`,
    };
}
function unlockedHandler({ entity, event }) {
    return {
        imports: new Set(),
        handler: `ponder.on('${entity}:${event.name}', async ({ event, context }) => {

    
})`,
    };
}
function thawedHandler({ entity, event }) {
    return {
        imports: new Set(),
        handler: `ponder.on('${entity}:${event.name}', async ({ event, context }) => {

    
})`,
    };
}