@pafi-dev/issuer-postgres 0.1.2 → 0.3.0

package/dist/index.cjs

@@ -28,6 +28,7 @@ var __decorateClass = (decorators, target, key, kind) => {
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  CreateRedemptionHistory1746230400001: () => CreateRedemptionHistory1746230400001,
   IndexerCursorEntity: () => IndexerCursorEntity,
   InitialSchema1700000000000: () => InitialSchema1700000000000,
   LedgerJournalEntity: () => LedgerJournalEntity,
@@ -37,6 +38,8 @@ __export(src_exports, {
   PendingCreditEntity: () => PendingCreditEntity,
   PostgresCursorStore: () => PostgresCursorStore,
   PostgresPointLedger: () => PostgresPointLedger,
+  PostgresRedemptionHistoryStore: () => PostgresRedemptionHistoryStore,
+  RedemptionHistoryEntity: () => RedemptionHistoryEntity,
   UserBalanceEntity: () => UserBalanceEntity
 });
 module.exports = __toCommonJS(src_exports);
@@ -105,7 +108,22 @@ __decorateClass([
 ], LockedMintEntity.prototype, "userOpHash", 2);
 LockedMintEntity = __decorateClass([
   (0, import_typeorm.Entity)({ name: "locked_mint_requests" }),
-  (0, import_typeorm.Index)(["userAddress", "status"])
+  (0, import_typeorm.Index)("IDX_locked_mint_user_token_status_expires", [
+    "userAddress",
+    "tokenAddress",
+    "status",
+    "expiresAt"
+  ]),
+  (0, import_typeorm.Index)("IDX_locked_mint_user_token_amount_status", [
+    "userAddress",
+    "tokenAddress",
+    "amount",
+    "status"
+  ]),
+  (0, import_typeorm.Index)("IDX_locked_mint_pending_expires", ["expiresAt"], {
+    where: `"status" = 'PENDING'`
+  }),
+  (0, import_typeorm.Index)("IDX_locked_mint_user_op_hash", ["userOpHash"])
 ], LockedMintEntity);
 
 // src/entities/pending-credit.entity.ts
@@ -258,10 +276,61 @@ __decorateClass([
 ], LedgerJournalEntity.prototype, "createdAt", 2);
 LedgerJournalEntity = __decorateClass([
   (0, import_typeorm4.Entity)({ name: "ledger_journal" }),
-  (0, import_typeorm4.Index)(["userAddress", "createdAt"])
+  (0, import_typeorm4.Index)(["userAddress", "createdAt"]),
+  (0, import_typeorm4.Index)(
+    "UQ_ledger_journal_user_token_tx_reason",
+    ["userAddress", "tokenAddress", "txHash", "reason"],
+    {
+      unique: true,
+      where: '"tx_hash" IS NOT NULL'
+    }
+  )
 ], LedgerJournalEntity);
 
 // src/postgresPointLedger.ts
+var RETRIABLE_PG_CODES = /* @__PURE__ */ new Set(["40P01", "40001"]);
+var UNIQUE_VIOLATION = "23505";
+var JOURNAL_IDEMPOTENCY_CONSTRAINT = "UQ_ledger_journal_user_token_tx_reason";
+var LEGACY_JOURNAL_IDEMPOTENCY_CONSTRAINT = "UQ_ledger_journal_user_tx_reason";
+function isRetriablePgError(err) {
+  const e = err;
+  if (!e) return false;
+  if (e.code && RETRIABLE_PG_CODES.has(e.code)) return true;
+  if (e.message && /deadlock detected|could not serialize/i.test(e.message)) {
+    return true;
+  }
+  return false;
+}
+function isJournalIdempotencyViolation(err) {
+  const e = err;
+  if (!e) return false;
+  const code = e.code ?? e.driverError?.code;
+  if (code !== UNIQUE_VIOLATION) return false;
+  const constraint = e.constraint ?? e.driverError?.constraint;
+  if (constraint === JOURNAL_IDEMPOTENCY_CONSTRAINT || constraint === LEGACY_JOURNAL_IDEMPOTENCY_CONSTRAINT) {
+    return true;
+  }
+  const message = e.message ?? e.driverError?.message ?? "";
+  return message.includes(JOURNAL_IDEMPOTENCY_CONSTRAINT) || message.includes(LEGACY_JOURNAL_IDEMPOTENCY_CONSTRAINT);
+}
+async function withDeadlockRetry(dataSource, fn, maxAttempts = 3) {
+  let attempt = 0;
+  let delayMs = 25;
+  for (; ; ) {
+    attempt++;
+    try {
+      return await dataSource.transaction(fn);
+    } catch (err) {
+      if (attempt >= maxAttempts || !isRetriablePgError(err)) {
+        throw err;
+      }
+      await new Promise(
+        (r) => setTimeout(r, delayMs + Math.floor(Math.random() * delayMs))
+      );
+      delayMs *= 2;
+    }
+  }
+}
 var PostgresPointLedger = class {
   constructor(dataSource, options = {}) {
     this.dataSource = dataSource;
@@ -274,13 +343,47 @@ var PostgresPointLedger = class {
   // ---------------------------------------------------------------------
   async getBalance(userAddress, tokenAddress) {
     const { user, token } = normalize(userAddress, tokenAddress);
-    await this.dataSource.getRepository(LockedMintEntity).createQueryBuilder().update().set({ status: "EXPIRED" }).where("status = :pending", { pending: "PENDING" }).andWhere("expires_at <= :now", { now: /* @__PURE__ */ new Date() }).execute();
-    const balanceRow = await this.dataSource.getRepository(UserBalanceEntity).findOne({ where: { userAddress: user, tokenAddress: token } });
+    const [balanceRow, locked] = await Promise.all([
+      this.dataSource.getRepository(UserBalanceEntity).findOne({ where: { userAddress: user, tokenAddress: token } }),
+      this.sumPendingLocks(user, token)
+    ]);
     const total = balanceRow?.balance ?? 0n;
-    const locked = await this.sumPendingLocks(user, token);
     const available = total - locked;
     return available < 0n ? 0n : available;
   }
+  /**
+   * Background sweep — marks all expired PENDING locks as EXPIRED in
+   * a single UPDATE. Issuers SHOULD call this periodically (e.g.
+   * every 1-5 minutes via a cron / NestJS `@Interval`) to keep the
+   * lock table from growing unbounded.
+   *
+   * A single sweep amortizes the write cost vs `getBalance` doing a
+   * wide UPDATE on every read. Returns the number of rows transitioned.
+   *
+   * @example
+   * ```ts
+   * import { Interval } from "@nestjs/schedule";
+   *
+   * @Injectable()
+   * export class LockSweepService {
+   *   constructor(private readonly ledger: PostgresPointLedger) {}
+   *
+   *   @Interval(5 * 60 * 1000) // 5 minutes
+   *   async sweep() {
+   *     const swept = await this.ledger.markExpiredLocks();
+   *     this.logger.debug(`expired ${swept} mint locks`);
+   *   }
+   * }
+   * ```
+   */
+  async markExpiredLocks() {
+    const result = await this.dataSource.getRepository(LockedMintEntity).createQueryBuilder().update().set({ status: "EXPIRED" }).where("status = :pending", { pending: "PENDING" }).andWhere("expires_at <= :now", { now: /* @__PURE__ */ new Date() }).execute();
+    const swept = result.affected ?? 0;
+    if (swept > 0) {
+      this.logger?.debug?.(`markExpiredLocks: swept ${swept} mint locks`);
+    }
+    return swept;
+  }
   async getLockedRequests(userAddress, tokenAddress) {
     const { user, token } = normalize(userAddress, tokenAddress);
     const rows = await this.dataSource.getRepository(LockedMintEntity).find({
@@ -346,8 +449,8 @@ var PostgresPointLedger = class {
       throw new Error("creditBalance: amount must be positive");
     }
     const { user, token } = normalize(userAddress, tokenAddress);
-    await this.dataSource.transaction(async (tx) => {
-      const existing = await tx.getRepository(UserBalanceEntity).findOne({ where: { userAddress: user, tokenAddress: token } });
+    await withDeadlockRetry(this.dataSource, async (tx) => {
+      const existing = await tx.getRepository(UserBalanceEntity).createQueryBuilder("balance").setLock("pessimistic_write").where("balance.user_address = :user", { user }).andWhere("balance.token_address = :token", { token }).getOne();
       const next = (existing?.balance ?? 0n) + amount;
       await tx.getRepository(UserBalanceEntity).upsert(
         { userAddress: user, tokenAddress: token, balance: next },
@@ -370,8 +473,8 @@ var PostgresPointLedger = class {
       throw new Error("lockForMinting: lockDurationMs must be positive");
     }
     const { user, token } = normalize(userAddress, tokenAddress);
-    return this.dataSource.transaction(async (tx) => {
-      const balanceRow = await tx.getRepository(UserBalanceEntity).findOne({ where: { userAddress: user, tokenAddress: token } });
+    return withDeadlockRetry(this.dataSource, async (tx) => {
+      const balanceRow = await tx.getRepository(UserBalanceEntity).createQueryBuilder("balance").setLock("pessimistic_write").where("balance.user_address = :user", { user }).andWhere("balance.token_address = :token", { token }).getOne();
       const total = balanceRow?.balance ?? 0n;
       const pendingTotal = await tx.getRepository(LockedMintEntity).createQueryBuilder("lock").select("COALESCE(SUM(CAST(lock.amount AS NUMERIC)), 0)", "sum").where("lock.user_address = :user", { user }).andWhere("lock.token_address = :token", { token }).andWhere("lock.status = :pending", { pending: "PENDING" }).andWhere("lock.expires_at > :now", { now: /* @__PURE__ */ new Date() }).getRawOne();
       const locked = pendingTotal ? BigInt(pendingTotal.sum) : 0n;
@@ -405,43 +508,72 @@ var PostgresPointLedger = class {
       throw new Error("deductBalance: amount must be positive");
     }
     const { user, token } = normalize(userAddress, tokenAddress);
-    await this.dataSource.transaction(async (tx) => {
-      const balance = await tx.getRepository(UserBalanceEntity).findOne({ where: { userAddress: user, tokenAddress: token } });
-      if (!balance || balance.balance < amount) {
-        throw new Error(
-          `Cannot deduct ${amount} from balance ${balance?.balance ?? 0n}`
+    try {
+      await withDeadlockRetry(this.dataSource, async (tx) => {
+        const balance = await tx.getRepository(UserBalanceEntity).createQueryBuilder("balance").setLock("pessimistic_write").where("balance.user_address = :user", { user }).andWhere("balance.token_address = :token", { token }).getOne();
+        const already = await tx.getRepository(LedgerJournalEntity).findOne({
+          where: {
+            userAddress: user,
+            tokenAddress: token,
+            txHash,
+            reason: "MINT_CONFIRMED"
+          }
+        });
+        if (already) {
+          this.logger?.debug?.(
+            `deductBalance: idempotent skip tx=${txHash} user=${user} token=${token}`
+          );
+          return;
+        }
+        if (!balance || balance.balance < amount) {
+          throw new Error(
+            `Cannot deduct ${amount} from balance ${balance?.balance ?? 0n}`
+          );
+        }
+        await tx.getRepository(UserBalanceEntity).update(
+          { userAddress: user, tokenAddress: token },
+          { balance: balance.balance - amount }
         );
-      }
-      await tx.getRepository(UserBalanceEntity).update(
-        { userAddress: user, tokenAddress: token },
-        { balance: balance.balance - amount }
-      );
-      await tx.getRepository(LedgerJournalEntity).insert({
-        userAddress: user,
-        tokenAddress: token,
-        delta: -amount,
-        reason: "MINT_CONFIRMED",
-        txHash
-      });
-      const match = await tx.getRepository(LockedMintEntity).findOne({
-        where: {
+        await tx.getRepository(LedgerJournalEntity).insert({
           userAddress: user,
           tokenAddress: token,
-          amount,
-          status: "PENDING"
-        },
-        order: { createdAt: "ASC" }
+          delta: -amount,
+          reason: "MINT_CONFIRMED",
+          txHash
+        });
+        const match = await tx.getRepository(LockedMintEntity).findOne({
+          where: {
+            userAddress: user,
+            tokenAddress: token,
+            amount,
+            status: "PENDING"
+          },
+          order: { createdAt: "ASC" }
+        });
+        if (match) {
+          await tx.getRepository(LockedMintEntity).update({ id: match.id }, { status: "MINTED", txHash });
+        }
       });
-      if (match) {
-        await tx.getRepository(LockedMintEntity).update({ id: match.id }, { status: "MINTED", txHash });
+    } catch (err) {
+      if (isJournalIdempotencyViolation(err)) {
+        this.logger?.debug?.(
+          `deductBalance: idempotent (concurrent race) tx=${txHash} user=${user}`
+        );
+        return;
       }
-    });
+      throw err;
+    }
     this.logger?.log?.(`deduct ${user}[${token}] -${amount} tx=${txHash}`);
   }
   async updateMintStatus(lockId, status, txHash) {
     const update = { status };
     if (txHash) update.txHash = txHash;
-    await this.dataSource.getRepository(LockedMintEntity).update({ id: lockId }, update);
+    const result = await this.dataSource.getRepository(LockedMintEntity).createQueryBuilder().update().set(update).where("id = :id", { id: lockId }).andWhere("status = :pending", { pending: "PENDING" }).execute();
+    if ((result.affected ?? 0) === 0) {
+      this.logger?.debug?.(
+        `updateMintStatus: lock ${lockId} not in PENDING (terminal state), no-op`
+      );
+    }
   }
   async bindMintUserOpHash(lockId, userOpHash) {
     await this.dataSource.getRepository(LockedMintEntity).update({ id: lockId }, { userOpHash });
@@ -473,8 +605,8 @@ var PostgresPointLedger = class {
     return row.id;
   }
   async resolveCreditByBurnTx(lockId, txHash) {
-    await this.dataSource.transaction(async (tx) => {
-      const credit = await tx.getRepository(PendingCreditEntity).findOne({ where: { id: lockId } });
+    const run = async () => withDeadlockRetry(this.dataSource, async (tx) => {
+      const credit = await tx.getRepository(PendingCreditEntity).createQueryBuilder("credit").setLock("pessimistic_write").where("credit.id = :id", { id: lockId }).getOne();
       if (!credit) {
         throw new Error(
           `resolveCreditByBurnTx: unknown pending credit ${lockId}`
@@ -508,7 +640,7 @@ var PostgresPointLedger = class {
         );
         return;
       }
-      const balance = await tx.getRepository(UserBalanceEntity).findOne({ where: { userAddress: user, tokenAddress: token } });
+      const balance = await tx.getRepository(UserBalanceEntity).createQueryBuilder("balance").setLock("pessimistic_write").where("balance.user_address = :user", { user }).andWhere("balance.token_address = :token", { token }).getOne();
       const next = (balance?.balance ?? 0n) + credit.amount;
       await tx.getRepository(UserBalanceEntity).upsert(
         { userAddress: user, tokenAddress: token, balance: next },
@@ -526,6 +658,18 @@ var PostgresPointLedger = class {
         { status: "RESOLVED", txHash, resolvedAt: /* @__PURE__ */ new Date() }
       );
     });
+    try {
+      await run();
+    } catch (err) {
+      if (isJournalIdempotencyViolation(err)) {
+        this.logger?.debug?.(
+          `resolveCreditByBurnTx: concurrent race on tx=${txHash} lock=${lockId}, replaying via sibling defense`
+        );
+        await run();
+      } else {
+        throw err;
+      }
+    }
     this.logger?.log?.(`resolve pending credit ${lockId} tx=${txHash}`);
   }
   /**
@@ -634,13 +778,114 @@ var PostgresCursorStore = class _PostgresCursorStore {
   }
 };
 
+// src/postgresRedemptionHistoryStore.ts
+var import_viem2 = require("viem");
+
+// src/entities/redemption-history.entity.ts
+var import_typeorm6 = require("typeorm");
+var RedemptionHistoryEntity = class {
+  id;
+  userAddress;
+  tokenAddress;
+  amountPt;
+  createdAtUnixSec;
+  reservationId;
+  rowCreatedAt;
+};
+__decorateClass([
+  (0, import_typeorm6.PrimaryGeneratedColumn)("uuid")
+], RedemptionHistoryEntity.prototype, "id", 2);
+__decorateClass([
+  (0, import_typeorm6.Column)({ name: "user_address", type: "varchar", length: 42 })
+], RedemptionHistoryEntity.prototype, "userAddress", 2);
+__decorateClass([
+  (0, import_typeorm6.Column)({ name: "token_address", type: "varchar", length: 42, nullable: true })
+], RedemptionHistoryEntity.prototype, "tokenAddress", 2);
+__decorateClass([
+  (0, import_typeorm6.Column)({
+    name: "amount_pt",
+    type: "numeric",
+    precision: 78,
+    scale: 0,
+    transformer: {
+      to: (value) => value.toString(),
+      from: (value) => BigInt(value)
+    }
+  })
+], RedemptionHistoryEntity.prototype, "amountPt", 2);
+__decorateClass([
+  (0, import_typeorm6.Column)({ name: "created_at_unix_sec", type: "bigint" })
+], RedemptionHistoryEntity.prototype, "createdAtUnixSec", 2);
+__decorateClass([
+  (0, import_typeorm6.Column)({
+    name: "reservation_id",
+    type: "varchar",
+    length: 64,
+    nullable: true
+  })
+], RedemptionHistoryEntity.prototype, "reservationId", 2);
+__decorateClass([
+  (0, import_typeorm6.CreateDateColumn)({ name: "row_created_at", type: "timestamptz" })
+], RedemptionHistoryEntity.prototype, "rowCreatedAt", 2);
+RedemptionHistoryEntity = __decorateClass([
+  (0, import_typeorm6.Entity)({ name: "redemption_history" }),
+  (0, import_typeorm6.Index)("idx_redemption_history_user_created", [
+    "userAddress",
+    "createdAtUnixSec"
+  ])
+], RedemptionHistoryEntity);
+
+// src/postgresRedemptionHistoryStore.ts
+var PostgresRedemptionHistoryStore = class {
+  constructor(dataSource) {
+    this.dataSource = dataSource;
+  }
+  dataSource;
+  async sumRedeemedSince(user, sinceUnixSec, pointTokenAddress) {
+    const repo = this.dataSource.getRepository(RedemptionHistoryEntity);
+    const qb = repo.createQueryBuilder("rh").select("COALESCE(SUM(rh.amount_pt), 0)", "sum").where("rh.user_address = :user", { user: (0, import_viem2.getAddress)(user) }).andWhere("rh.created_at_unix_sec >= :since", { since: sinceUnixSec });
+    if (pointTokenAddress !== void 0) {
+      qb.andWhere("rh.token_address = :token", {
+        token: (0, import_viem2.getAddress)(pointTokenAddress)
+      });
+    } else {
+    }
+    const row = await qb.getRawOne() ?? { sum: "0" };
+    return BigInt(row.sum ?? "0");
+  }
+  async getLastRedeemedAtUnixSec(user, pointTokenAddress) {
+    const repo = this.dataSource.getRepository(RedemptionHistoryEntity);
+    const qb = repo.createQueryBuilder("rh").select("rh.created_at_unix_sec", "ts").where("rh.user_address = :user", { user: (0, import_viem2.getAddress)(user) }).orderBy("rh.created_at_unix_sec", "DESC").limit(1);
+    if (pointTokenAddress !== void 0) {
+      qb.andWhere("rh.token_address = :token", {
+        token: (0, import_viem2.getAddress)(pointTokenAddress)
+      });
+    }
+    const row = await qb.getRawOne();
+    if (!row || row.ts === null) return null;
+    return Number(row.ts);
+  }
+  async recordRedemption(entry) {
+    const repo = this.dataSource.getRepository(RedemptionHistoryEntity);
+    const row = repo.create({
+      userAddress: (0, import_viem2.getAddress)(entry.user),
+      tokenAddress: entry.pointTokenAddress ? (0, import_viem2.getAddress)(entry.pointTokenAddress) : null,
+      amountPt: entry.amountPt,
+      createdAtUnixSec: String(entry.unixSec),
+      reservationId: entry.reservationId ?? null
+    });
+    await repo.save(row);
+  }
+};
+
 // src/entities/index.ts
 var PAFI_ENTITIES = [
   LockedMintEntity,
   PendingCreditEntity,
   UserBalanceEntity,
   LedgerJournalEntity,
-  IndexerCursorEntity
+  IndexerCursorEntity,
+  RedemptionHistoryEntity
 ];
 
 // src/migrations/1700000000000-InitialSchema.ts
@@ -746,10 +991,136 @@ var InitialSchema1700000000000 = class {
   }
 };
 
+// src/migrations/1746230400001-CreateRedemptionHistory.ts
+var CreateRedemptionHistory1746230400001 = class {
+  name = "CreateRedemptionHistory1746230400001";
+  async up(queryRunner) {
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS redemption_history (
+        id                    uuid           PRIMARY KEY DEFAULT gen_random_uuid(),
+        user_address          varchar(42)    NOT NULL,
+        token_address         varchar(42),
+        amount_pt             numeric(78, 0) NOT NULL,
+        created_at_unix_sec   bigint         NOT NULL,
+        reservation_id        varchar(64),
+        row_created_at        timestamptz    NOT NULL DEFAULT NOW(),
+        CONSTRAINT redemption_history_amount_positive CHECK (amount_pt > 0)
+      )
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_redemption_history_user_created
+        ON redemption_history (user_address, created_at_unix_sec DESC)
+    `);
+  }
+  async down(queryRunner) {
+    await queryRunner.query(
+      `DROP INDEX IF EXISTS idx_redemption_history_user_created`
+    );
+    await queryRunner.query(`DROP TABLE IF EXISTS redemption_history`);
+  }
+};
+
+// src/migrations/1747500000000-AddJournalIdempotencyIndex.ts
+var AddJournalIdempotencyIndex1747500000000 = class {
+  name = "AddJournalIdempotencyIndex1747500000000";
+  async up(queryRunner) {
+    await queryRunner.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS "UQ_ledger_journal_user_tx_reason"
+        ON "ledger_journal" ("user_address", "tx_hash", "reason")
+        WHERE "tx_hash" IS NOT NULL
+    `);
+  }
+  async down(queryRunner) {
+    await queryRunner.query(
+      `DROP INDEX IF EXISTS "UQ_ledger_journal_user_tx_reason"`
+    );
+  }
+};
+
+// src/migrations/1747600000000-AddLockedMintCompositeIndexes.ts
+var AddLockedMintCompositeIndexes1747600000000 = class {
+  name = "AddLockedMintCompositeIndexes1747600000000";
+  /**
+   * CONCURRENTLY index DDL cannot run inside a transaction. Tell
+   * TypeORM to issue these statements directly.
+   */
+  transaction = false;
+  async up(queryRunner) {
+    await queryRunner.query(`
+      CREATE INDEX CONCURRENTLY IF NOT EXISTS
+        "IDX_locked_mint_user_token_status_expires"
+      ON "locked_mint_requests"
+        ("user_address", "token_address", "status", "expires_at")
+    `);
+    await queryRunner.query(`
+      CREATE INDEX CONCURRENTLY IF NOT EXISTS
+        "IDX_locked_mint_user_token_amount_status"
+      ON "locked_mint_requests"
+        ("user_address", "token_address", "amount", "status")
+    `);
+    await queryRunner.query(`
+      CREATE INDEX CONCURRENTLY IF NOT EXISTS
+        "IDX_locked_mint_pending_expires"
+      ON "locked_mint_requests" ("expires_at")
+      WHERE "status" = 'PENDING'
+    `);
+    await queryRunner.query(
+      `DROP INDEX CONCURRENTLY IF EXISTS "IDX_locked_mint_user_status"`
+    );
+  }
+  async down(queryRunner) {
+    await queryRunner.query(`
+      CREATE INDEX CONCURRENTLY IF NOT EXISTS "IDX_locked_mint_user_status"
+      ON "locked_mint_requests" ("user_address", "token_address", "status")
+    `);
+    await queryRunner.query(
+      `DROP INDEX CONCURRENTLY IF EXISTS "IDX_locked_mint_pending_expires"`
+    );
+    await queryRunner.query(
+      `DROP INDEX CONCURRENTLY IF EXISTS "IDX_locked_mint_user_token_amount_status"`
+    );
+    await queryRunner.query(
+      `DROP INDEX CONCURRENTLY IF EXISTS "IDX_locked_mint_user_token_status_expires"`
+    );
+  }
+};
+
+// src/migrations/1747700000000-FixIdempotencyAddTokenAddress.ts
+var FixIdempotencyAddTokenAddress1747700000000 = class {
+  name = "FixIdempotencyAddTokenAddress1747700000000";
+  async up(queryRunner) {
+    await queryRunner.query(
+      `DROP INDEX IF EXISTS "UQ_ledger_journal_user_tx_reason"`
+    );
+    await queryRunner.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS "UQ_ledger_journal_user_token_tx_reason"
+        ON "ledger_journal" ("user_address", "token_address", "tx_hash", "reason")
+        WHERE "tx_hash" IS NOT NULL
+    `);
+  }
+  async down(queryRunner) {
+    await queryRunner.query(
+      `DROP INDEX IF EXISTS "UQ_ledger_journal_user_token_tx_reason"`
+    );
+    await queryRunner.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS "UQ_ledger_journal_user_tx_reason"
+        ON "ledger_journal" ("user_address", "tx_hash", "reason")
+        WHERE "tx_hash" IS NOT NULL
+    `);
+  }
+};
+
 // src/migrations/index.ts
-var PAFI_MIGRATIONS = [InitialSchema1700000000000];
+var PAFI_MIGRATIONS = [
+  InitialSchema1700000000000,
+  CreateRedemptionHistory1746230400001,
+  AddJournalIdempotencyIndex1747500000000,
+  AddLockedMintCompositeIndexes1747600000000,
+  FixIdempotencyAddTokenAddress1747700000000
+];
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CreateRedemptionHistory1746230400001,
   IndexerCursorEntity,
   InitialSchema1700000000000,
   LedgerJournalEntity,
@@ -759,6 +1130,8 @@ var PAFI_MIGRATIONS = [InitialSchema1700000000000];
   PendingCreditEntity,
   PostgresCursorStore,
   PostgresPointLedger,
+  PostgresRedemptionHistoryStore,
+  RedemptionHistoryEntity,
   UserBalanceEntity
 });
 //# sourceMappingURL=index.cjs.map