@pafi-dev/issuer-postgres 0.1.0

package/dist/index.js

@@ -0,0 +1,749 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+
+// src/postgresPointLedger.ts
+import { getAddress } from "viem";
+
+// src/entities/locked-mint.entity.ts
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  PrimaryGeneratedColumn
+} from "typeorm";
+var LockedMintEntity = class {
+  id;
+  userAddress;
+  tokenAddress;
+  amount;
+  status;
+  createdAt;
+  expiresAt;
+  txHash;
+  userOpHash;
+};
+__decorateClass([
+  PrimaryGeneratedColumn("uuid")
+], LockedMintEntity.prototype, "id", 2);
+__decorateClass([
+  Column({ name: "user_address", type: "varchar", length: 42 })
+], LockedMintEntity.prototype, "userAddress", 2);
+__decorateClass([
+  Column({ name: "token_address", type: "varchar", length: 42 })
+], LockedMintEntity.prototype, "tokenAddress", 2);
+__decorateClass([
+  Column({
+    name: "amount",
+    type: "numeric",
+    precision: 78,
+    scale: 0,
+    transformer: {
+      to: (value) => value.toString(),
+      from: (value) => BigInt(value)
+    }
+  })
+], LockedMintEntity.prototype, "amount", 2);
+__decorateClass([
+  Column({
+    name: "status",
+    type: "varchar",
+    length: 16,
+    default: "PENDING"
+  })
+], LockedMintEntity.prototype, "status", 2);
+__decorateClass([
+  CreateDateColumn({ name: "created_at" })
+], LockedMintEntity.prototype, "createdAt", 2);
+__decorateClass([
+  Column({ name: "expires_at", type: "timestamp with time zone" })
+], LockedMintEntity.prototype, "expiresAt", 2);
+__decorateClass([
+  Column({ name: "tx_hash", type: "varchar", length: 66, nullable: true })
+], LockedMintEntity.prototype, "txHash", 2);
+__decorateClass([
+  Column({
+    name: "user_op_hash",
+    type: "varchar",
+    length: 66,
+    nullable: true
+  })
+], LockedMintEntity.prototype, "userOpHash", 2);
+LockedMintEntity = __decorateClass([
+  Entity({ name: "locked_mint_requests" }),
+  Index(["userAddress", "status"])
+], LockedMintEntity);
+
+// src/entities/pending-credit.entity.ts
+import {
+  Column as Column2,
+  CreateDateColumn as CreateDateColumn2,
+  Entity as Entity2,
+  Index as Index2,
+  PrimaryGeneratedColumn as PrimaryGeneratedColumn2
+} from "typeorm";
+var PendingCreditEntity = class {
+  id;
+  userAddress;
+  tokenAddress;
+  amount;
+  status;
+  txHash;
+  userOpHash;
+  createdAt;
+  expiresAt;
+  resolvedAt;
+};
+__decorateClass([
+  PrimaryGeneratedColumn2("uuid")
+], PendingCreditEntity.prototype, "id", 2);
+__decorateClass([
+  Column2({ name: "user_address", type: "varchar", length: 42 })
+], PendingCreditEntity.prototype, "userAddress", 2);
+__decorateClass([
+  Column2({ name: "token_address", type: "varchar", length: 42 })
+], PendingCreditEntity.prototype, "tokenAddress", 2);
+__decorateClass([
+  Column2({
+    name: "amount",
+    type: "numeric",
+    precision: 78,
+    scale: 0,
+    transformer: {
+      to: (value) => value.toString(),
+      from: (value) => BigInt(value)
+    }
+  })
+], PendingCreditEntity.prototype, "amount", 2);
+__decorateClass([
+  Column2({
+    name: "status",
+    type: "varchar",
+    length: 16,
+    default: "PENDING"
+  })
+], PendingCreditEntity.prototype, "status", 2);
+__decorateClass([
+  Column2({ name: "tx_hash", type: "varchar", length: 66, nullable: true })
+], PendingCreditEntity.prototype, "txHash", 2);
+__decorateClass([
+  Column2({
+    name: "user_op_hash",
+    type: "varchar",
+    length: 66,
+    nullable: true
+  })
+], PendingCreditEntity.prototype, "userOpHash", 2);
+__decorateClass([
+  CreateDateColumn2({ name: "created_at" })
+], PendingCreditEntity.prototype, "createdAt", 2);
+__decorateClass([
+  Column2({ name: "expires_at", type: "timestamp with time zone" })
+], PendingCreditEntity.prototype, "expiresAt", 2);
+__decorateClass([
+  Column2({
+    name: "resolved_at",
+    type: "timestamp with time zone",
+    nullable: true
+  })
+], PendingCreditEntity.prototype, "resolvedAt", 2);
+PendingCreditEntity = __decorateClass([
+  Entity2({ name: "pending_credits" }),
+  Index2(["userAddress", "status"]),
+  Index2(["txHash"])
+], PendingCreditEntity);
+
+// src/entities/user-balance.entity.ts
+import { Column as Column3, Entity as Entity3, PrimaryColumn, UpdateDateColumn } from "typeorm";
+var UserBalanceEntity = class {
+  userAddress;
+  tokenAddress;
+  balance;
+  updatedAt;
+};
+__decorateClass([
+  PrimaryColumn({ name: "user_address", type: "varchar", length: 42 })
+], UserBalanceEntity.prototype, "userAddress", 2);
+__decorateClass([
+  PrimaryColumn({ name: "token_address", type: "varchar", length: 42 })
+], UserBalanceEntity.prototype, "tokenAddress", 2);
+__decorateClass([
+  Column3({
+    name: "balance",
+    type: "numeric",
+    precision: 78,
+    scale: 0,
+    default: 0,
+    transformer: {
+      to: (value) => value.toString(),
+      from: (value) => BigInt(value)
+    }
+  })
+], UserBalanceEntity.prototype, "balance", 2);
+__decorateClass([
+  UpdateDateColumn({ name: "updated_at" })
+], UserBalanceEntity.prototype, "updatedAt", 2);
+UserBalanceEntity = __decorateClass([
+  Entity3({ name: "user_balances" })
+], UserBalanceEntity);
+
+// src/entities/ledger-journal.entity.ts
+import {
+  Column as Column4,
+  CreateDateColumn as CreateDateColumn3,
+  Entity as Entity4,
+  Index as Index3,
+  PrimaryGeneratedColumn as PrimaryGeneratedColumn3
+} from "typeorm";
+var LedgerJournalEntity = class {
+  id;
+  userAddress;
+  tokenAddress;
+  delta;
+  reason;
+  txHash;
+  createdAt;
+};
+__decorateClass([
+  PrimaryGeneratedColumn3("uuid")
+], LedgerJournalEntity.prototype, "id", 2);
+__decorateClass([
+  Column4({ name: "user_address", type: "varchar", length: 42 })
+], LedgerJournalEntity.prototype, "userAddress", 2);
+__decorateClass([
+  Column4({ name: "token_address", type: "varchar", length: 42 })
+], LedgerJournalEntity.prototype, "tokenAddress", 2);
+__decorateClass([
+  Column4({
+    name: "delta",
+    type: "numeric",
+    precision: 78,
+    scale: 0,
+    transformer: {
+      to: (value) => value.toString(),
+      from: (value) => BigInt(value)
+    }
+  })
+], LedgerJournalEntity.prototype, "delta", 2);
+__decorateClass([
+  Column4({ name: "reason", type: "varchar", length: 128 })
+], LedgerJournalEntity.prototype, "reason", 2);
+__decorateClass([
+  Column4({ name: "tx_hash", type: "varchar", length: 66, nullable: true })
+], LedgerJournalEntity.prototype, "txHash", 2);
+__decorateClass([
+  CreateDateColumn3({ name: "created_at" })
+], LedgerJournalEntity.prototype, "createdAt", 2);
+LedgerJournalEntity = __decorateClass([
+  Entity4({ name: "ledger_journal" }),
+  Index3(["userAddress", "createdAt"])
+], LedgerJournalEntity);
+
+// src/postgresPointLedger.ts
+var PostgresPointLedger = class {
+  constructor(dataSource, options = {}) {
+    this.dataSource = dataSource;
+    this.logger = options.logger;
+  }
+  dataSource;
+  logger;
+  // ---------------------------------------------------------------------
+  // Read
+  // ---------------------------------------------------------------------
+  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 total = balanceRow?.balance ?? 0n;
+    const locked = await this.sumPendingLocks(user, token);
+    const available = total - locked;
+    return available < 0n ? 0n : available;
+  }
+  async getLockedRequests(userAddress, tokenAddress) {
+    const { user, token } = normalize(userAddress, tokenAddress);
+    const rows = await this.dataSource.getRepository(LockedMintEntity).find({
+      where: { userAddress: user, tokenAddress: token, status: "PENDING" },
+      order: { createdAt: "ASC" }
+    });
+    return rows.map((row) => this.toSdkLock(row));
+  }
+  async getMintLock(lockId, userAddress) {
+    const row = await this.dataSource.getRepository(LockedMintEntity).findOne({ where: { id: lockId } });
+    if (!row) return null;
+    if (userAddress && row.userAddress.toLowerCase() !== userAddress.toLowerCase()) {
+      return null;
+    }
+    return this.toSdkLock(row);
+  }
+  /** Raw TypeORM row — escape hatch for callers that need entity fields. */
+  async getMintLockEntity(lockId) {
+    return this.dataSource.getRepository(LockedMintEntity).findOne({ where: { id: lockId } });
+  }
+  async getPendingCredit(lockId, userAddress) {
+    const row = await this.dataSource.getRepository(PendingCreditEntity).findOne({ where: { id: lockId } });
+    if (!row) return null;
+    if (userAddress && row.userAddress.toLowerCase() !== userAddress.toLowerCase()) {
+      return null;
+    }
+    return {
+      lockId: row.id,
+      userAddress: getAddress(row.userAddress),
+      amount: row.amount,
+      tokenAddress: row.tokenAddress ? getAddress(row.tokenAddress) : void 0,
+      status: row.status,
+      createdAt: row.createdAt.getTime(),
+      expiresAt: row.expiresAt.getTime(),
+      txHash: row.txHash ?? void 0,
+      resolvedAt: row.resolvedAt?.getTime(),
+      userOpHash: row.userOpHash ?? void 0
+    };
+  }
+  /** Raw TypeORM row escape hatch for credits. */
+  async getPendingCreditEntity(lockId) {
+    return this.dataSource.getRepository(PendingCreditEntity).findOne({ where: { id: lockId } });
+  }
+  /**
+   * Paginated list of a user's mint requests across all statuses and
+   * all tokens — used by `GET /user/transactions` reference endpoint.
+   */
+  async listUserTransactions(userAddress, limit, offset) {
+    const user = getAddress(userAddress);
+    const [rows, total] = await this.dataSource.getRepository(LockedMintEntity).findAndCount({
+      where: { userAddress: user },
+      order: { createdAt: "DESC" },
+      take: limit,
+      skip: offset
+    });
+    return { rows, total };
+  }
+  // ---------------------------------------------------------------------
+  // Write
+  // ---------------------------------------------------------------------
+  async creditBalance(userAddress, amount, reason, tokenAddress) {
+    if (amount <= 0n) {
+      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 } });
+      const next = (existing?.balance ?? 0n) + amount;
+      await tx.getRepository(UserBalanceEntity).upsert(
+        { userAddress: user, tokenAddress: token, balance: next },
+        { conflictPaths: ["userAddress", "tokenAddress"] }
+      );
+      await tx.getRepository(LedgerJournalEntity).insert({
+        userAddress: user,
+        tokenAddress: token,
+        delta: amount,
+        reason
+      });
+    });
+    this.logger?.debug?.(`credit ${user}[${token}] +${amount} (${reason})`);
+  }
+  async lockForMinting(userAddress, amount, lockDurationMs, tokenAddress) {
+    if (amount <= 0n) {
+      throw new Error("lockForMinting: amount must be positive");
+    }
+    if (lockDurationMs <= 0) {
+      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 } });
+      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;
+      const available = total - locked;
+      if (available < amount) {
+        throw new Error(
+          `Insufficient balance: available=${available}, requested=${amount}`
+        );
+      }
+      const lock = await tx.getRepository(LockedMintEntity).save({
+        userAddress: user,
+        tokenAddress: token,
+        amount,
+        status: "PENDING",
+        expiresAt: new Date(Date.now() + lockDurationMs)
+      });
+      this.logger?.debug?.(
+        `lock ${lock.id} ${user}[${token}] amount=${amount}`
+      );
+      return lock.id;
+    });
+  }
+  async releaseLock(lockId) {
+    const result = await this.dataSource.getRepository(LockedMintEntity).delete({ id: lockId, status: "PENDING" });
+    if ((result.affected ?? 0) > 0) {
+      this.logger?.debug?.(`release lock ${lockId}`);
+    }
+  }
+  async deductBalance(userAddress, amount, txHash, tokenAddress) {
+    if (amount <= 0n) {
+      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}`
+        );
+      }
+      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: {
+          userAddress: user,
+          tokenAddress: token,
+          amount,
+          status: "PENDING"
+        },
+        order: { createdAt: "ASC" }
+      });
+      if (match) {
+        await tx.getRepository(LockedMintEntity).update({ id: match.id }, { status: "MINTED", txHash });
+      }
+    });
+    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);
+  }
+  async bindMintUserOpHash(lockId, userOpHash) {
+    await this.dataSource.getRepository(LockedMintEntity).update({ id: lockId }, { userOpHash });
+  }
+  async bindCreditUserOpHash(lockId, userOpHash) {
+    await this.dataSource.getRepository(PendingCreditEntity).update({ id: lockId }, { userOpHash });
+  }
+  // ---------------------------------------------------------------------
+  // Reverse flow (burn → off-chain credit)
+  // ---------------------------------------------------------------------
+  async reservePendingCredit(userAddress, amount, durationMs, tokenAddress) {
+    if (amount <= 0n) {
+      throw new Error("reservePendingCredit: amount must be positive");
+    }
+    if (durationMs <= 0) {
+      throw new Error("reservePendingCredit: durationMs must be positive");
+    }
+    const { user, token } = normalize(userAddress, tokenAddress);
+    const row = await this.dataSource.getRepository(PendingCreditEntity).save({
+      userAddress: user,
+      tokenAddress: token,
+      amount,
+      status: "PENDING",
+      expiresAt: new Date(Date.now() + durationMs)
+    });
+    this.logger?.debug?.(
+      `reserve pending credit ${row.id} ${user}[${token}] +${amount}`
+    );
+    return row.id;
+  }
+  async resolveCreditByBurnTx(lockId, txHash) {
+    await this.dataSource.transaction(async (tx) => {
+      const credit = await tx.getRepository(PendingCreditEntity).findOne({ where: { id: lockId } });
+      if (!credit) {
+        throw new Error(
+          `resolveCreditByBurnTx: unknown pending credit ${lockId}`
+        );
+      }
+      if (credit.status === "RESOLVED") {
+        if (credit.txHash === txHash) return;
+        throw new Error(
+          `resolveCreditByBurnTx: credit ${lockId} already resolved with a different txHash`
+        );
+      }
+      if (credit.status === "EXPIRED") {
+        throw new Error(
+          `resolveCreditByBurnTx: credit ${lockId} already expired \u2014 burn landed too late`
+        );
+      }
+      const user = credit.userAddress;
+      const token = credit.tokenAddress;
+      const alreadyResolved = await tx.getRepository(PendingCreditEntity).findOne({
+        where: {
+          userAddress: user,
+          tokenAddress: token,
+          txHash,
+          status: "RESOLVED"
+        }
+      });
+      if (alreadyResolved) {
+        await tx.getRepository(PendingCreditEntity).update(
+          { id: lockId },
+          { status: "RESOLVED", txHash, resolvedAt: /* @__PURE__ */ new Date() }
+        );
+        return;
+      }
+      const balance = await tx.getRepository(UserBalanceEntity).findOne({ where: { userAddress: user, tokenAddress: token } });
+      const next = (balance?.balance ?? 0n) + credit.amount;
+      await tx.getRepository(UserBalanceEntity).upsert(
+        { userAddress: user, tokenAddress: token, balance: next },
+        { conflictPaths: ["userAddress", "tokenAddress"] }
+      );
+      await tx.getRepository(LedgerJournalEntity).insert({
+        userAddress: user,
+        tokenAddress: token,
+        delta: credit.amount,
+        reason: "BURN_FOR_CREDIT",
+        txHash
+      });
+      await tx.getRepository(PendingCreditEntity).update(
+        { id: lockId },
+        { status: "RESOLVED", txHash, resolvedAt: /* @__PURE__ */ new Date() }
+      );
+    });
+    this.logger?.log?.(`resolve pending credit ${lockId} tx=${txHash}`);
+  }
+  /**
+   * Used by `BurnIndexer.matchLockId` to resolve an on-chain burn
+   * event back to a pending credit row. Returns the oldest matching
+   * `(user, token, amount, status: PENDING)` lockId, or undefined
+   * when no match exists (unsolicited burn — indexer skips).
+   */
+  async findPendingCreditLockId(userAddress, amount, tokenAddress) {
+    const { user, token } = normalize(userAddress, tokenAddress);
+    const row = await this.dataSource.getRepository(PendingCreditEntity).findOne({
+      where: {
+        userAddress: user,
+        tokenAddress: token,
+        amount,
+        status: "PENDING"
+      },
+      order: { createdAt: "ASC" }
+    });
+    return row?.id;
+  }
+  // ---------------------------------------------------------------------
+  // Internals
+  // ---------------------------------------------------------------------
+  async sumPendingLocks(userAddress, tokenAddress) {
+    const row = await this.dataSource.getRepository(LockedMintEntity).createQueryBuilder("lock").select("COALESCE(SUM(CAST(lock.amount AS NUMERIC)), 0)", "sum").where("lock.user_address = :user", { user: userAddress }).andWhere("lock.token_address = :token", { token: tokenAddress }).andWhere("lock.status = :pending", { pending: "PENDING" }).andWhere("lock.expires_at > :now", { now: /* @__PURE__ */ new Date() }).getRawOne();
+    return row ? BigInt(row.sum) : 0n;
+  }
+  toSdkLock(row) {
+    const out = {
+      lockId: row.id,
+      userAddress: row.userAddress,
+      tokenAddress: row.tokenAddress,
+      amount: row.amount,
+      status: row.status,
+      createdAt: row.createdAt.getTime(),
+      expiresAt: row.expiresAt.getTime()
+    };
+    if (row.txHash) out.txHash = row.txHash;
+    if (row.userOpHash) out.userOpHash = row.userOpHash;
+    return out;
+  }
+};
+function normalize(userAddress, tokenAddress) {
+  if (!tokenAddress) {
+    throw new Error(
+      "PostgresPointLedger: tokenAddress is required on every call (multi-token ledger)"
+    );
+  }
+  return {
+    user: getAddress(userAddress),
+    token: getAddress(tokenAddress)
+  };
+}
+
+// src/entities/indexer-cursor.entity.ts
+import { Column as Column5, Entity as Entity5, PrimaryColumn as PrimaryColumn2, UpdateDateColumn as UpdateDateColumn2 } from "typeorm";
+var IndexerCursorEntity = class {
+  id;
+  nextBlock;
+  updatedAt;
+};
+__decorateClass([
+  PrimaryColumn2({ type: "varchar", length: 64 })
+], IndexerCursorEntity.prototype, "id", 2);
+__decorateClass([
+  Column5({
+    name: "next_block",
+    type: "numeric",
+    precision: 78,
+    scale: 0,
+    transformer: {
+      to: (value) => value.toString(),
+      from: (value) => BigInt(value)
+    }
+  })
+], IndexerCursorEntity.prototype, "nextBlock", 2);
+__decorateClass([
+  UpdateDateColumn2({ name: "updated_at" })
+], IndexerCursorEntity.prototype, "updatedAt", 2);
+IndexerCursorEntity = __decorateClass([
+  Entity5({ name: "indexer_cursors" })
+], IndexerCursorEntity);
+
+// src/postgresCursorStore.ts
+var PostgresCursorStore = class _PostgresCursorStore {
+  constructor(dataSource, cursorId = "default") {
+    this.dataSource = dataSource;
+    this.cursorId = cursorId;
+  }
+  dataSource;
+  cursorId;
+  async load() {
+    const row = await this.dataSource.getRepository(IndexerCursorEntity).findOne({ where: { id: this.cursorId } });
+    return row?.nextBlock;
+  }
+  async save(blockNumber) {
+    await this.dataSource.getRepository(IndexerCursorEntity).upsert(
+      { id: this.cursorId, nextBlock: blockNumber },
+      { conflictPaths: ["id"] }
+    );
+  }
+  /** Derived store keyed by a different `id` — for sibling indexers. */
+  forKey(cursorId) {
+    return new _PostgresCursorStore(this.dataSource, cursorId);
+  }
+};
+
+// src/entities/index.ts
+var PAFI_ENTITIES = [
+  LockedMintEntity,
+  PendingCreditEntity,
+  UserBalanceEntity,
+  LedgerJournalEntity,
+  IndexerCursorEntity
+];
+
+// src/migrations/1700000000000-InitialSchema.ts
+var InitialSchema1700000000000 = class {
+  name = "InitialSchema1700000000000";
+  async up(queryRunner) {
+    await queryRunner.query(`CREATE EXTENSION IF NOT EXISTS "pgcrypto"`);
+    await queryRunner.query(`
+      CREATE TABLE "user_balances" (
+        "user_address" varchar(42) NOT NULL,
+        "token_address" varchar(42) NOT NULL,
+        "balance" numeric(78, 0) NOT NULL DEFAULT 0,
+        "updated_at" TIMESTAMP NOT NULL DEFAULT now(),
+        CONSTRAINT "PK_user_balances" PRIMARY KEY ("user_address", "token_address")
+      )
+    `);
+    await queryRunner.query(`
+      CREATE TABLE "locked_mint_requests" (
+        "id" uuid NOT NULL DEFAULT gen_random_uuid(),
+        "user_address" varchar(42) NOT NULL,
+        "token_address" varchar(42) NOT NULL,
+        "amount" numeric(78, 0) NOT NULL,
+        "status" varchar(16) NOT NULL DEFAULT 'PENDING',
+        "created_at" TIMESTAMP NOT NULL DEFAULT now(),
+        "expires_at" TIMESTAMP WITH TIME ZONE NOT NULL,
+        "tx_hash" varchar(66),
+        "user_op_hash" varchar(66),
+        CONSTRAINT "PK_locked_mint_requests" PRIMARY KEY ("id")
+      )
+    `);
+    await queryRunner.query(`
+      CREATE INDEX "IDX_locked_mint_user_status"
+        ON "locked_mint_requests" ("user_address", "token_address", "status")
+    `);
+    await queryRunner.query(`
+      CREATE INDEX "IDX_locked_mint_user_op_hash"
+        ON "locked_mint_requests" ("user_op_hash")
+    `);
+    await queryRunner.query(`
+      CREATE TABLE "pending_credits" (
+        "id" uuid NOT NULL DEFAULT gen_random_uuid(),
+        "user_address" varchar(42) NOT NULL,
+        "token_address" varchar(42) NOT NULL,
+        "amount" numeric(78, 0) NOT NULL,
+        "status" varchar(16) NOT NULL DEFAULT 'PENDING',
+        "tx_hash" varchar(66),
+        "user_op_hash" varchar(66),
+        "created_at" TIMESTAMP NOT NULL DEFAULT now(),
+        "expires_at" TIMESTAMP WITH TIME ZONE NOT NULL,
+        "resolved_at" TIMESTAMP WITH TIME ZONE,
+        CONSTRAINT "PK_pending_credits" PRIMARY KEY ("id")
+      )
+    `);
+    await queryRunner.query(`
+      CREATE INDEX "IDX_pending_credits_user_status"
+        ON "pending_credits" ("user_address", "token_address", "status")
+    `);
+    await queryRunner.query(`
+      CREATE INDEX "IDX_pending_credits_tx_hash"
+        ON "pending_credits" ("tx_hash")
+    `);
+    await queryRunner.query(`
+      CREATE INDEX "IDX_pending_credits_user_op_hash"
+        ON "pending_credits" ("user_op_hash")
+    `);
+    await queryRunner.query(`
+      CREATE TABLE "ledger_journal" (
+        "id" uuid NOT NULL DEFAULT gen_random_uuid(),
+        "user_address" varchar(42) NOT NULL,
+        "token_address" varchar(42) NOT NULL,
+        "delta" numeric(78, 0) NOT NULL,
+        "reason" varchar(128) NOT NULL,
+        "tx_hash" varchar(66),
+        "created_at" TIMESTAMP NOT NULL DEFAULT now(),
+        CONSTRAINT "PK_ledger_journal" PRIMARY KEY ("id")
+      )
+    `);
+    await queryRunner.query(`
+      CREATE INDEX "IDX_ledger_journal_user_created"
+        ON "ledger_journal" ("user_address", "token_address", "created_at")
+    `);
+    await queryRunner.query(`
+      CREATE TABLE "indexer_cursors" (
+        "id" varchar(64) NOT NULL,
+        "next_block" numeric(78, 0) NOT NULL,
+        "updated_at" TIMESTAMP NOT NULL DEFAULT now(),
+        CONSTRAINT "PK_indexer_cursors" PRIMARY KEY ("id")
+      )
+    `);
+  }
+  async down(queryRunner) {
+    await queryRunner.query(`DROP TABLE "indexer_cursors"`);
+    await queryRunner.query(`DROP INDEX "IDX_ledger_journal_user_created"`);
+    await queryRunner.query(`DROP TABLE "ledger_journal"`);
+    await queryRunner.query(`DROP INDEX "IDX_pending_credits_user_op_hash"`);
+    await queryRunner.query(`DROP INDEX "IDX_pending_credits_tx_hash"`);
+    await queryRunner.query(`DROP INDEX "IDX_pending_credits_user_status"`);
+    await queryRunner.query(`DROP TABLE "pending_credits"`);
+    await queryRunner.query(`DROP INDEX "IDX_locked_mint_user_op_hash"`);
+    await queryRunner.query(`DROP INDEX "IDX_locked_mint_user_status"`);
+    await queryRunner.query(`DROP TABLE "locked_mint_requests"`);
+    await queryRunner.query(`DROP TABLE "user_balances"`);
+  }
+};
+
+// src/migrations/index.ts
+var PAFI_MIGRATIONS = [InitialSchema1700000000000];
+export {
+  IndexerCursorEntity,
+  InitialSchema1700000000000,
+  LedgerJournalEntity,
+  LockedMintEntity,
+  PAFI_ENTITIES,
+  PAFI_MIGRATIONS,
+  PendingCreditEntity,
+  PostgresCursorStore,
+  PostgresPointLedger,
+  UserBalanceEntity
+};
+//# sourceMappingURL=index.js.map