@rosen-bridge/watcher-data-extractor 0.1.0-alpha-2 → 0.1.0-alpha-5

package/dist/actions/EventTriggerDB.d.ts

@@ -3,14 +3,15 @@ import { BlockEntity } from "@rosen-bridge/scanner";
 import { ExtractedEventTrigger } from "../interfaces/extractedEventTrigger";
 declare class EventTriggerDB {
     private readonly datasource;
+    private readonly triggerEventRepository;
     constructor(dataSource: DataSource);
     /**
-     * It stores list of wids in the dataSource with block id
-     * @param wids
+     * It stores list of eventTriggers in the dataSource with block id
+     * @param eventTriggers
      * @param block
      * @param extractor
      */
-    storeEventTriggers: (wids: Array<ExtractedEventTrigger>, block: BlockEntity, extractor: string) => Promise<boolean>;
+    storeEventTriggers: (eventTriggers: Array<ExtractedEventTrigger>, block: BlockEntity, extractor: string) => Promise<boolean>;
     /**
      * deleting all permits corresponding to the block(id) and extractor(id)
      * @param block

package/dist/actions/EventTriggerDB.js

@@ -1,45 +1,67 @@
+import { In } from "typeorm";
 import EventTriggerEntity from "../entities/EventTriggerEntity";
 class EventTriggerDB {
     datasource;
+    triggerEventRepository;
     constructor(dataSource) {
         this.datasource = dataSource;
+        this.triggerEventRepository = dataSource.getRepository(EventTriggerEntity);
     }
     /**
-     * It stores list of wids in the dataSource with block id
-     * @param wids
+     * It stores list of eventTriggers in the dataSource with block id
+     * @param eventTriggers
      * @param block
      * @param extractor
      */
-    storeEventTriggers = async (wids, block, extractor) => {
-        const widEntity = wids.map((event) => {
-            const row = new EventTriggerEntity();
-            row.boxId = event.boxId;
-            row.boxSerialized = event.boxSerialized;
-            row.blockId = block.hash;
-            row.extractor = extractor;
-            row.WIDs = event.WIDs;
-            row.amount = event.amount;
-            row.bridgeFee = event.bridgeFee;
-            row.fromAddress = event.fromAddress;
-            row.toAddress = event.toAddress;
-            row.fromChain = event.fromChain;
-            row.networkFee = event.networkFee;
-            row.sourceChainTokenId = event.sourceChainTokenId;
-            row.targetChainTokenId = event.targetChainTokenId;
-            row.sourceBlockId = event.sourceBlockId;
-            row.toChain = event.toChain;
-            row.sourceTxId = event.sourceTxId;
-            return row;
+    storeEventTriggers = async (eventTriggers, block, extractor) => {
+        if (eventTriggers.length === 0)
+            return true;
+        const boxIds = eventTriggers.map(trigger => trigger.boxId);
+        const savedTriggers = await this.triggerEventRepository.findBy({
+            boxId: In(boxIds),
+            extractor: extractor,
         });
         let success = true;
         const queryRunner = this.datasource.createQueryRunner();
         await queryRunner.connect();
         await queryRunner.startTransaction();
         try {
-            await queryRunner.manager.save(widEntity);
+            for (const event of eventTriggers) {
+                const saved = savedTriggers.some((entity) => {
+                    return entity.boxId === event.boxId;
+                });
+                const entity = {
+                    boxId: event.boxId,
+                    boxSerialized: event.boxSerialized,
+                    block: block.hash,
+                    height: block.height,
+                    extractor: extractor,
+                    WIDs: event.WIDs,
+                    amount: event.amount,
+                    bridgeFee: event.bridgeFee,
+                    fromAddress: event.fromAddress,
+                    toAddress: event.toAddress,
+                    fromChain: event.fromChain,
+                    networkFee: event.networkFee,
+                    sourceChainTokenId: event.sourceChainTokenId,
+                    targetChainTokenId: event.targetChainTokenId,
+                    sourceBlockId: event.sourceBlockId,
+                    toChain: event.toChain,
+                    sourceTxId: event.sourceTxId,
+                };
+                if (!saved) {
+                    await queryRunner.manager.insert(EventTriggerEntity, entity);
+                }
+                else {
+                    await queryRunner.manager.update(EventTriggerEntity, {
+                        boxId: event.boxId
+                    }, entity);
+                }
+            }
             await queryRunner.commitTransaction();
         }
         catch (e) {
+            console.log(`An error occurred during store eventTrigger action: ${e}`);
             await queryRunner.rollbackTransaction();
             success = false;
         }
@@ -57,7 +79,7 @@ class EventTriggerDB {
         await this.datasource.createQueryBuilder()
             .delete()
             .from(EventTriggerEntity)
-            .where("extractor = :extractor AND blockId = :block", {
+            .where("extractor = :extractor AND block = :block", {
             "block": block,
             "extractor": extractor
         }).execute();

package/dist/actions/commitmentDB.d.ts

@@ -3,20 +3,22 @@ import { extractedCommitment } from "../interfaces/extractedCommitment";
 import { BlockEntity } from "@rosen-bridge/scanner";
 declare class CommitmentEntityAction {
     private readonly datasource;
+    private readonly commitmentRepository;
     constructor(dataSource: DataSource);
     /**
      * It stores list of observations in the dataSource with block id
      * @param commitments
      * @param block
-     * @param extractorId
+     * @param extractor
      */
-    storeCommitments: (commitments: Array<extractedCommitment>, block: BlockEntity, extractorId: string) => Promise<boolean>;
+    storeCommitments: (commitments: Array<extractedCommitment>, block: BlockEntity, extractor: string) => Promise<boolean>;
     /**
      * update spendBlock Column of the commitments in the dataBase
      * @param spendId
      * @param block
+     * @param extractor
      */
-    spendCommitments: (spendId: Array<string>, block: BlockEntity) => Promise<void>;
+    spendCommitments: (spendId: Array<string>, block: BlockEntity, extractor: string) => Promise<void>;
     /**
      * deleting all permits corresponding to the block(id) and extractor(id)
      * @param block

package/dist/actions/commitmentDB.js

@@ -1,37 +1,60 @@
+import { In } from "typeorm";
 import CommitmentEntity from "../entities/CommitmentEntity";
 class CommitmentEntityAction {
     datasource;
+    commitmentRepository;
     constructor(dataSource) {
         this.datasource = dataSource;
+        this.commitmentRepository = dataSource.getRepository(CommitmentEntity);
     }
     /**
      * It stores list of observations in the dataSource with block id
      * @param commitments
      * @param block
-     * @param extractorId
+     * @param extractor
      */
-    storeCommitments = async (commitments, block, extractorId) => {
-        const commitmentEntity = commitments.map((commitment) => {
-            const row = new CommitmentEntity();
-            row.commitment = commitment.commitment;
-            row.eventId = commitment.eventId;
-            row.commitmentBoxId = commitment.commitmentBoxId;
-            row.WID = commitment.WID;
-            row.extractor = extractorId;
-            row.blockId = block.hash;
-            return row;
+    storeCommitments = async (commitments, block, extractor) => {
+        if (commitments.length === 0)
+            return true;
+        const boxIds = commitments.map(commitment => commitment.boxId);
+        const savedCommitments = await this.commitmentRepository.findBy({
+            boxId: In(boxIds),
+            extractor: extractor,
         });
         let success = true;
         const queryRunner = this.datasource.createQueryRunner();
         await queryRunner.connect();
         await queryRunner.startTransaction();
         try {
-            await queryRunner.manager.save(commitmentEntity);
+            for (const commitment of commitments) {
+                const saved = savedCommitments.some((entity) => {
+                    return entity.boxId === commitment.boxId;
+                });
+                const entity = {
+                    commitment: commitment.commitment,
+                    eventId: commitment.eventId,
+                    boxId: commitment.boxId,
+                    WID: commitment.WID,
+                    extractor: extractor,
+                    block: block.hash,
+                    height: block.height,
+                    boxSerialized: commitment.boxSerialized,
+                };
+                if (!saved) {
+                    await queryRunner.manager.insert(CommitmentEntity, entity);
+                }
+                else {
+                    await queryRunner.manager.update(CommitmentEntity, {
+                        boxId: commitment.boxId
+                    }, entity);
+                }
+            }
             await queryRunner.commitTransaction();
         }
         catch (e) {
-            success = false;
+            console.log(`An error occurred during store commitments action: ${e}`);
             await queryRunner.rollbackTransaction();
+            success = false;
         }
         finally {
             await queryRunner.release();
@@ -42,14 +65,15 @@ class CommitmentEntityAction {
      * update spendBlock Column of the commitments in the dataBase
      * @param spendId
      * @param block
+     * @param extractor
      */
-    spendCommitments = async (spendId, block) => {
+    spendCommitments = async (spendId, block, extractor) => {
         //todo: should change with single db call
         for (const id of spendId) {
             await this.datasource.createQueryBuilder()
                 .update(CommitmentEntity)
-                .set({ spendBlock: block.hash })
-                .where("commitmentBoxId = :id", { id: id })
+                .set({ spendBlock: block.hash, spendHeight: block.height })
+                .where("boxId = :id AND extractor = :extractor", { id: id, extractor: extractor })
                 .execute();
         }
     };
@@ -62,10 +86,17 @@ class CommitmentEntityAction {
         await this.datasource.createQueryBuilder()
             .delete()
             .from(CommitmentEntity)
-            .where("extractor = :extractor AND blockId = :block", {
+            .where("extractor = :extractor AND block = :block", {
             "block": block,
             "extractor": extractor
         }).execute();
+        //TODO: should handled null value in spendBlockHeight
+        await this.datasource.createQueryBuilder()
+            .update(CommitmentEntity)
+            .set({ spendBlock: undefined, spendHeight: 0 })
+            .where("spendBlock = :block AND block = :block", {
+            block: block
+        }).execute();
     };
 }
 export default CommitmentEntityAction;

package/dist/actions/permitDB.d.ts

@@ -3,6 +3,7 @@ import { extractedPermit } from "../interfaces/extractedPermit";
 import { BlockEntity } from "@rosen-bridge/scanner";
 declare class PermitEntityAction {
     private readonly datasource;
+    private readonly permitRepository;
     constructor(dataSource: DataSource);
     /**
      * It stores list of permits in the dataSource with block id
@@ -11,6 +12,13 @@ declare class PermitEntityAction {
      * @param extractor
      */
     storePermits: (permits: Array<extractedPermit>, block: BlockEntity, extractor: string) => Promise<boolean>;
+    /**
+     * update spendBlock Column of the permits in the dataBase
+     * @param spendId
+     * @param block
+     * @param extractor
+     */
+    spendPermits: (spendId: Array<string>, block: BlockEntity, extractor: string) => Promise<void>;
     /**
      * deleting all permits corresponding to the block(id) and extractor(id)
      * @param block

package/dist/actions/permitDB.js

@@ -1,8 +1,12 @@
+import { In } from "typeorm";
 import PermitEntity from "../entities/PermitEntity";
+import CommitmentEntity from "../entities/CommitmentEntity";
 class PermitEntityAction {
     datasource;
+    permitRepository;
     constructor(dataSource) {
         this.datasource = dataSource;
+        this.permitRepository = dataSource.getRepository(PermitEntity);
     }
     /**
      * It stores list of permits in the dataSource with block id
@@ -11,24 +15,43 @@ class PermitEntityAction {
      * @param extractor
      */
     storePermits = async (permits, block, extractor) => {
-        const permitEntity = permits.map((permit) => {
-            const row = new PermitEntity();
-            row.boxId = permit.boxId;
-            row.boxSerialized = permit.boxSerialized;
-            row.blockId = block.hash;
-            row.extractor = extractor;
-            row.WID = permit.WID;
-            return row;
+        if (permits.length === 0)
+            return true;
+        const boxIds = permits.map(permit => permit.boxId);
+        const savedPermits = await this.permitRepository.findBy({
+            boxId: In(boxIds),
+            extractor: extractor,
         });
         let success = true;
         const queryRunner = this.datasource.createQueryRunner();
         await queryRunner.connect();
         await queryRunner.startTransaction();
         try {
-            await queryRunner.manager.save(permitEntity);
+            for (const permit of permits) {
+                const saved = savedPermits.some((entity) => {
+                    return entity.boxId === permit.boxId;
+                });
+                const entity = {
+                    boxId: permit.boxId,
+                    boxSerialized: permit.boxSerialized,
+                    block: block.hash,
+                    height: block.height,
+                    extractor: extractor,
+                    WID: permit.WID,
+                };
+                if (!saved) {
+                    await queryRunner.manager.insert(PermitEntity, entity);
+                }
+                else {
+                    await queryRunner.manager.update(PermitEntity, {
+                        boxId: permit.boxId
+                    }, entity);
+                }
+            }
             await queryRunner.commitTransaction();
         }
         catch (e) {
+            console.log(`An error occurred during store permit action: ${e}`);
             await queryRunner.rollbackTransaction();
             success = false;
         }
@@ -37,6 +60,22 @@ class PermitEntityAction {
         }
         return success;
     };
+    /**
+     * update spendBlock Column of the permits in the dataBase
+     * @param spendId
+     * @param block
+     * @param extractor
+     */
+    spendPermits = async (spendId, block, extractor) => {
+        //todo: should change with single db call
+        for (const id of spendId) {
+            await this.datasource.createQueryBuilder()
+                .update(PermitEntity)
+                .set({ spendBlock: block.hash, spendHeight: block.height })
+                .where("boxId = :id AND extractor = :extractor", { id: id, extractor: extractor })
+                .execute();
+        }
+    };
     /**
      * deleting all permits corresponding to the block(id) and extractor(id)
      * @param block
@@ -47,10 +86,17 @@ class PermitEntityAction {
         await this.datasource.createQueryBuilder()
             .delete()
             .from(PermitEntity)
-            .where("extractor = :extractor AND blockId = :block", {
+            .where("extractor = :extractor AND block = :block", {
             "block": block,
             "extractor": extractor
         }).execute();
+        //TODO: should handled null value in spendBlockHeight
+        await this.datasource.createQueryBuilder()
+            .update(CommitmentEntity)
+            .set({ spendBlock: undefined, spendHeight: 0 })
+            .where("spendBlock = :block AND block = :block", {
+            block: block
+        }).execute();
     };
 }
 export default PermitEntityAction;

package/dist/entities/CommitmentEntity.d.ts

@@ -4,8 +4,11 @@ declare class CommitmentEntity {
     eventId: string;
     commitment: string;
     WID: string;
-    commitmentBoxId: string;
-    blockId: string;
-    spendBlock?: string;
+    boxId: string;
+    block: string;
+    height: number;
+    boxSerialized: string;
+    spendBlock: string;
+    spendHeight?: number;
 }
 export default CommitmentEntity;

package/dist/entities/CommitmentEntity.js

@@ -7,16 +7,19 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { Column, Entity, PrimaryGeneratedColumn } from "typeorm";
+import { Column, Entity, PrimaryGeneratedColumn, Unique } from "typeorm";
 let CommitmentEntity = class CommitmentEntity {
     id;
     extractor;
     eventId;
     commitment;
     WID;
-    commitmentBoxId;
-    blockId;
+    boxId;
+    block;
+    height;
+    boxSerialized;
     spendBlock;
+    spendHeight;
 };
 __decorate([
     PrimaryGeneratedColumn(),
@@ -41,16 +44,29 @@ __decorate([
 __decorate([
     Column(),
     __metadata("design:type", String)
-], CommitmentEntity.prototype, "commitmentBoxId", void 0);
+], CommitmentEntity.prototype, "boxId", void 0);
 __decorate([
     Column(),
     __metadata("design:type", String)
-], CommitmentEntity.prototype, "blockId", void 0);
+], CommitmentEntity.prototype, "block", void 0);
+__decorate([
+    Column(),
+    __metadata("design:type", Number)
+], CommitmentEntity.prototype, "height", void 0);
+__decorate([
+    Column(),
+    __metadata("design:type", String)
+], CommitmentEntity.prototype, "boxSerialized", void 0);
 __decorate([
     Column({ nullable: true }),
     __metadata("design:type", String)
 ], CommitmentEntity.prototype, "spendBlock", void 0);
+__decorate([
+    Column({ nullable: true }),
+    __metadata("design:type", Number)
+], CommitmentEntity.prototype, "spendHeight", void 0);
 CommitmentEntity = __decorate([
-    Entity()
+    Entity(),
+    Unique(["boxId", "extractor"])
 ], CommitmentEntity);
 export default CommitmentEntity;

package/dist/entities/EventTriggerEntity.d.ts

@@ -3,7 +3,8 @@ declare class EventTriggerEntity {
     extractor: string;
     boxId: string;
     boxSerialized: string;
-    blockId: string;
+    block: string;
+    height: number;
     fromChain: string;
     toChain: string;
     fromAddress: string;

package/dist/entities/EventTriggerEntity.js

@@ -7,13 +7,14 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { Column, Entity, PrimaryGeneratedColumn } from "typeorm";
+import { Column, Entity, PrimaryGeneratedColumn, Unique } from "typeorm";
 let EventTriggerEntity = class EventTriggerEntity {
     id;
     extractor;
     boxId;
     boxSerialized;
-    blockId;
+    block;
+    height;
     fromChain;
     toChain;
     fromAddress;
@@ -46,7 +47,11 @@ __decorate([
 __decorate([
     Column(),
     __metadata("design:type", String)
-], EventTriggerEntity.prototype, "blockId", void 0);
+], EventTriggerEntity.prototype, "block", void 0);
+__decorate([
+    Column(),
+    __metadata("design:type", Number)
+], EventTriggerEntity.prototype, "height", void 0);
 __decorate([
     Column(),
     __metadata("design:type", String)
@@ -96,6 +101,7 @@ __decorate([
     __metadata("design:type", String)
 ], EventTriggerEntity.prototype, "WIDs", void 0);
 EventTriggerEntity = __decorate([
-    Entity()
+    Entity(),
+    Unique(["boxId", "extractor"])
 ], EventTriggerEntity);
 export default EventTriggerEntity;

package/dist/entities/PermitEntity.d.ts

@@ -4,6 +4,9 @@ declare class PermitEntity {
     boxId: string;
     boxSerialized: string;
     WID: string;
-    blockId: string;
+    block: string;
+    height: number;
+    spendBlock: string;
+    spendHeight?: number;
 }
 export default PermitEntity;

package/dist/entities/PermitEntity.js

@@ -7,14 +7,17 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { Column, Entity, PrimaryGeneratedColumn } from "typeorm";
+import { Column, Entity, PrimaryGeneratedColumn, Unique } from "typeorm";
 let PermitEntity = class PermitEntity {
     id;
     extractor;
     boxId;
     boxSerialized;
     WID;
-    blockId;
+    block;
+    height;
+    spendBlock;
+    spendHeight;
 };
 __decorate([
     PrimaryGeneratedColumn(),
@@ -39,8 +42,21 @@ __decorate([
 __decorate([
     Column(),
     __metadata("design:type", String)
-], PermitEntity.prototype, "blockId", void 0);
+], PermitEntity.prototype, "block", void 0);
+__decorate([
+    Column(),
+    __metadata("design:type", Number)
+], PermitEntity.prototype, "height", void 0);
+__decorate([
+    Column({ nullable: true }),
+    __metadata("design:type", String)
+], PermitEntity.prototype, "spendBlock", void 0);
+__decorate([
+    Column({ nullable: true }),
+    __metadata("design:type", Number)
+], PermitEntity.prototype, "spendHeight", void 0);
 PermitEntity = __decorate([
-    Entity()
+    Entity(),
+    Unique(["boxId", "extractor"])
 ], PermitEntity);
 export default PermitEntity;

package/dist/extractor/EventTriggerExtractor.js

@@ -40,17 +40,15 @@ class EventTriggerExtractor extends AbstractExtractor {
                                     R4Serialized.length >= 1 &&
                                     R5Serialized.length >= 11 &&
                                     output.ergo_tree().to_base16_bytes() === this.eventTriggerErgoTree) {
-                                    const WIDs = R4Serialized.map(byteArray => {
-                                        Buffer.from(byteArray).toString();
-                                    }).join(',');
+                                    const WIDs = R4Serialized.map(byteArray => Buffer.from(byteArray).toString("hex")).join(',');
                                     boxes.push({
                                         boxId: output.box_id().to_str(),
                                         boxSerialized: Buffer.from(output.sigma_serialize_bytes()).toString("base64"),
                                         toChain: Buffer.from(R5Serialized[2]).toString(),
                                         toAddress: Buffer.from(R5Serialized[4]).toString(),
-                                        networkFee: Buffer.from(R5Serialized[7]).toString(),
-                                        bridgeFee: Buffer.from(R5Serialized[6]).toString(),
-                                        amount: Buffer.from(R5Serialized[5]).toString(),
+                                        networkFee: BigInt("0x" + Buffer.from(R5Serialized[7]).toString("hex")).toString(10),
+                                        bridgeFee: BigInt("0x" + Buffer.from(R5Serialized[6]).toString("hex")).toString(10),
+                                        amount: BigInt("0x" + Buffer.from(R5Serialized[5]).toString("hex")).toString(10),
                                         sourceChainTokenId: Buffer.from(R5Serialized[8]).toString(),
                                         targetChainTokenId: Buffer.from(R5Serialized[9]).toString(),
                                         sourceTxId: Buffer.from(R5Serialized[0]).toString(),

package/dist/extractor/commitmentExtractor.js

@@ -49,7 +49,8 @@ class CommitmentExtractor extends AbstractExtractor {
                                         WID: WID,
                                         commitment: eventDigest,
                                         eventId: requestId,
-                                        commitmentBoxId: output.box_id().to_str(),
+                                        boxId: output.box_id().to_str(),
+                                        boxSerialized: Buffer.from(output.sigma_serialize_bytes()).toString("base64")
                                     });
                                 }
                             }
@@ -66,7 +67,7 @@ class CommitmentExtractor extends AbstractExtractor {
                 });
                 // process save commitments
                 this.actions.storeCommitments(commitments, block, this.id).then(() => {
-                    this.actions.spendCommitments(spendIds, block).then(() => {
+                    this.actions.spendCommitments(spendIds, block, this.id).then(() => {
                         resolve(true);
                     });
                 }).catch((e) => reject(e));

package/dist/extractor/permitExtractor.js

@@ -26,6 +26,7 @@ class PermitExtractor extends AbstractExtractor {
         return new Promise((resolve, reject) => {
             try {
                 const boxes = [];
+                const spendIds = [];
                 txs.forEach(transaction => {
                     for (let index = 0; index < transaction.outputs().len(); index++) {
                         const output = transaction.outputs().get(index);
@@ -40,7 +41,7 @@ class PermitExtractor extends AbstractExtractor {
                                     boxes.push({
                                         boxId: output.box_id().to_str(),
                                         boxSerialized: Buffer.from(output.sigma_serialize_bytes()).toString("base64"),
-                                        WID: Buffer.from(R4Serialized[0]).toString()
+                                        WID: Buffer.from(R4Serialized[0]).toString('hex')
                                     });
                                 }
                             }
@@ -49,9 +50,16 @@ class PermitExtractor extends AbstractExtractor {
                             continue;
                         }
                     }
+                    // process inputs
+                    for (let index = 0; index < transaction.inputs().len(); index++) {
+                        const input = transaction.inputs().get(index);
+                        spendIds.push(input.box_id().to_str());
+                    }
                 });
                 this.actions.storePermits(boxes, block, this.getId()).then(() => {
-                    resolve(true);
+                    this.actions.spendPermits(spendIds, block, this.getId()).then(() => {
+                        resolve(true);
+                    });
                 }).catch((e) => {
                     console.log(`Error in storing permits of the block ${block}`);
                     console.log(e);

package/dist/interfaces/extractedCommitment.d.ts

@@ -2,6 +2,7 @@ interface extractedCommitment {
     WID: string;
     commitment: string;
     eventId: string;
-    commitmentBoxId: string;
+    boxId: string;
+    boxSerialized: string;
 }
 export { extractedCommitment };

package/dist/migrations/{init.js → 1659787165000-initMigration.js}

@@ -4,19 +4,23 @@ export class initMigration1659787165000 {
         await queryRunner.query(`CREATE TABLE "commitment_entity" 
                     ("id" integer PRIMARY KEY AUTOINCREMENT NOT NULL, 
                     "extractor" varchar NOT NULL, 
-                    "eventId" varchar NOT NULL, 
+                    "eventId" varchar NOT NULL,
+                    "boxSerialized" varchar NOT NULL, 
                     "commitment" varchar NOT NULL, 
                     "WID" varchar NOT NULL, 
-                    "commitmentBoxId" varchar NOT NULL, 
-                    "blockId" varchar NOT NULL, 
-                    "spendBlock" varchar
+                    "boxId" varchar NOT NULL, 
+                    "block" varchar NOT NULL, 
+                    "height" INTEGER NOT NULL, 
+                    "spendBlock" varchar,
+                    "spendHeight" INTEGER,
+                    CONSTRAINT "UQ_cc294fc304a66f8f194840f1ece" UNIQUE ("boxId", "extractor")
                 )`);
         await queryRunner.query(`CREATE TABLE "event_trigger_entity" 
                     ("id" integer PRIMARY KEY AUTOINCREMENT NOT NULL, 
                     "extractor" varchar NOT NULL, 
                     "boxId" varchar NOT NULL, 
                     "boxSerialized" varchar NOT NULL, 
-                    "blockId" varchar NOT NULL,
+                    "block" varchar NOT NULL,
                     "fromChain" varchar NOT NULL,
                     "toChain" varchar NOT NULL,
                     "fromAddress" varchar NOT NULL,
@@ -28,15 +32,21 @@ export class initMigration1659787165000 {
                     "targetChainTokenId" varchar NOT NULL,
                     "sourceBlockId" varchar NOT NULL,
                     "sourceTxId" varchar NOT NULL,
-                    "WIDs" varchar NOT NULL
+                    "height" INTEGER NOT NULL, 
+                    "WIDs" varchar NOT NULL,
+                    CONSTRAINT "UQ_c905f221a1b6271ca4405dbbe5f" UNIQUE ("boxId", "extractor")
                 )`);
         await queryRunner.query(`CREATE TABLE "permit_entity" 
                     ("id" integer PRIMARY KEY AUTOINCREMENT NOT NULL, 
                     "extractor" varchar NOT NULL, 
                     "boxId" varchar NOT NULL, 
                     "boxSerialized" varchar NOT NULL, 
-                    "blockId" varchar NOT NULL,
-                    "WID" varchar NOT NULL
+                    "block" varchar NOT NULL,
+                    "height" INTEGER NOT NULL, 
+                    "WID" varchar NOT NULL,
+                    "spendBlock" varchar,
+                    "spendHeight" INTEGER,
+                     CONSTRAINT "UQ_d3226602b909b64bcaeadc39c3c" UNIQUE ("boxId", "extractor")
                 )`);
     }
     async down(queryRunner) {

package/dist/migrations/index.d.ts

@@ -1,2 +1,2 @@
-import { initMigration1659787165000 } from "./init";
+import { initMigration1659787165000 } from "./1659787165000-initMigration";
 export declare const migrations: (typeof initMigration1659787165000)[];

package/dist/migrations/index.js

@@ -1,2 +1,2 @@
-import { initMigration1659787165000 } from "./init";
+import { initMigration1659787165000 } from "./1659787165000-initMigration";
 export const migrations = [initMigration1659787165000];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rosen-bridge/watcher-data-extractor",
-  "version": "0.1.0-alpha-2",
+  "version": "0.1.0-alpha-5",
   "description": "Extractor for rosen specific boxes on ergo blockchain",
   "author": "Sahand Zoufan",
   "license": "GPL-3.0",