Skip to content

Commit

Permalink
add event processing for bundle locking, unlocking, extending, collat…
Browse files Browse the repository at this point in the history 
…eral locking, releasing, and staking
  • Loading branch information
@doerfli
doerfli committed Nov 22, 2024
1 parent 0b595fc commit 6f30529
Show file tree
Hide file tree
Showing 2 changed files with 242 additions and 7 deletions.
220 changes: 220 additions & 0 deletions src/bundle_processor.ts
View file
Original file line number Diff line number Diff line change
Expand Up @@ -124,6 +124,226 @@ export default class BundleProcessor {
return bundles;
}

async processBundleLockedEvent(event: DecodedLogEntry, bundles: Map<BigInt, Bundle>): Promise<Map<BigInt, Bundle>> {
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<BigInt, Bundle>): Promise<Map<BigInt, Bundle>> {
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<BigInt, Bundle>): Promise<Map<BigInt, Bundle>> {
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<BigInt, Bundle>): Promise<Map<BigInt, Bundle>> {
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<BigInt, Bundle>): Promise<Map<BigInt, Bundle>> {
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<BigInt, Bundle>): Promise<Map<BigInt, Bundle>> {
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<BigInt, Bundle>): Promise<Map<BigInt, Bundle>> {
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;
Expand Down
29 changes: 22 additions & 7 deletions src/main.ts
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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);
Expand Down

0 comments on commit 6f30529

Please sign in to comment.