From 6f305295c05d53b4d98fa03886444287b9da6ccb Mon Sep 17 00:00:00 2001 From: Marc Doerflinger Date: Fri, 22 Nov 2024 16:09:32 +0000 Subject: [PATCH] add event processing for bundle locking, unlocking, extending, collateral locking, releasing, and staking --- src/bundle_processor.ts | 220 ++++++++++++++++++++++++++++++++++++++++ src/main.ts | 29 ++++-- 2 files changed, 242 insertions(+), 7 deletions(-) diff --git a/src/bundle_processor.ts b/src/bundle_processor.ts index 9d95462..2dffdd5 100644 --- a/src/bundle_processor.ts +++ b/src/bundle_processor.ts @@ -124,6 +124,226 @@ export default class BundleProcessor { return bundles; } + async processBundleLockedEvent(event: DecodedLogEntry, bundles: Map): Promise> { + if (event.event_name !== 'LogBundleServiceBundleLocked') { + throw new Error(`Invalid event type ${event.event_name}`); + } + + logger.info(`Processing bundle locked event ${event.tx_hash} - ${event.event_name} - ${event.data}`); + const data = this.decodeBundleServiceEvent(event); + if (data === null || data === undefined) { + logger.error(`Failed to decode event ${event.tx_hash} - ${event.event_name} - ${event.data}`); + return bundles; + } + if (data.name !== 'LogBundleServiceBundleLocked') { + throw new Error(`Invalid event name ${data.name}`); + } + + const bundleNftId = data.args[0] as BigInt; + const bundle = bundles.get(bundleNftId); + if (bundle === undefined) { + throw new Error(`Bundle not found ${bundleNftId}`); + } + bundle.locked = true; + bundle.modified = { + blockNumber: event.block_number, + timestamp:BigInt(new Date(event.block_time).getTime()), + txHash: event.tx_hash, + from: event.tx_from + }; + return bundles; + } + + async processBundleUnlockedEvent(event: DecodedLogEntry, bundles: Map): Promise> { + if (event.event_name !== 'LogBundleServiceBundleUnlocked') { + throw new Error(`Invalid event type ${event.event_name}`); + } + + logger.info(`Processing bundle unlocked event ${event.tx_hash} - ${event.event_name} - ${event.data}`); + const data = this.decodeBundleServiceEvent(event); + if (data === null || data === undefined) { + logger.error(`Failed to decode event ${event.tx_hash} - ${event.event_name} - ${event.data}`); + return bundles; + } + if (data.name !== 'LogBundleServiceBundleUnlocked') { + throw new Error(`Invalid event name ${data.name}`); + } + + const bundleNftId = data.args[0] as BigInt; + const bundle = bundles.get(bundleNftId); + if (bundle === undefined) { + throw new Error(`Bundle not found ${bundleNftId}`); + } + bundle.locked = false; + bundle.modified = { + blockNumber: event.block_number, + timestamp:BigInt(new Date(event.block_time).getTime()), + txHash: event.tx_hash, + from: event.tx_from + }; + return bundles; + } + + async processBundleExtendedEvent(event: DecodedLogEntry, bundles: Map): Promise> { + if (event.event_name !== 'LogBundleServiceBundleExtended') { + throw new Error(`Invalid event type ${event.event_name}`); + } + + logger.info(`Processing bundle extended event ${event.tx_hash} - ${event.event_name} - ${event.data}`); + const data = this.decodeBundleServiceEvent(event); + if (data === null || data === undefined) { + logger.error(`Failed to decode event ${event.tx_hash} - ${event.event_name} - ${event.data}`); + return bundles; + } + if (data.name !== 'LogBundleServiceBundleExtended') { + throw new Error(`Invalid event name ${data.name}`); + } + + const bundleNftId = data.args[0] as BigInt; + const lifetime = data.args[1] as bigint; + // const extendedExpiration = data.args[2] as BigInt; + const bundle = bundles.get(bundleNftId); + if (bundle === undefined) { + throw new Error(`Bundle not found ${bundleNftId}`); + } + bundle.lifetime = bundle.lifetime + lifetime; + bundle.modified = { + blockNumber: event.block_number, + timestamp:BigInt(new Date(event.block_time).getTime()), + txHash: event.tx_hash, + from: event.tx_from + }; + return bundles; + } + + async processCollateralLockedEvent(event: DecodedLogEntry, bundles: Map): Promise> { + if (event.event_name !== 'LogBundleServiceCollateralLocked') { + throw new Error(`Invalid event type ${event.event_name}`); + } + + logger.info(`Processing collateral locked event ${event.tx_hash} - ${event.event_name} - ${event.data}`); + const data = this.decodeBundleServiceEvent(event); + if (data === null || data === undefined) { + logger.error(`Failed to decode event ${event.tx_hash} - ${event.event_name} - ${event.data}`); + return bundles; + } + if (data.name !== 'LogBundleServiceCollateralLocked') { + throw new Error(`Invalid event name ${data.name}`); + } + + const bundleNftId = data.args[0] as BigInt; + const lockedAmount = data.args[2] as bigint; + + const bundle = bundles.get(bundleNftId); + if (bundle === undefined) { + throw new Error(`Bundle not found ${bundleNftId}`); + } + bundle.lockedAmount = bundle.lockedAmount + lockedAmount; + bundle.modified = { + blockNumber: event.block_number, + timestamp:BigInt(new Date(event.block_time).getTime()), + txHash: event.tx_hash, + from: event.tx_from + }; + return bundles; + } + + async processCollateralReleasedEvent(event: DecodedLogEntry, bundles: Map): Promise> { + if (event.event_name !== 'LogBundleServiceCollateralReleased') { + throw new Error(`Invalid event type ${event.event_name}`); + } + + logger.info(`Processing collateral released event ${event.tx_hash} - ${event.event_name} - ${event.data}`); + const data = this.decodeBundleServiceEvent(event); + if (data === null || data === undefined) { + logger.error(`Failed to decode event ${event.tx_hash} - ${event.event_name} - ${event.data}`); + return bundles; + } + if (data.name !== 'LogBundleServiceCollateralReleased') { + throw new Error(`Invalid event name ${data.name}`); + } + + const bundleNftId = data.args[0] as BigInt; + const releasedAmount = data.args[2] as bigint; + + const bundle = bundles.get(bundleNftId); + if (bundle === undefined) { + throw new Error(`Bundle not found ${bundleNftId}`); + } + bundle.lockedAmount = bundle.lockedAmount - releasedAmount; + bundle.modified = { + blockNumber: event.block_number, + timestamp:BigInt(new Date(event.block_time).getTime()), + txHash: event.tx_hash, + from: event.tx_from + }; + return bundles; + } + + async processBundleStakedEvent(event: DecodedLogEntry, bundles: Map): Promise> { + if (event.event_name !== 'LogBundleServiceBundleStaked') { + throw new Error(`Invalid event type ${event.event_name}`); + } + + logger.info(`Processing bundle staked event ${event.tx_hash} - ${event.event_name} - ${event.data}`); + const data = this.decodeBundleServiceEvent(event); + if (data === null || data === undefined) { + logger.error(`Failed to decode event ${event.tx_hash} - ${event.event_name} - ${event.data}`); + return bundles; + } + if (data.name !== 'LogBundleServiceBundleStaked') { + throw new Error(`Invalid event name ${data.name}`); + } + + const bundleNftId = data.args[0] as BigInt; + const balance = data.args[1] as bigint; + + const bundle = bundles.get(bundleNftId); + if (bundle === undefined) { + throw new Error(`Bundle not found ${bundleNftId}`); + } + bundle.balance = bundle.balance + balance; + bundle.modified = { + blockNumber: event.block_number, + timestamp:BigInt(new Date(event.block_time).getTime()), + txHash: event.tx_hash, + from: event.tx_from + }; + return bundles; + } + + async processBundleUnstakedEvent(event: DecodedLogEntry, bundles: Map): Promise> { + if (event.event_name !== 'LogBundleServiceBundleUnstaked') { + throw new Error(`Invalid event type ${event.event_name}`); + } + + logger.info(`Processing bundle unstaked event ${event.tx_hash} - ${event.event_name} - ${event.data}`); + const data = this.decodeBundleServiceEvent(event); + if (data === null || data === undefined) { + logger.error(`Failed to decode event ${event.tx_hash} - ${event.event_name} - ${event.data}`); + return bundles; + } + if (data.name !== 'LogBundleServiceBundleUnstaked') { + throw new Error(`Invalid event name ${data.name}`); + } + + const bundleNftId = data.args[0] as BigInt; + const balance = data.args[1] as bigint; + + const bundle = bundles.get(bundleNftId); + if (bundle === undefined) { + throw new Error(`Bundle not found ${bundleNftId}`); + } + bundle.balance = bundle.balance - balance; + bundle.modified = { + blockNumber: event.block_number, + timestamp:BigInt(new Date(event.block_time).getTime()), + txHash: event.tx_hash, + from: event.tx_from + }; + return bundles; + } + decodeBundleServiceEvent(event: DecodedLogEntry) { const topic0 = event.topic0; let topic1 = event.topic1; diff --git a/src/main.ts b/src/main.ts index a528aa3..2b50085 100644 --- a/src/main.ts +++ b/src/main.ts @@ -220,15 +220,30 @@ class Main { case 'LogBundleServiceBundleClosed': await this.bundleProcessor.processBundleClosedEvent(event, bundles); break; + case 'LogBundleServiceBundleLocked': + await this.bundleProcessor.processBundleLockedEvent(event, bundles); + break; + case 'LogBundleServiceBundleUnlocked': + await this.bundleProcessor.processBundleUnlockedEvent(event, bundles); + break; + case 'LogBundleServiceBundleExtended': + await this.bundleProcessor.processBundleExtendedEvent(event, bundles); + break; + case 'LogBundleServiceCollateralLocked': + await this.bundleProcessor.processCollateralLockedEvent(event, bundles); + break; + case 'LogBundleServiceCollateralReleased': + await this.bundleProcessor.processCollateralReleasedEvent(event, bundles); + break; + case 'LogBundleServiceBundleStaked': + await this.bundleProcessor.processBundleStakedEvent(event, bundles); + break; + case 'LogBundleServiceBundleUnstaked': + await this.bundleProcessor.processBundleUnstakedEvent(event, bundles); + break; + - // event LogBundleServiceBundleLocked(NftId bundleNftId); - // event LogBundleServiceBundleUnlocked(NftId bundleNftId); - // event LogBundleServiceBundleExtended(NftId bundleNftId, Seconds lifetimeExtension, Timestamp extendedExpiredAt); // event LogBundleServiceBundleFeeUpdated(NftId bundleNftId, Amount fixedFee, UFixed fractionalFee); - // event LogBundleServiceCollateralLocked(NftId bundleNftId, NftId policyNftId, Amount collateralAmount); - // event LogBundleServiceCollateralReleased(NftId bundleNftId, NftId policyNftId, Amount collateralAmount); - // event LogBundleServiceBundleStaked(NftId bundleNftId, Amount amount); - // event LogBundleServiceBundleUnstaked(NftId bundleNftId, Amount amount); // event LogPoolServiceMaxBalanceAmountUpdated(NftId poolNftId, Amount previousMaxCapitalAmount, Amount currentMaxCapitalAmount); // event LogPoolServiceWalletFunded(NftId poolNftId, address poolOwner, Amount amount);