multivendor-wallet 0.0.1

package/README.md

@@ -0,0 +1,21 @@
+# multivendor-wallet
+
+Framework-agnostic wallet ledger engine for multi-vendor marketplaces.
+
+## Operations
+
+- `credit` / `debit` — adjust available balance (integer minor units / paise)
+- `hold` / `release` / `cancelHold` — escrow lifecycle
+- `transfer` — atomic debit + credit
+- `getBalance` — `{ available, held, total }` where `total = available + held`
+
+## Host integration
+
+Implement `IWalletStore` with your persistence layer (TypeORM adapter ships in Myownbazaar_server). Pass `{ nativeTx: entityManager }` to join an existing database transaction.
+
+## Publish
+
+```bash
+pnpm run build && pnpm run test
+# tag: wallet-v0.0.1
+```

package/dist/hooks/index.cjs

@@ -0,0 +1,681 @@
+'use strict';
+
+var typeorm = require('typeorm');
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/currency.ts
+function toMinorUnit(amount) {
+  return Math.round(amount * 100);
+}
+__name(toMinorUnit, "toMinorUnit");
+function fromMinorUnit(amount) {
+  return amount / 100;
+}
+__name(fromMinorUnit, "fromMinorUnit");
+
+// src/types.ts
+var WalletAccountType = /* @__PURE__ */ (function(WalletAccountType2) {
+  WalletAccountType2["CUSTOMER"] = "customer";
+  WalletAccountType2["VENDOR"] = "vendor";
+  WalletAccountType2["PLATFORM"] = "platform";
+  return WalletAccountType2;
+})({});
+
+// src/hooks/order.ts
+function isWalletOnlyPayment(paymentMethod) {
+  return String(paymentMethod ?? "").trim().toLowerCase() === "wallet";
+}
+__name(isWalletOnlyPayment, "isWalletOnlyPayment");
+function createOrderHooks(runtime) {
+  const { client, platformOwnerId, flags } = runtime;
+  return {
+    async onOrderPaid(ctx) {
+      if (!flags.enabled || !flags.ledgerWrites) {
+        return;
+      }
+      const txCtx = {
+        nativeTx: ctx.nativeTx
+      };
+      const platform = await client.getOrCreateAccount(WalletAccountType.PLATFORM, platformOwnerId, ctx.currency, txCtx);
+      const orderTotalPaise = toMinorUnit(ctx.orderTotalRupees);
+      const shouldDebitCustomer = isWalletOnlyPayment(ctx.paymentMethod) && ctx.customerId && !ctx.skipCustomerDebit;
+      if (shouldDebitCustomer) {
+        const debitRupees = ctx.walletAmountRupees ?? ctx.orderTotalRupees;
+        const customer = await client.getOrCreateAccount(WalletAccountType.CUSTOMER, ctx.customerId, ctx.currency, txCtx);
+        await client.debit({
+          accountId: customer.id,
+          amount: toMinorUnit(debitRupees),
+          idempotencyKey: `wallet:payment:${ctx.paymentNumber}`,
+          reference: {
+            referenceType: "order",
+            referenceId: String(ctx.orderId)
+          }
+        }, txCtx);
+      }
+      await client.credit({
+        accountId: platform.id,
+        amount: orderTotalPaise,
+        idempotencyKey: `payment:${ctx.paymentNumber}`,
+        reference: {
+          referenceType: "order",
+          referenceId: String(ctx.orderId)
+        }
+      }, txCtx);
+      for (const line of ctx.lines) {
+        const vendorNetRupees = line.commissionBaseRupees - line.commissionRupees;
+        if (vendorNetRupees <= 0) {
+          continue;
+        }
+        const vendor = await client.getOrCreateAccount(WalletAccountType.VENDOR, line.vendorId, ctx.currency, txCtx);
+        await client.hold({
+          sourceAccountId: platform.id,
+          targetAccountId: vendor.id,
+          amount: toMinorUnit(vendorNetRupees),
+          idempotencyKey: `order:${ctx.orderId}:hold:vendorOrder:${line.vendorOrderId}`,
+          reference: {
+            referenceType: "vendor_order",
+            referenceId: String(line.vendorOrderId)
+          }
+        }, txCtx);
+      }
+    },
+    async onLineDelivered(ctx) {
+      if (!flags.enabled || !flags.ledgerWrites) {
+        return;
+      }
+      await client.release({
+        reference: {
+          referenceType: "vendor_order",
+          referenceId: String(ctx.vendorOrderId)
+        },
+        idempotencyKey: `vendorOrder:${ctx.vendorOrderId}:release`
+      }, ctx.nativeTx != null ? {
+        nativeTx: ctx.nativeTx
+      } : void 0);
+    }
+  };
+}
+__name(createOrderHooks, "createOrderHooks");
+
+// src/hooks/refund.ts
+function isWalletPayment(paymentMethod) {
+  return String(paymentMethod ?? "").trim().toLowerCase() === "wallet";
+}
+__name(isWalletPayment, "isWalletPayment");
+function walletCreditRupees(ctx) {
+  if (ctx.walletRefundRupees != null && ctx.walletRefundRupees > 0) {
+    return ctx.walletRefundRupees;
+  }
+  return isWalletPayment(ctx.paymentMethod) ? ctx.lineTotalRupees : 0;
+}
+__name(walletCreditRupees, "walletCreditRupees");
+function idempotencyPrefix(ctx) {
+  const scope = ctx.idempotencyScope ?? String(ctx.orderProductId);
+  return ctx.refundReason === "return" ? `return:${scope}` : `refund:${ctx.orderProductId}`;
+}
+__name(idempotencyPrefix, "idempotencyPrefix");
+function createRefundHooks(runtime) {
+  const { client, platformOwnerId, flags } = runtime;
+  return {
+    async onRefund(ctx) {
+      if (!flags.enabled || !flags.ledgerWrites) {
+        await ctx.processExternalRefund();
+        return;
+      }
+      const keyPrefix = idempotencyPrefix(ctx);
+      if (!ctx.skipEscrow) {
+        await client.cancelHold({
+          reference: {
+            referenceType: "vendor_order",
+            referenceId: String(ctx.vendorOrderId)
+          },
+          idempotencyKey: `${keyPrefix}:cancel_hold`
+        });
+      }
+      const refundPaise = toMinorUnit(ctx.lineTotalRupees);
+      if (refundPaise > 0) {
+        const platform = await client.getOrCreateAccount(WalletAccountType.PLATFORM, platformOwnerId, ctx.currency);
+        const balance = await client.getBalance(platform.id);
+        if (balance.available >= refundPaise) {
+          await client.debit({
+            accountId: platform.id,
+            amount: refundPaise,
+            idempotencyKey: `${keyPrefix}:platform_debit`,
+            reference: {
+              referenceType: "order_product",
+              referenceId: String(ctx.orderProductId)
+            }
+          });
+        }
+        const creditRupees = walletCreditRupees(ctx);
+        if (creditRupees > 0 && ctx.customerId) {
+          const customer = await client.getOrCreateAccount(WalletAccountType.CUSTOMER, ctx.customerId, ctx.currency);
+          await client.credit({
+            accountId: customer.id,
+            amount: toMinorUnit(creditRupees),
+            idempotencyKey: `${keyPrefix}:customer_credit`,
+            reference: {
+              referenceType: "order",
+              referenceId: String(ctx.orderId ?? ctx.orderProductId)
+            }
+          });
+        }
+      }
+      await ctx.processExternalRefund();
+    }
+  };
+}
+__name(createRefundHooks, "createRefundHooks");
+
+// src/hooks/settlement.ts
+function createSettlementHooks(runtime) {
+  const { client, flags } = runtime;
+  return {
+    async onSettlementDebit(ctx) {
+      if (!flags.enabled || !flags.settlementDebit) {
+        return;
+      }
+      const txCtx = {
+        nativeTx: ctx.nativeTx
+      };
+      const amountPaise = toMinorUnit(ctx.amountRupees);
+      const vendorAccount = await client.getOrCreateAccount(WalletAccountType.VENDOR, ctx.vendorId, ctx.currency, txCtx);
+      const balance = await client.getBalance(vendorAccount.id, txCtx);
+      if (balance.available < amountPaise) {
+        throw new Error(`Insufficient vendor wallet balance for settlement (vendor ${ctx.vendorId})`);
+      }
+      await client.debit({
+        accountId: vendorAccount.id,
+        amount: amountPaise,
+        idempotencyKey: `settlement:${ctx.settlementId}:debit:${ctx.vendorId}`,
+        reference: {
+          referenceType: "settlement",
+          referenceId: String(ctx.settlementId)
+        }
+      }, txCtx);
+    }
+  };
+}
+__name(createSettlementHooks, "createSettlementHooks");
+function resolveWalletConnection() {
+  {
+    throw new Error("Wallet database connection is not registered. Pass host TypeORM Connection as dataSource.");
+  }
+}
+__name(resolveWalletConnection, "resolveWalletConnection");
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+function nowTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace("T", " ");
+}
+__name(nowTimestamp, "nowTimestamp");
+var _WalletAccountEntity = class _WalletAccountEntity {
+  constructor() {
+    __publicField(this, "id");
+    __publicField(this, "ownerType");
+    __publicField(this, "ownerId");
+    __publicField(this, "currency");
+    __publicField(this, "availableBalance");
+    __publicField(this, "heldBalance");
+    __publicField(this, "createdBy");
+    __publicField(this, "createdDate");
+    __publicField(this, "modifiedBy");
+    __publicField(this, "modifiedDate");
+  }
+  setCreated() {
+    this.createdDate = nowTimestamp();
+    this.modifiedDate = nowTimestamp();
+  }
+  setModified() {
+    this.modifiedDate = nowTimestamp();
+  }
+};
+__name(_WalletAccountEntity, "WalletAccountEntity");
+var WalletAccountEntity = _WalletAccountEntity;
+_ts_decorate([
+  typeorm.PrimaryGeneratedColumn({
+    name: "id"
+  }),
+  _ts_metadata("design:type", Number)
+], WalletAccountEntity.prototype, "id", void 0);
+_ts_decorate([
+  typeorm.Column({
+    name: "owner_type",
+    length: 32
+  }),
+  _ts_metadata("design:type", String)
+], WalletAccountEntity.prototype, "ownerType", void 0);
+_ts_decorate([
+  typeorm.Column({
+    name: "owner_id"
+  }),
+  _ts_metadata("design:type", Number)
+], WalletAccountEntity.prototype, "ownerId", void 0);
+_ts_decorate([
+  typeorm.Column({
+    name: "currency",
+    length: 8,
+    default: "INR"
+  }),
+  _ts_metadata("design:type", String)
+], WalletAccountEntity.prototype, "currency", void 0);
+_ts_decorate([
+  typeorm.Column({
+    name: "available_balance",
+    type: "bigint",
+    default: 0
+  }),
+  _ts_metadata("design:type", String)
+], WalletAccountEntity.prototype, "availableBalance", void 0);
+_ts_decorate([
+  typeorm.Column({
+    name: "held_balance",
+    type: "bigint",
+    default: 0
+  }),
+  _ts_metadata("design:type", String)
+], WalletAccountEntity.prototype, "heldBalance", void 0);
+_ts_decorate([
+  typeorm.Column({
+    name: "created_by",
+    nullable: true
+  }),
+  _ts_metadata("design:type", Number)
+], WalletAccountEntity.prototype, "createdBy", void 0);
+_ts_decorate([
+  typeorm.Column({
+    name: "created_date",
+    nullable: true
+  }),
+  _ts_metadata("design:type", String)
+], WalletAccountEntity.prototype, "createdDate", void 0);
+_ts_decorate([
+  typeorm.Column({
+    name: "modified_by",
+    nullable: true
+  }),
+  _ts_metadata("design:type", Number)
+], WalletAccountEntity.prototype, "modifiedBy", void 0);
+_ts_decorate([
+  typeorm.Column({
+    name: "modified_date",
+    nullable: true
+  }),
+  _ts_metadata("design:type", String)
+], WalletAccountEntity.prototype, "modifiedDate", void 0);
+_ts_decorate([
+  typeorm.BeforeInsert(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", []),
+  _ts_metadata("design:returntype", void 0)
+], WalletAccountEntity.prototype, "setCreated", null);
+_ts_decorate([
+  typeorm.BeforeUpdate(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", []),
+  _ts_metadata("design:returntype", void 0)
+], WalletAccountEntity.prototype, "setModified", null);
+WalletAccountEntity = _ts_decorate([
+  typeorm.Entity("wallet_account")
+], WalletAccountEntity);
+var _WalletLedgerEntryEntity = class _WalletLedgerEntryEntity {
+  constructor() {
+    __publicField(this, "id");
+    __publicField(this, "accountId");
+    __publicField(this, "entryType");
+    __publicField(this, "amount");
+    __publicField(this, "balanceAfterAvailable");
+    __publicField(this, "balanceAfterHeld");
+    __publicField(this, "idempotencyKey");
+    __publicField(this, "referenceType");
+    __publicField(this, "referenceId");
+    __publicField(this, "metadata");
+    __publicField(this, "createdBy");
+    __publicField(this, "createdDate");
+    __publicField(this, "modifiedBy");
+    __publicField(this, "modifiedDate");
+  }
+  setCreated() {
+    this.createdDate = nowTimestamp();
+    this.modifiedDate = nowTimestamp();
+  }
+};
+__name(_WalletLedgerEntryEntity, "WalletLedgerEntryEntity");
+var WalletLedgerEntryEntity = _WalletLedgerEntryEntity;
+_ts_decorate([
+  typeorm.PrimaryGeneratedColumn({
+    name: "id"
+  }),
+  _ts_metadata("design:type", Number)
+], WalletLedgerEntryEntity.prototype, "id", void 0);
+_ts_decorate([
+  typeorm.Column({
+    name: "account_id"
+  }),
+  _ts_metadata("design:type", Number)
+], WalletLedgerEntryEntity.prototype, "accountId", void 0);
+_ts_decorate([
+  typeorm.Column({
+    name: "entry_type",
+    length: 32
+  }),
+  _ts_metadata("design:type", String)
+], WalletLedgerEntryEntity.prototype, "entryType", void 0);
+_ts_decorate([
+  typeorm.Column({
+    name: "amount",
+    type: "bigint"
+  }),
+  _ts_metadata("design:type", String)
+], WalletLedgerEntryEntity.prototype, "amount", void 0);
+_ts_decorate([
+  typeorm.Column({
+    name: "balance_after_available",
+    type: "bigint"
+  }),
+  _ts_metadata("design:type", String)
+], WalletLedgerEntryEntity.prototype, "balanceAfterAvailable", void 0);
+_ts_decorate([
+  typeorm.Column({
+    name: "balance_after_held",
+    type: "bigint"
+  }),
+  _ts_metadata("design:type", String)
+], WalletLedgerEntryEntity.prototype, "balanceAfterHeld", void 0);
+_ts_decorate([
+  typeorm.Column({
+    name: "idempotency_key",
+    length: 255,
+    unique: true
+  }),
+  _ts_metadata("design:type", String)
+], WalletLedgerEntryEntity.prototype, "idempotencyKey", void 0);
+_ts_decorate([
+  typeorm.Column({
+    name: "reference_type",
+    length: 64,
+    nullable: true
+  }),
+  _ts_metadata("design:type", String)
+], WalletLedgerEntryEntity.prototype, "referenceType", void 0);
+_ts_decorate([
+  typeorm.Column({
+    name: "reference_id",
+    length: 128,
+    nullable: true
+  }),
+  _ts_metadata("design:type", String)
+], WalletLedgerEntryEntity.prototype, "referenceId", void 0);
+_ts_decorate([
+  typeorm.Column({
+    name: "metadata",
+    type: "json",
+    nullable: true
+  }),
+  _ts_metadata("design:type", typeof Record === "undefined" ? Object : Record)
+], WalletLedgerEntryEntity.prototype, "metadata", void 0);
+_ts_decorate([
+  typeorm.Column({
+    name: "created_by",
+    nullable: true
+  }),
+  _ts_metadata("design:type", Number)
+], WalletLedgerEntryEntity.prototype, "createdBy", void 0);
+_ts_decorate([
+  typeorm.Column({
+    name: "created_date",
+    nullable: true
+  }),
+  _ts_metadata("design:type", String)
+], WalletLedgerEntryEntity.prototype, "createdDate", void 0);
+_ts_decorate([
+  typeorm.Column({
+    name: "modified_by",
+    nullable: true
+  }),
+  _ts_metadata("design:type", Number)
+], WalletLedgerEntryEntity.prototype, "modifiedBy", void 0);
+_ts_decorate([
+  typeorm.Column({
+    name: "modified_date",
+    nullable: true
+  }),
+  _ts_metadata("design:type", String)
+], WalletLedgerEntryEntity.prototype, "modifiedDate", void 0);
+_ts_decorate([
+  typeorm.BeforeInsert(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", []),
+  _ts_metadata("design:returntype", void 0)
+], WalletLedgerEntryEntity.prototype, "setCreated", null);
+WalletLedgerEntryEntity = _ts_decorate([
+  typeorm.Entity("wallet_ledger_entry")
+], WalletLedgerEntryEntity);
+var _WalletHoldEntity = class _WalletHoldEntity {
+  constructor() {
+    __publicField(this, "id");
+    __publicField(this, "sourceAccountId");
+    __publicField(this, "targetAccountId");
+    __publicField(this, "amount");
+    __publicField(this, "status");
+    __publicField(this, "referenceType");
+    __publicField(this, "referenceId");
+    __publicField(this, "idempotencyKey");
+    __publicField(this, "createdBy");
+    __publicField(this, "createdDate");
+    __publicField(this, "modifiedBy");
+    __publicField(this, "modifiedDate");
+  }
+  setCreated() {
+    this.createdDate = nowTimestamp();
+    this.modifiedDate = nowTimestamp();
+  }
+  setModified() {
+    this.modifiedDate = nowTimestamp();
+  }
+};
+__name(_WalletHoldEntity, "WalletHoldEntity");
+var WalletHoldEntity = _WalletHoldEntity;
+_ts_decorate([
+  typeorm.PrimaryGeneratedColumn({
+    name: "id"
+  }),
+  _ts_metadata("design:type", Number)
+], WalletHoldEntity.prototype, "id", void 0);
+_ts_decorate([
+  typeorm.Column({
+    name: "source_account_id"
+  }),
+  _ts_metadata("design:type", Number)
+], WalletHoldEntity.prototype, "sourceAccountId", void 0);
+_ts_decorate([
+  typeorm.Column({
+    name: "target_account_id"
+  }),
+  _ts_metadata("design:type", Number)
+], WalletHoldEntity.prototype, "targetAccountId", void 0);
+_ts_decorate([
+  typeorm.Column({
+    name: "amount",
+    type: "bigint"
+  }),
+  _ts_metadata("design:type", String)
+], WalletHoldEntity.prototype, "amount", void 0);
+_ts_decorate([
+  typeorm.Column({
+    name: "status",
+    length: 16,
+    default: "active"
+  }),
+  _ts_metadata("design:type", String)
+], WalletHoldEntity.prototype, "status", void 0);
+_ts_decorate([
+  typeorm.Column({
+    name: "reference_type",
+    length: 64
+  }),
+  _ts_metadata("design:type", String)
+], WalletHoldEntity.prototype, "referenceType", void 0);
+_ts_decorate([
+  typeorm.Column({
+    name: "reference_id",
+    length: 128
+  }),
+  _ts_metadata("design:type", String)
+], WalletHoldEntity.prototype, "referenceId", void 0);
+_ts_decorate([
+  typeorm.Column({
+    name: "idempotency_key",
+    length: 255
+  }),
+  _ts_metadata("design:type", String)
+], WalletHoldEntity.prototype, "idempotencyKey", void 0);
+_ts_decorate([
+  typeorm.Column({
+    name: "created_by",
+    nullable: true
+  }),
+  _ts_metadata("design:type", Number)
+], WalletHoldEntity.prototype, "createdBy", void 0);
+_ts_decorate([
+  typeorm.Column({
+    name: "created_date",
+    nullable: true
+  }),
+  _ts_metadata("design:type", String)
+], WalletHoldEntity.prototype, "createdDate", void 0);
+_ts_decorate([
+  typeorm.Column({
+    name: "modified_by",
+    nullable: true
+  }),
+  _ts_metadata("design:type", Number)
+], WalletHoldEntity.prototype, "modifiedBy", void 0);
+_ts_decorate([
+  typeorm.Column({
+    name: "modified_date",
+    nullable: true
+  }),
+  _ts_metadata("design:type", String)
+], WalletHoldEntity.prototype, "modifiedDate", void 0);
+_ts_decorate([
+  typeorm.BeforeInsert(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", []),
+  _ts_metadata("design:returntype", void 0)
+], WalletHoldEntity.prototype, "setCreated", null);
+_ts_decorate([
+  typeorm.BeforeUpdate(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", []),
+  _ts_metadata("design:returntype", void 0)
+], WalletHoldEntity.prototype, "setModified", null);
+WalletHoldEntity = _ts_decorate([
+  typeorm.Entity("wallet_hold")
+], WalletHoldEntity);
+
+// src/hooks/reconciliation.ts
+async function runWalletReconciliation() {
+  const parityDeltas = await findVendorPaymentHoldParityDeltas();
+  const cacheMismatches = await findCacheLedgerMismatches();
+  return {
+    parityDeltas,
+    cacheMismatches
+  };
+}
+__name(runWalletReconciliation, "runWalletReconciliation");
+async function findVendorPaymentHoldParityDeltas() {
+  const rows = await resolveWalletConnection().query(`
+    SELECT
+      vo.order_id AS orderId,
+      vp.vendor_order_id AS vendorOrderId,
+      vp.amount AS vendorPaymentAmount,
+      wh.amount AS holdAmount,
+      wh.status AS holdStatus
+    FROM vendor_payment vp
+    INNER JOIN vendor_orders vo ON vo.vendor_order_id = vp.vendor_order_id
+    LEFT JOIN wallet_hold wh
+      ON wh.reference_type = 'vendor_order'
+      AND wh.reference_id = CAST(vp.vendor_order_id AS CHAR)
+    WHERE vp.vendor_order_id IS NOT NULL
+  `);
+  const deltas = [];
+  for (const row of rows) {
+    const vendorPaymentRupees = Number(row.vendorPaymentAmount) || 0;
+    const holdPaise = row.holdAmount != null ? Number(row.holdAmount) : 0;
+    const holdRupees = fromMinorUnit(holdPaise);
+    const delta = Math.abs(vendorPaymentRupees - holdRupees);
+    if (delta > 0.01 && row.holdStatus === "active") {
+      deltas.push({
+        orderId: Number(row.orderId),
+        vendorOrderId: Number(row.vendorOrderId),
+        vendorPaymentRupees,
+        holdPaise,
+        deltaRupees: delta
+      });
+    }
+  }
+  return deltas;
+}
+__name(findVendorPaymentHoldParityDeltas, "findVendorPaymentHoldParityDeltas");
+async function findCacheLedgerMismatches() {
+  const connection = resolveWalletConnection();
+  const accounts = await connection.getRepository(WalletAccountEntity).find();
+  const mismatches = [];
+  for (const account of accounts) {
+    const lastEntry = await connection.getRepository(WalletLedgerEntryEntity).findOne({
+      where: {
+        accountId: account.id
+      },
+      order: {
+        id: "DESC"
+      }
+    });
+    if (!lastEntry) {
+      continue;
+    }
+    const cachedAvailable = Number(account.availableBalance);
+    const cachedHeld = Number(account.heldBalance);
+    const ledgerAvailable = Number(lastEntry.balanceAfterAvailable);
+    const ledgerHeld = Number(lastEntry.balanceAfterHeld);
+    if (cachedAvailable !== ledgerAvailable || cachedHeld !== ledgerHeld) {
+      mismatches.push({
+        accountId: account.id,
+        cachedAvailable,
+        cachedHeld,
+        ledgerAvailable,
+        ledgerHeld
+      });
+    }
+  }
+  return mismatches;
+}
+__name(findCacheLedgerMismatches, "findCacheLedgerMismatches");
+
+// src/hooks/index.ts
+function createLifecycleHooks(runtime) {
+  return {
+    ...createOrderHooks(runtime),
+    ...createSettlementHooks(runtime),
+    ...createRefundHooks(runtime)
+  };
+}
+__name(createLifecycleHooks, "createLifecycleHooks");
+
+exports.createLifecycleHooks = createLifecycleHooks;
+exports.runWalletReconciliation = runWalletReconciliation;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map