[web3] Ethereum の Sepolia上のイベントログから ERC-721, ERC-1155 の所有者の見つけ方

export async function getEventTransferFilter(contractAddress: string, tokenId: bigint,
     fromBlock: number = 0, toBlock: number = 0): Promise<EventFilterLog | null> {
   try {
        const contract = new ethers.Contract(contractAddress, [TRANSFER_EVENT_SIGNATURE], provider);
        const filter = contract.filters.Transfer(null, null, null);
        const events = await contract.queryFilter(filter, fromBlock, toBlock);
        if(events.length === 0) {
            return null;
        }
        const matchingEvents = events.filter(event => {
            const eventTokenId = ethers.getBytes(event.topics[3]);
            const inputTokenId = ethers.getBytes(ethers.toBeHex(tokenId));
            return ethers.zeroPadValue(eventTokenId, 32) === ethers.zeroPadValue(inputTokenId, 32); // TokenId と一致判定
        });
        if (matchingEvents.length > 0) {
            const lastEvent = matchingEvents[matchingEvents.length - 1];
            const lastToAddress = (<ethers.Log>lastEvent).topics[2];
            const lastTokenId = BigInt((<ethers.Log>lastEvent).topics[3]);
            return {
                tokenId: lastTokenId,
                toAddress: lastToAddress,
                val: BigInt(1),
                transactionHash: lastEvent.transactionHash,
                blockNumber: lastEvent.blockNumber
            } as EventFilterLog;
        } else {
            console.log("No matching events found.");
            return null;
        }
    } catch (error) {
        console.error("Error:", error);
        return null;
    }
}

import 'reflect-metadata';
import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';

@Entity('EventTransferSingleAndBatch')
export class EventTransferSingleAndBatch {
    @PrimaryGeneratedColumn()
    id!: bigint;

    @Column({ type: 'varchar', length: 255 })
    contract_address!: string;

    @Column({ type: 'bigint' })
    token_id!: bigint;

    @Column({ type: 'varchar', length: 255 })
    from_address!: string;

    @Column({ type: 'varchar', length: 255 })
    to_address!: string;

    @Column({ type: 'bigint' })
    val!: bigint;

    @Column({ type: 'varchar', length: 255 })
    transaction_hash!: string;

    @Column({ type: 'int' })
    block_number!: number;

    @Column({ type: 'varchar', length: 255, nullable: true })
    event_hash!: string;
}

public async processEventLogs(): Promise<void> {
    const startBlockNumber = this.contractBlockNumber === null ? 0 : this.contractBlockNumber;
    for (let i = startBlockNumber; i < this.currentBlockNumber; i += this.iter) {
        let toBlock = i + this.iter;
        let fromBlock = i;
        console.log(`ERC1155: ${this.contractAddress}; ${this.tokenId}. Fetching events from block ${fromBlock} to ${toBlock}...`);
        //NOTE: すべてのEvent ログを取得して、DB内に保存する。
        let eventTransferSingleFilter = await getEventTransferSingleFilter(this.contractAddress, this.tokenId, fromBlock, toBlock);  // ロジックの1,2の箇所に対応
        let eventTransferBatchFilter = await getEventTransferBatchFilter(this.contractAddress, this.tokenId, fromBlock, toBlock);  // ロジックの1,2の箇所に対応
        eventTransferSingleFilter?.forEach(async (eventTransferSingle: EventFilterLog) => {
            const existEventTransferSingleAndBatch = await getEventTransferSingleAndBatch(this.contractAddress, this.tokenId, eventTransferSingle);
            if(existEventTransferSingleAndBatch === null) {
                await insertEventTransferSingleAndBatch(this.contractAddress, this.tokenId, eventTransferSingle);
            }
        });
        
        eventTransferBatchFilter?.forEach(async (eventTransferBatch: EventTransferBatchFilterLog) => {
            eventTransferBatch.tokenIds.forEach(async (eventTokenId: bigint, idx: number) => {
                const eventTransferLog: EventFilterLog = {
                    tokenId: eventTokenId,
                    fromAddress: eventTransferBatch.fromAddress,
                    toAddress: eventTransferBatch.toAddress,
                    val: eventTransferBatch.vals[idx],
                    transactionHash: eventTransferBatch.transactionHash,
                    blockNumber: eventTransferBatch.blockNumber,
                    eventHash: eventTransferBatch.eventHash
                }

                const existEventTransferSingleAndBatch = await getEventTransferSingleAndBatch(this.contractAddress, this.tokenId, eventTransferLog);
                if(existEventTransferSingleAndBatch === null) {
                    await insertEventTransferSingleAndBatch(this.contractAddress, this.tokenId, eventTransferLog);
                }
            });
        });
    }
}

//NOTE: DB内に保存したEvent ログを元に、OwnerAddress を取得する。
public async processNftOwnerAddressForEventLog(): Promise<void> {
    const accountAddresses = await getAccountAddressesEventTransferSingleAndBatch(this.contractAddress, this.tokenId);
    accountAddresses?.forEach(async (accountAddress: string) => {
        //NOTE: 0x0000000000000000000000000000000000000000 が Owner というのは変なので無視して良さそう。
        if(accountAddress === "0x0000000000000000000000000000000000000000") {
            console.log("accountAddress is zero address. skip");
            return;
        }
        const accountTotalVal = await getTotalValEventTransferSingleAndBatch(this.contractAddress, this.tokenId, accountAddress);
        if(accountTotalVal !== null && accountTotalVal.val > 0){
            const ownerRecords: Owner[] | null = await getOwnerByAccountAddress(this.contractAddress, this.tokenId, accountAddress);
            
            if(ownerRecords === null || ownerRecords.length === 0) {
                await insertOwnerAndNftsOwners(this.contractAddress, this.tokenId, 
                    accountAddress, accountTotalVal.val, 
                    accountTotalVal.last_tx_hash, accountTotalVal.last_block_number);
            } else {
                ownerRecords.forEach((ownerRecord: Owner) => {
                    console.log("ownerRecord: ", ownerRecord);
                })
            }
            
        }
    });
}

export async function getAccountAddressesEventTransferSingleAndBatch(contractAddress: string, tokenId: bigint): Promise<string[] | null> {
    return connection.then(async (conn: DataSource) => {
        
        const eventTransferSingleAndBatches = await conn.getRepository(EventTransferSingleAndBatch)
            .find(
                { where: 
                    { 
                        contract_address: contractAddress, token_id: tokenId
                    },
                    order: { block_number: "ASC" }
                }
            );
        let accountAddresses: string[] = [];
        
        eventTransferSingleAndBatches.forEach((eventTransferSingleAndBatch: EventTransferSingleAndBatch) => {
            accountAddresses.push(eventTransferSingleAndBatch.from_address);
            accountAddresses.push(eventTransferSingleAndBatch.to_address);
        });

        return Array.from(new Set(accountAddresses));
    })
    .catch((error: any) => {
        console.error('データベース接続エラー:', error);
        return null;
    });
}

export async function getTotalValEventTransferSingleAndBatch(
    contractAddress: string, tokenId: bigint, accountAddress: string): Promise<Owner | null> {
    return await connection.then(async (conn: DataSource) => {
        
        const eventTransferSingleAndBatches = await conn.getRepository(EventTransferSingleAndBatch)
            .find(
                { where: 
                    { 
                        contract_address: contractAddress, token_id: tokenId
                    },
                    order: { block_number: "asc" }
                }
            );
        const eventTransferSingleAndBatchesForFromAddress = eventTransferSingleAndBatches.filter(
            (event: EventTransferSingleAndBatch) => {
                return event.from_address === accountAddress;
            });
        const eventTransferSingleAndBatchesForToAddress = eventTransferSingleAndBatches.filter(
            (event: EventTransferSingleAndBatch) => {
                return event.to_address === accountAddress;
            });
        let eventTransferTotalVal: bigint = BigInt(0);
        
        eventTransferSingleAndBatchesForFromAddress.forEach((eventTransferSingleAndBatch: EventTransferSingleAndBatch) => {
            eventTransferTotalVal -= BigInt(eventTransferSingleAndBatch.val);
        });

        eventTransferSingleAndBatchesForToAddress.forEach((eventTransferSingleAndBatch: EventTransferSingleAndBatch) => {
            eventTransferTotalVal += BigInt(eventTransferSingleAndBatch.val);
        });

        return {
            owner_address: accountAddress,
            val: eventTransferTotalVal,
            last_tx_hash: eventTransferSingleAndBatches[eventTransferSingleAndBatches.length - 1]?.transaction_hash,
            last_block_number: eventTransferSingleAndBatches[eventTransferSingleAndBatches.length - 1]?.block_number
        } as Owner;
    })
    .catch((error: any) => {
        console.error('データベース接続エラー:', error);
        return null;
    });
}