multivendor-wallet 0.0.1

package/dist/index.js

@@ -0,0 +1,2173 @@
+import { PrimaryGeneratedColumn, Column, BeforeInsert, BeforeUpdate, Entity } from 'typeorm';
+import 'reflect-metadata';
+import { Get, Authorized, QueryParam, Res, Param, Post, Body, Req, JsonController } from 'routing-controllers';
+import { IsString, IsNotEmpty, IsInt, Min, IsNumber, IsOptional } from 'class-validator';
+import { Router } from 'express';
+
+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 __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/errors.ts
+var _WalletError = class _WalletError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WalletError";
+  }
+};
+__name(_WalletError, "WalletError");
+var WalletError = _WalletError;
+var _WalletConfigError = class _WalletConfigError extends WalletError {
+  constructor(message) {
+    super(message);
+    this.name = "WalletConfigError";
+  }
+};
+__name(_WalletConfigError, "WalletConfigError");
+var WalletConfigError = _WalletConfigError;
+var _InsufficientBalanceError = class _InsufficientBalanceError extends WalletError {
+  constructor(message = "Insufficient available balance") {
+    super(message);
+    this.name = "InsufficientBalanceError";
+  }
+};
+__name(_InsufficientBalanceError, "InsufficientBalanceError");
+var InsufficientBalanceError = _InsufficientBalanceError;
+var _HoldNotFoundError = class _HoldNotFoundError extends WalletError {
+  constructor(message = "Active hold not found for reference") {
+    super(message);
+    this.name = "HoldNotFoundError";
+  }
+};
+__name(_HoldNotFoundError, "HoldNotFoundError");
+var HoldNotFoundError = _HoldNotFoundError;
+var _DuplicateOperationError = class _DuplicateOperationError extends WalletError {
+  constructor(message, existingEntry) {
+    super(message);
+    __publicField(this, "existingEntry");
+    this.name = "DuplicateOperationError";
+    this.existingEntry = existingEntry;
+  }
+};
+__name(_DuplicateOperationError, "DuplicateOperationError");
+var DuplicateOperationError = _DuplicateOperationError;
+var _InvalidAmountError = class _InvalidAmountError extends WalletError {
+  constructor(message = "Amount must be a positive integer in minor units") {
+    super(message);
+    this.name = "InvalidAmountError";
+  }
+};
+__name(_InvalidAmountError, "InvalidAmountError");
+var InvalidAmountError = _InvalidAmountError;
+
+// src/types.ts
+var WalletAccountType = /* @__PURE__ */ (function(WalletAccountType2) {
+  WalletAccountType2["CUSTOMER"] = "customer";
+  WalletAccountType2["VENDOR"] = "vendor";
+  WalletAccountType2["PLATFORM"] = "platform";
+  return WalletAccountType2;
+})({});
+var LedgerEntryType = /* @__PURE__ */ (function(LedgerEntryType2) {
+  LedgerEntryType2["CREDIT"] = "credit";
+  LedgerEntryType2["DEBIT"] = "debit";
+  LedgerEntryType2["HOLD"] = "hold";
+  LedgerEntryType2["RELEASE"] = "release";
+  LedgerEntryType2["CANCEL_HOLD"] = "cancel_hold";
+  LedgerEntryType2["TRANSFER"] = "transfer";
+  return LedgerEntryType2;
+})({});
+var HoldStatus = /* @__PURE__ */ (function(HoldStatus2) {
+  HoldStatus2["ACTIVE"] = "active";
+  HoldStatus2["RELEASED"] = "released";
+  HoldStatus2["CANCELLED"] = "cancelled";
+  return HoldStatus2;
+})({});
+
+// src/client.ts
+var _WalletLedgerClient = class _WalletLedgerClient {
+  constructor(store, config = {}) {
+    __publicField(this, "store");
+    __publicField(this, "config");
+    this.store = store;
+    this.config = config;
+  }
+  async getOrCreateAccount(type, ownerId, currency, ctx) {
+    return this.store.runInTransaction((tx) => tx.getOrCreateAccount(type, ownerId, currency ?? this.config.defaultCurrency ?? "INR"), ctx);
+  }
+  async getBalance(accountId, ctx) {
+    return this.store.runInTransaction(async (tx) => {
+      const account = await tx.getAccountById(accountId);
+      if (!account) {
+        throw new Error(`Wallet account ${accountId} not found`);
+      }
+      return this.toBalance(account);
+    }, ctx);
+  }
+  async credit(params, ctx) {
+    this.assertPositiveAmount(params.amount);
+    return this.store.runInTransaction((tx) => this.creditInTx(tx, params), ctx);
+  }
+  async debit(params, ctx) {
+    this.assertPositiveAmount(params.amount);
+    return this.store.runInTransaction((tx) => this.debitInTx(tx, params), ctx);
+  }
+  async hold(params, ctx) {
+    this.assertPositiveAmount(params.amount);
+    return this.store.runInTransaction((tx) => this.holdInTx(tx, params), ctx);
+  }
+  async release(params, ctx) {
+    return this.store.runInTransaction((tx) => this.releaseInTx(tx, params), ctx);
+  }
+  async cancelHold(params, ctx) {
+    return this.store.runInTransaction((tx) => this.cancelHoldInTx(tx, params), ctx);
+  }
+  async transfer(params, ctx) {
+    this.assertPositiveAmount(params.amount);
+    return this.store.runInTransaction(async (tx) => {
+      const debit = await this.debitInTx(tx, {
+        accountId: params.fromAccountId,
+        amount: params.amount,
+        idempotencyKey: `${params.idempotencyKey}:debit`,
+        reference: params.reference,
+        metadata: params.metadata
+      });
+      const credit = await this.creditInTx(tx, {
+        accountId: params.toAccountId,
+        amount: params.amount,
+        idempotencyKey: `${params.idempotencyKey}:credit`,
+        reference: params.reference,
+        metadata: params.metadata
+      });
+      return {
+        debit,
+        credit
+      };
+    }, ctx);
+  }
+  async getTransactions(params, ctx) {
+    const limit = params.limit ?? 50;
+    const offset = params.offset ?? 0;
+    return this.store.runInTransaction((tx) => tx.listLedgerEntries(params.accountId, limit, offset), ctx);
+  }
+  async creditInTx(tx, params) {
+    const existing = await tx.findLedgerByIdempotencyKey(params.idempotencyKey);
+    if (existing) {
+      const account = await tx.getAccountById(existing.accountId);
+      if (!account) {
+        throw new Error(`Wallet account ${existing.accountId} not found`);
+      }
+      return {
+        entry: existing,
+        account
+      };
+    }
+    await tx.lockAccount(params.accountId);
+    const updated = await tx.updateBalances(params.accountId, {
+      availableDelta: params.amount
+    });
+    const entry = await tx.appendLedgerEntry({
+      accountId: params.accountId,
+      entryType: LedgerEntryType.CREDIT,
+      amount: params.amount,
+      balanceAfterAvailable: updated.availableBalance,
+      balanceAfterHeld: updated.heldBalance,
+      idempotencyKey: params.idempotencyKey,
+      referenceType: params.reference?.referenceType,
+      referenceId: params.reference?.referenceId,
+      metadata: params.metadata
+    });
+    return {
+      entry,
+      account: updated
+    };
+  }
+  async debitInTx(tx, params) {
+    const existing = await tx.findLedgerByIdempotencyKey(params.idempotencyKey);
+    if (existing) {
+      const account = await tx.getAccountById(existing.accountId);
+      if (!account) {
+        throw new Error(`Wallet account ${existing.accountId} not found`);
+      }
+      return {
+        entry: existing,
+        account
+      };
+    }
+    const locked = await tx.lockAccount(params.accountId);
+    if (locked.availableBalance < params.amount) {
+      throw new InsufficientBalanceError();
+    }
+    const updated = await tx.updateBalances(params.accountId, {
+      availableDelta: -params.amount
+    });
+    const entry = await tx.appendLedgerEntry({
+      accountId: params.accountId,
+      entryType: LedgerEntryType.DEBIT,
+      amount: params.amount,
+      balanceAfterAvailable: updated.availableBalance,
+      balanceAfterHeld: updated.heldBalance,
+      idempotencyKey: params.idempotencyKey,
+      referenceType: params.reference?.referenceType,
+      referenceId: params.reference?.referenceId,
+      metadata: params.metadata
+    });
+    return {
+      entry,
+      account: updated
+    };
+  }
+  async holdInTx(tx, params) {
+    const existing = await tx.findLedgerByIdempotencyKey(params.idempotencyKey);
+    if (existing) {
+      const account = await tx.getAccountById(existing.accountId);
+      const hold2 = await tx.findHoldByReference(params.reference);
+      if (!account) {
+        throw new Error(`Wallet account ${existing.accountId} not found`);
+      }
+      return {
+        entry: existing,
+        account,
+        hold: hold2 ?? void 0
+      };
+    }
+    const existingHold = await tx.findHoldByReference(params.reference);
+    if (existingHold?.status === HoldStatus.ACTIVE) {
+      throw new DuplicateOperationError("Hold already exists for reference", existingHold);
+    }
+    const source = await tx.lockAccount(params.sourceAccountId);
+    if (source.availableBalance < params.amount) {
+      throw new InsufficientBalanceError("Insufficient platform balance for hold");
+    }
+    await tx.updateBalances(params.sourceAccountId, {
+      availableDelta: -params.amount
+    });
+    const targetUpdated = await tx.updateBalances(params.targetAccountId, {
+      heldDelta: params.amount
+    });
+    const hold = await tx.upsertHold({
+      sourceAccountId: params.sourceAccountId,
+      targetAccountId: params.targetAccountId,
+      amount: params.amount,
+      status: HoldStatus.ACTIVE,
+      referenceType: params.reference.referenceType,
+      referenceId: params.reference.referenceId,
+      idempotencyKey: params.idempotencyKey
+    });
+    const sourceAfterHold = await tx.getAccountById(params.sourceAccountId);
+    if (!sourceAfterHold) {
+      throw new Error(`Wallet account ${params.sourceAccountId} not found`);
+    }
+    await tx.appendLedgerEntry({
+      accountId: params.sourceAccountId,
+      entryType: LedgerEntryType.HOLD,
+      amount: params.amount,
+      balanceAfterAvailable: sourceAfterHold.availableBalance,
+      balanceAfterHeld: sourceAfterHold.heldBalance,
+      idempotencyKey: `${params.idempotencyKey}:source`,
+      referenceType: params.reference.referenceType,
+      referenceId: params.reference.referenceId,
+      metadata: params.metadata
+    });
+    const entry = await tx.appendLedgerEntry({
+      accountId: params.targetAccountId,
+      entryType: LedgerEntryType.HOLD,
+      amount: params.amount,
+      balanceAfterAvailable: targetUpdated.availableBalance,
+      balanceAfterHeld: targetUpdated.heldBalance,
+      idempotencyKey: params.idempotencyKey,
+      referenceType: params.reference.referenceType,
+      referenceId: params.reference.referenceId,
+      metadata: params.metadata
+    });
+    return {
+      entry,
+      account: targetUpdated,
+      hold
+    };
+  }
+  async releaseInTx(tx, params) {
+    const existing = await tx.findLedgerByIdempotencyKey(params.idempotencyKey);
+    if (existing) {
+      const account = await tx.getAccountById(existing.accountId);
+      const hold2 = await tx.findHoldByReference(params.reference);
+      if (!account) {
+        throw new Error(`Wallet account ${existing.accountId} not found`);
+      }
+      return {
+        entry: existing,
+        account,
+        hold: hold2 ?? void 0
+      };
+    }
+    const hold = await this.requireActiveHold(tx, params.reference);
+    await tx.lockAccount(hold.targetAccountId);
+    const targetUpdated = await tx.updateBalances(hold.targetAccountId, {
+      heldDelta: -hold.amount,
+      availableDelta: hold.amount
+    });
+    const releasedHold = await tx.upsertHold({
+      ...hold,
+      status: HoldStatus.RELEASED
+    });
+    const entry = await tx.appendLedgerEntry({
+      accountId: hold.targetAccountId,
+      entryType: LedgerEntryType.RELEASE,
+      amount: hold.amount,
+      balanceAfterAvailable: targetUpdated.availableBalance,
+      balanceAfterHeld: targetUpdated.heldBalance,
+      idempotencyKey: params.idempotencyKey,
+      referenceType: params.reference.referenceType,
+      referenceId: params.reference.referenceId,
+      metadata: params.metadata
+    });
+    return {
+      entry,
+      account: targetUpdated,
+      hold: releasedHold
+    };
+  }
+  async cancelHoldInTx(tx, params) {
+    const existing = await tx.findLedgerByIdempotencyKey(params.idempotencyKey);
+    if (existing) {
+      const account = await tx.getAccountById(existing.accountId);
+      const hold2 = await tx.findHoldByReference(params.reference);
+      if (!account) {
+        throw new Error(`Wallet account ${existing.accountId} not found`);
+      }
+      return {
+        entry: existing,
+        account,
+        hold: hold2 ?? void 0
+      };
+    }
+    const hold = await this.requireActiveHold(tx, params.reference);
+    await tx.lockAccount(hold.sourceAccountId);
+    await tx.lockAccount(hold.targetAccountId);
+    const sourceUpdated = await tx.updateBalances(hold.sourceAccountId, {
+      availableDelta: hold.amount
+    });
+    const targetUpdated = await tx.updateBalances(hold.targetAccountId, {
+      heldDelta: -hold.amount
+    });
+    const cancelledHold = await tx.upsertHold({
+      ...hold,
+      status: HoldStatus.CANCELLED
+    });
+    await tx.appendLedgerEntry({
+      accountId: hold.sourceAccountId,
+      entryType: LedgerEntryType.CANCEL_HOLD,
+      amount: hold.amount,
+      balanceAfterAvailable: sourceUpdated.availableBalance,
+      balanceAfterHeld: sourceUpdated.heldBalance,
+      idempotencyKey: `${params.idempotencyKey}:source`,
+      referenceType: params.reference.referenceType,
+      referenceId: params.reference.referenceId,
+      metadata: params.metadata
+    });
+    const entry = await tx.appendLedgerEntry({
+      accountId: hold.targetAccountId,
+      entryType: LedgerEntryType.CANCEL_HOLD,
+      amount: hold.amount,
+      balanceAfterAvailable: targetUpdated.availableBalance,
+      balanceAfterHeld: targetUpdated.heldBalance,
+      idempotencyKey: params.idempotencyKey,
+      referenceType: params.reference.referenceType,
+      referenceId: params.reference.referenceId,
+      metadata: params.metadata
+    });
+    return {
+      entry,
+      account: targetUpdated,
+      hold: cancelledHold
+    };
+  }
+  toBalance(account) {
+    return {
+      available: account.availableBalance,
+      held: account.heldBalance,
+      total: account.availableBalance + account.heldBalance
+    };
+  }
+  assertPositiveAmount(amount) {
+    if (!Number.isInteger(amount) || amount <= 0) {
+      throw new InvalidAmountError();
+    }
+  }
+  async requireActiveHold(tx, reference) {
+    const hold = await tx.findHoldByReference(reference);
+    if (!hold || hold.status !== HoldStatus.ACTIVE) {
+      throw new HoldNotFoundError();
+    }
+    return hold;
+  }
+};
+__name(_WalletLedgerClient, "WalletLedgerClient");
+var WalletLedgerClient = _WalletLedgerClient;
+
+// src/currency.ts
+function toMinorUnit(amount) {
+  return Math.round(amount * 100);
+}
+__name(toMinorUnit, "toMinorUnit");
+function fromMinorUnit(amount) {
+  return amount / 100;
+}
+__name(fromMinorUnit, "fromMinorUnit");
+
+// 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");
+
+// src/plugin-instance.ts
+var activePlugin;
+var activeConnection;
+function bindWalletPlugin(plugin) {
+  activePlugin = plugin;
+}
+__name(bindWalletPlugin, "bindWalletPlugin");
+function bindWalletConnection(connection) {
+  activeConnection = connection;
+}
+__name(bindWalletConnection, "bindWalletConnection");
+function resolveWalletPlugin() {
+  if (!activePlugin) {
+    throw new Error("Wallet plugin is not registered. Call registerWalletPlugin() during app bootstrap.");
+  }
+  return activePlugin;
+}
+__name(resolveWalletPlugin, "resolveWalletPlugin");
+function resolveWalletConnection() {
+  if (!activeConnection?.manager) {
+    throw new Error("Wallet database connection is not registered. Pass host TypeORM Connection as dataSource.");
+  }
+  return activeConnection;
+}
+__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([
+  PrimaryGeneratedColumn({
+    name: "id"
+  }),
+  _ts_metadata("design:type", Number)
+], WalletAccountEntity.prototype, "id", void 0);
+_ts_decorate([
+  Column({
+    name: "owner_type",
+    length: 32
+  }),
+  _ts_metadata("design:type", String)
+], WalletAccountEntity.prototype, "ownerType", void 0);
+_ts_decorate([
+  Column({
+    name: "owner_id"
+  }),
+  _ts_metadata("design:type", Number)
+], WalletAccountEntity.prototype, "ownerId", void 0);
+_ts_decorate([
+  Column({
+    name: "currency",
+    length: 8,
+    default: "INR"
+  }),
+  _ts_metadata("design:type", String)
+], WalletAccountEntity.prototype, "currency", void 0);
+_ts_decorate([
+  Column({
+    name: "available_balance",
+    type: "bigint",
+    default: 0
+  }),
+  _ts_metadata("design:type", String)
+], WalletAccountEntity.prototype, "availableBalance", void 0);
+_ts_decorate([
+  Column({
+    name: "held_balance",
+    type: "bigint",
+    default: 0
+  }),
+  _ts_metadata("design:type", String)
+], WalletAccountEntity.prototype, "heldBalance", void 0);
+_ts_decorate([
+  Column({
+    name: "created_by",
+    nullable: true
+  }),
+  _ts_metadata("design:type", Number)
+], WalletAccountEntity.prototype, "createdBy", void 0);
+_ts_decorate([
+  Column({
+    name: "created_date",
+    nullable: true
+  }),
+  _ts_metadata("design:type", String)
+], WalletAccountEntity.prototype, "createdDate", void 0);
+_ts_decorate([
+  Column({
+    name: "modified_by",
+    nullable: true
+  }),
+  _ts_metadata("design:type", Number)
+], WalletAccountEntity.prototype, "modifiedBy", void 0);
+_ts_decorate([
+  Column({
+    name: "modified_date",
+    nullable: true
+  }),
+  _ts_metadata("design:type", String)
+], WalletAccountEntity.prototype, "modifiedDate", void 0);
+_ts_decorate([
+  BeforeInsert(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", []),
+  _ts_metadata("design:returntype", void 0)
+], WalletAccountEntity.prototype, "setCreated", null);
+_ts_decorate([
+  BeforeUpdate(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", []),
+  _ts_metadata("design:returntype", void 0)
+], WalletAccountEntity.prototype, "setModified", null);
+WalletAccountEntity = _ts_decorate([
+  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([
+  PrimaryGeneratedColumn({
+    name: "id"
+  }),
+  _ts_metadata("design:type", Number)
+], WalletLedgerEntryEntity.prototype, "id", void 0);
+_ts_decorate([
+  Column({
+    name: "account_id"
+  }),
+  _ts_metadata("design:type", Number)
+], WalletLedgerEntryEntity.prototype, "accountId", void 0);
+_ts_decorate([
+  Column({
+    name: "entry_type",
+    length: 32
+  }),
+  _ts_metadata("design:type", String)
+], WalletLedgerEntryEntity.prototype, "entryType", void 0);
+_ts_decorate([
+  Column({
+    name: "amount",
+    type: "bigint"
+  }),
+  _ts_metadata("design:type", String)
+], WalletLedgerEntryEntity.prototype, "amount", void 0);
+_ts_decorate([
+  Column({
+    name: "balance_after_available",
+    type: "bigint"
+  }),
+  _ts_metadata("design:type", String)
+], WalletLedgerEntryEntity.prototype, "balanceAfterAvailable", void 0);
+_ts_decorate([
+  Column({
+    name: "balance_after_held",
+    type: "bigint"
+  }),
+  _ts_metadata("design:type", String)
+], WalletLedgerEntryEntity.prototype, "balanceAfterHeld", void 0);
+_ts_decorate([
+  Column({
+    name: "idempotency_key",
+    length: 255,
+    unique: true
+  }),
+  _ts_metadata("design:type", String)
+], WalletLedgerEntryEntity.prototype, "idempotencyKey", void 0);
+_ts_decorate([
+  Column({
+    name: "reference_type",
+    length: 64,
+    nullable: true
+  }),
+  _ts_metadata("design:type", String)
+], WalletLedgerEntryEntity.prototype, "referenceType", void 0);
+_ts_decorate([
+  Column({
+    name: "reference_id",
+    length: 128,
+    nullable: true
+  }),
+  _ts_metadata("design:type", String)
+], WalletLedgerEntryEntity.prototype, "referenceId", void 0);
+_ts_decorate([
+  Column({
+    name: "metadata",
+    type: "json",
+    nullable: true
+  }),
+  _ts_metadata("design:type", typeof Record === "undefined" ? Object : Record)
+], WalletLedgerEntryEntity.prototype, "metadata", void 0);
+_ts_decorate([
+  Column({
+    name: "created_by",
+    nullable: true
+  }),
+  _ts_metadata("design:type", Number)
+], WalletLedgerEntryEntity.prototype, "createdBy", void 0);
+_ts_decorate([
+  Column({
+    name: "created_date",
+    nullable: true
+  }),
+  _ts_metadata("design:type", String)
+], WalletLedgerEntryEntity.prototype, "createdDate", void 0);
+_ts_decorate([
+  Column({
+    name: "modified_by",
+    nullable: true
+  }),
+  _ts_metadata("design:type", Number)
+], WalletLedgerEntryEntity.prototype, "modifiedBy", void 0);
+_ts_decorate([
+  Column({
+    name: "modified_date",
+    nullable: true
+  }),
+  _ts_metadata("design:type", String)
+], WalletLedgerEntryEntity.prototype, "modifiedDate", void 0);
+_ts_decorate([
+  BeforeInsert(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", []),
+  _ts_metadata("design:returntype", void 0)
+], WalletLedgerEntryEntity.prototype, "setCreated", null);
+WalletLedgerEntryEntity = _ts_decorate([
+  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([
+  PrimaryGeneratedColumn({
+    name: "id"
+  }),
+  _ts_metadata("design:type", Number)
+], WalletHoldEntity.prototype, "id", void 0);
+_ts_decorate([
+  Column({
+    name: "source_account_id"
+  }),
+  _ts_metadata("design:type", Number)
+], WalletHoldEntity.prototype, "sourceAccountId", void 0);
+_ts_decorate([
+  Column({
+    name: "target_account_id"
+  }),
+  _ts_metadata("design:type", Number)
+], WalletHoldEntity.prototype, "targetAccountId", void 0);
+_ts_decorate([
+  Column({
+    name: "amount",
+    type: "bigint"
+  }),
+  _ts_metadata("design:type", String)
+], WalletHoldEntity.prototype, "amount", void 0);
+_ts_decorate([
+  Column({
+    name: "status",
+    length: 16,
+    default: "active"
+  }),
+  _ts_metadata("design:type", String)
+], WalletHoldEntity.prototype, "status", void 0);
+_ts_decorate([
+  Column({
+    name: "reference_type",
+    length: 64
+  }),
+  _ts_metadata("design:type", String)
+], WalletHoldEntity.prototype, "referenceType", void 0);
+_ts_decorate([
+  Column({
+    name: "reference_id",
+    length: 128
+  }),
+  _ts_metadata("design:type", String)
+], WalletHoldEntity.prototype, "referenceId", void 0);
+_ts_decorate([
+  Column({
+    name: "idempotency_key",
+    length: 255
+  }),
+  _ts_metadata("design:type", String)
+], WalletHoldEntity.prototype, "idempotencyKey", void 0);
+_ts_decorate([
+  Column({
+    name: "created_by",
+    nullable: true
+  }),
+  _ts_metadata("design:type", Number)
+], WalletHoldEntity.prototype, "createdBy", void 0);
+_ts_decorate([
+  Column({
+    name: "created_date",
+    nullable: true
+  }),
+  _ts_metadata("design:type", String)
+], WalletHoldEntity.prototype, "createdDate", void 0);
+_ts_decorate([
+  Column({
+    name: "modified_by",
+    nullable: true
+  }),
+  _ts_metadata("design:type", Number)
+], WalletHoldEntity.prototype, "modifiedBy", void 0);
+_ts_decorate([
+  Column({
+    name: "modified_date",
+    nullable: true
+  }),
+  _ts_metadata("design:type", String)
+], WalletHoldEntity.prototype, "modifiedDate", void 0);
+_ts_decorate([
+  BeforeInsert(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", []),
+  _ts_metadata("design:returntype", void 0)
+], WalletHoldEntity.prototype, "setCreated", null);
+_ts_decorate([
+  BeforeUpdate(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", []),
+  _ts_metadata("design:returntype", void 0)
+], WalletHoldEntity.prototype, "setModified", null);
+WalletHoldEntity = _ts_decorate([
+  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");
+function _ts_decorate2(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_decorate2, "_ts_decorate");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var _a;
+var WalletCreditDebitRequest = (_a = class {
+  constructor() {
+    __publicField(this, "ownerType");
+    __publicField(this, "ownerId");
+    __publicField(this, "amount");
+    __publicField(this, "currency");
+    __publicField(this, "reason");
+  }
+}, __name(_a, "WalletCreditDebitRequest"), _a);
+_ts_decorate2([
+  IsString(),
+  IsNotEmpty(),
+  _ts_metadata2("design:type", typeof WalletAccountType === "undefined" ? Object : WalletAccountType)
+], WalletCreditDebitRequest.prototype, "ownerType", void 0);
+_ts_decorate2([
+  IsInt(),
+  Min(0),
+  _ts_metadata2("design:type", Number)
+], WalletCreditDebitRequest.prototype, "ownerId", void 0);
+_ts_decorate2([
+  IsNumber(),
+  Min(0.01),
+  _ts_metadata2("design:type", Number)
+], WalletCreditDebitRequest.prototype, "amount", void 0);
+_ts_decorate2([
+  IsOptional(),
+  IsString(),
+  _ts_metadata2("design:type", String)
+], WalletCreditDebitRequest.prototype, "currency", void 0);
+_ts_decorate2([
+  IsOptional(),
+  IsString(),
+  _ts_metadata2("design:type", String)
+], WalletCreditDebitRequest.prototype, "reason", void 0);
+var _AdminWalletController = class _AdminWalletController {
+  get plugin() {
+    return resolveWalletPlugin();
+  }
+  assertEnabled(response) {
+    if (!this.plugin.isEnabled()) {
+      response.status(404).send({
+        status: 0,
+        message: "Wallet feature is disabled"
+      });
+      return false;
+    }
+    return true;
+  }
+  async listAccounts(limit = 50, offset = 0, response) {
+    if (!this.assertEnabled(response)) {
+      return;
+    }
+    const rows = await resolveWalletConnection().getRepository(WalletAccountEntity).find({
+      take: limit,
+      skip: offset,
+      order: {
+        id: "DESC"
+      }
+    });
+    response.status(200).send({
+      status: 1,
+      data: rows.map((row) => ({
+        id: row.id,
+        ownerType: row.ownerType,
+        ownerId: row.ownerId,
+        currency: row.currency,
+        available: fromMinorUnit(Number(row.availableBalance)),
+        held: fromMinorUnit(Number(row.heldBalance)),
+        total: fromMinorUnit(Number(row.availableBalance) + Number(row.heldBalance))
+      }))
+    });
+  }
+  async listTransactions(accountId, limit = 50, offset = 0, response) {
+    if (!this.assertEnabled(response)) {
+      return;
+    }
+    const entries = await this.plugin.client.getTransactions({
+      accountId,
+      limit,
+      offset
+    });
+    response.status(200).send({
+      status: 1,
+      data: entries.map((e) => ({
+        ...e,
+        amount: fromMinorUnit(e.amount),
+        balanceAfterAvailable: fromMinorUnit(e.balanceAfterAvailable),
+        balanceAfterHeld: fromMinorUnit(e.balanceAfterHeld)
+      }))
+    });
+  }
+  async credit(body, request, response) {
+    if (!this.assertEnabled(response)) {
+      return;
+    }
+    const currency = body.currency || "INR";
+    const account = await this.plugin.client.getOrCreateAccount(body.ownerType, body.ownerId, currency);
+    const result = await this.plugin.client.credit({
+      accountId: account.id,
+      amount: toMinorUnit(body.amount),
+      idempotencyKey: `admin:credit:${body.ownerType}:${body.ownerId}:${Date.now()}`,
+      reference: {
+        referenceType: "admin_adjustment",
+        referenceId: String(request.user?.userId || 0)
+      },
+      metadata: {
+        reason: body.reason
+      }
+    });
+    await this.emitAdminMutation({
+      event: "wallet_admin_credit",
+      actorId: request.user?.userId,
+      actorRole: "admin",
+      amount: body.amount,
+      after: {
+        accountId: account.id,
+        entryId: result.entry.id
+      }
+    });
+    response.status(200).send({
+      status: 1,
+      message: "Wallet credited successfully",
+      data: {
+        accountId: account.id,
+        available: fromMinorUnit(result.account.availableBalance)
+      }
+    });
+  }
+  async debit(body, request, response) {
+    if (!this.assertEnabled(response)) {
+      return;
+    }
+    const currency = body.currency || "INR";
+    const account = await this.plugin.client.getOrCreateAccount(body.ownerType, body.ownerId, currency);
+    const result = await this.plugin.client.debit({
+      accountId: account.id,
+      amount: toMinorUnit(body.amount),
+      idempotencyKey: `admin:debit:${body.ownerType}:${body.ownerId}:${Date.now()}`,
+      reference: {
+        referenceType: "admin_adjustment",
+        referenceId: String(request.user?.userId || 0)
+      },
+      metadata: {
+        reason: body.reason
+      }
+    });
+    await this.emitAdminMutation({
+      event: "wallet_admin_debit",
+      actorId: request.user?.userId,
+      actorRole: "admin",
+      amount: body.amount,
+      after: {
+        accountId: account.id,
+        entryId: result.entry.id
+      }
+    });
+    response.status(200).send({
+      status: 1,
+      message: "Wallet debited successfully",
+      data: {
+        accountId: account.id,
+        available: fromMinorUnit(result.account.availableBalance)
+      }
+    });
+  }
+  async emitAdminMutation(event) {
+    const handler = this.plugin.onAdminMutation;
+    if (handler) {
+      await handler(event);
+    }
+  }
+};
+__name(_AdminWalletController, "AdminWalletController");
+var AdminWalletController = _AdminWalletController;
+_ts_decorate2([
+  Get("/accounts"),
+  Authorized([
+    "admin"
+  ]),
+  _ts_param(0, QueryParam("limit")),
+  _ts_param(1, QueryParam("offset")),
+  _ts_param(2, Res()),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    Number,
+    Number,
+    Object
+  ]),
+  _ts_metadata2("design:returntype", Promise)
+], AdminWalletController.prototype, "listAccounts", null);
+_ts_decorate2([
+  Get("/transactions/:accountId"),
+  Authorized([
+    "admin"
+  ]),
+  _ts_param(0, Param("accountId")),
+  _ts_param(1, QueryParam("limit")),
+  _ts_param(2, QueryParam("offset")),
+  _ts_param(3, Res()),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    Number,
+    Number,
+    Number,
+    Object
+  ]),
+  _ts_metadata2("design:returntype", Promise)
+], AdminWalletController.prototype, "listTransactions", null);
+_ts_decorate2([
+  Post("/credit"),
+  Authorized([
+    "admin"
+  ]),
+  _ts_param(0, Body({
+    validate: true
+  })),
+  _ts_param(1, Req()),
+  _ts_param(2, Res()),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof WalletCreditDebitRequest === "undefined" ? Object : WalletCreditDebitRequest,
+    Object,
+    Object
+  ]),
+  _ts_metadata2("design:returntype", Promise)
+], AdminWalletController.prototype, "credit", null);
+_ts_decorate2([
+  Post("/debit"),
+  Authorized([
+    "admin"
+  ]),
+  _ts_param(0, Body({
+    validate: true
+  })),
+  _ts_param(1, Req()),
+  _ts_param(2, Res()),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof WalletCreditDebitRequest === "undefined" ? Object : WalletCreditDebitRequest,
+    Object,
+    Object
+  ]),
+  _ts_metadata2("design:returntype", Promise)
+], AdminWalletController.prototype, "debit", null);
+AdminWalletController = _ts_decorate2([
+  JsonController("/admin/wallet")
+], AdminWalletController);
+function _ts_decorate3(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_decorate3, "_ts_decorate");
+function _ts_metadata3(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata3, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_ts_param");
+var _CustomerWalletController = class _CustomerWalletController {
+  get plugin() {
+    return resolveWalletPlugin();
+  }
+  assertEnabled(response) {
+    if (!this.plugin.isEnabled()) {
+      response.status(404).send({
+        status: 0,
+        message: "Wallet feature is disabled"
+      });
+      return false;
+    }
+    return true;
+  }
+  async getBalance(request, response) {
+    if (!this.assertEnabled(response)) {
+      return;
+    }
+    const customerId = request.user?.id ?? 0;
+    const account = await this.plugin.client.getOrCreateAccount(WalletAccountType.CUSTOMER, customerId, "INR");
+    const balance = await this.plugin.client.getBalance(account.id);
+    response.status(200).send({
+      status: 1,
+      data: {
+        available: fromMinorUnit(balance.available),
+        held: fromMinorUnit(balance.held),
+        total: fromMinorUnit(balance.total),
+        currency: account.currency
+      }
+    });
+  }
+  async getTransactions(request, limit = 50, offset = 0, response) {
+    if (!this.assertEnabled(response)) {
+      return;
+    }
+    const customerId = request.user?.id ?? 0;
+    const account = await this.plugin.client.getOrCreateAccount(WalletAccountType.CUSTOMER, customerId, "INR");
+    const entries = await this.plugin.client.getTransactions({
+      accountId: account.id,
+      limit,
+      offset
+    });
+    response.status(200).send({
+      status: 1,
+      data: entries.map((e) => ({
+        id: e.id,
+        entryType: e.entryType,
+        amount: fromMinorUnit(e.amount),
+        referenceType: e.referenceType,
+        referenceId: e.referenceId,
+        createdAt: e.createdAt
+      }))
+    });
+  }
+};
+__name(_CustomerWalletController, "CustomerWalletController");
+var CustomerWalletController = _CustomerWalletController;
+_ts_decorate3([
+  Get("/balance"),
+  Authorized("customer"),
+  _ts_param2(0, Req()),
+  _ts_param2(1, Res()),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    Object,
+    Object
+  ]),
+  _ts_metadata3("design:returntype", Promise)
+], CustomerWalletController.prototype, "getBalance", null);
+_ts_decorate3([
+  Get("/transactions"),
+  Authorized("customer"),
+  _ts_param2(0, Req()),
+  _ts_param2(1, QueryParam("limit")),
+  _ts_param2(2, QueryParam("offset")),
+  _ts_param2(3, Res()),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    Object,
+    Number,
+    Number,
+    Object
+  ]),
+  _ts_metadata3("design:returntype", Promise)
+], CustomerWalletController.prototype, "getTransactions", null);
+CustomerWalletController = _ts_decorate3([
+  JsonController("/customer/wallet")
+], CustomerWalletController);
+function _ts_decorate4(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_decorate4, "_ts_decorate");
+function _ts_metadata4(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata4, "_ts_metadata");
+function _ts_param3(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param3, "_ts_param");
+var _VendorWalletController = class _VendorWalletController {
+  get plugin() {
+    return resolveWalletPlugin();
+  }
+  assertEnabled(response) {
+    if (!this.plugin.isEnabled()) {
+      response.status(404).send({
+        status: 0,
+        message: "Wallet feature is disabled"
+      });
+      return false;
+    }
+    return true;
+  }
+  async getBalance(request, response) {
+    if (!this.assertEnabled(response)) {
+      return;
+    }
+    const vendorId = request.user?.vendorId ?? 0;
+    const account = await this.plugin.client.getOrCreateAccount(WalletAccountType.VENDOR, vendorId, "INR");
+    const balance = await this.plugin.client.getBalance(account.id);
+    response.status(200).send({
+      status: 1,
+      data: {
+        available: fromMinorUnit(balance.available),
+        held: fromMinorUnit(balance.held),
+        total: fromMinorUnit(balance.total),
+        currency: account.currency
+      }
+    });
+  }
+  async getTransactions(request, limit = 50, offset = 0, response) {
+    if (!this.assertEnabled(response)) {
+      return;
+    }
+    const vendorId = request.user?.vendorId ?? 0;
+    const account = await this.plugin.client.getOrCreateAccount(WalletAccountType.VENDOR, vendorId, "INR");
+    const entries = await this.plugin.client.getTransactions({
+      accountId: account.id,
+      limit,
+      offset
+    });
+    response.status(200).send({
+      status: 1,
+      data: entries.map((e) => ({
+        id: e.id,
+        entryType: e.entryType,
+        amount: fromMinorUnit(e.amount),
+        referenceType: e.referenceType,
+        referenceId: e.referenceId,
+        createdAt: e.createdAt
+      }))
+    });
+  }
+};
+__name(_VendorWalletController, "VendorWalletController");
+var VendorWalletController = _VendorWalletController;
+_ts_decorate4([
+  Get("/balance"),
+  Authorized("vendor"),
+  _ts_param3(0, Req()),
+  _ts_param3(1, Res()),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    Object,
+    Object
+  ]),
+  _ts_metadata4("design:returntype", Promise)
+], VendorWalletController.prototype, "getBalance", null);
+_ts_decorate4([
+  Get("/transactions"),
+  Authorized("vendor"),
+  _ts_param3(0, Req()),
+  _ts_param3(1, QueryParam("limit")),
+  _ts_param3(2, QueryParam("offset")),
+  _ts_param3(3, Res()),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    Object,
+    Number,
+    Number,
+    Object
+  ]),
+  _ts_metadata4("design:returntype", Promise)
+], VendorWalletController.prototype, "getTransactions", null);
+VendorWalletController = _ts_decorate4([
+  JsonController("/vendor/wallet")
+], VendorWalletController);
+function createExpressWalletRouter(plugin, _basePath = "/api") {
+  const router = Router();
+  const disabled = /* @__PURE__ */ __name((_req, res) => {
+    res.status(404).json({
+      status: 0,
+      message: "Wallet feature is disabled"
+    });
+  }, "disabled");
+  const guard = /* @__PURE__ */ __name((req, res, next) => {
+    if (!plugin.isEnabled()) {
+      disabled(req, res);
+      return;
+    }
+    next();
+  }, "guard");
+  router.use(guard);
+  router.get("/customer/wallet/balance", async (req, res) => {
+    try {
+      const customerId = Number(req.user?.id ?? 0);
+      const account = await plugin.client.getOrCreateAccount(WalletAccountType.CUSTOMER, customerId, "INR");
+      const balance = await plugin.client.getBalance(account.id);
+      res.json({
+        status: 1,
+        data: {
+          available: fromMinorUnit(balance.available),
+          held: fromMinorUnit(balance.held),
+          total: fromMinorUnit(balance.total),
+          currency: account.currency
+        }
+      });
+    } catch (e) {
+      res.status(500).json({
+        status: 0,
+        message: e.message
+      });
+    }
+  });
+  router.get("/vendor/wallet/balance", async (req, res) => {
+    try {
+      const vendorId = Number(req.user?.vendorId ?? 0);
+      const account = await plugin.client.getOrCreateAccount(WalletAccountType.VENDOR, vendorId, "INR");
+      const balance = await plugin.client.getBalance(account.id);
+      res.json({
+        status: 1,
+        data: {
+          available: fromMinorUnit(balance.available),
+          held: fromMinorUnit(balance.held),
+          total: fromMinorUnit(balance.total),
+          currency: account.currency
+        }
+      });
+    } catch (e) {
+      res.status(500).json({
+        status: 0,
+        message: e.message
+      });
+    }
+  });
+  return router;
+}
+__name(createExpressWalletRouter, "createExpressWalletRouter");
+
+// src/http/plugin-http.ts
+function buildWalletHttp(plugin, config) {
+  if (!config || config.mode === "none" || !plugin.isEnabled()) {
+    return {};
+  }
+  if (config.mode === "routing-controllers") {
+    return {
+      controllers: [
+        AdminWalletController,
+        CustomerWalletController,
+        VendorWalletController
+      ]
+    };
+  }
+  if (config.mode === "express-router") {
+    const router = createExpressWalletRouter(plugin, config.basePath ?? "/api");
+    if (config.app) {
+      config.app.use(config.basePath ?? "/api", router);
+    }
+    return {
+      expressRouter: router
+    };
+  }
+  return {};
+}
+__name(buildWalletHttp, "buildWalletHttp");
+
+// src/payment/types.ts
+var PaymentProviderWallet = "wallet";
+
+// src/payment/WalletPaymentAdapter.ts
+function createWalletPaymentAdapter(plugin) {
+  return {
+    provider: PaymentProviderWallet,
+    getPublicCredential() {
+      return plugin.isCheckoutEnabled() ? "wallet" : null;
+    },
+    async createPayment(input) {
+      if (!plugin.isCheckoutEnabled()) {
+        throw new Error("Wallet checkout is not enabled");
+      }
+      const resolveCustomer = plugin.resolveOrderCustomerId;
+      if (!resolveCustomer) {
+        throw new Error("resolveOrderCustomerId is not configured on wallet plugin");
+      }
+      const customerId = await resolveCustomer(input.orderId);
+      if (!customerId) {
+        throw new Error("Order customer not found for wallet payment");
+      }
+      const client = plugin.client;
+      const customerAccount = await client.getOrCreateAccount(WalletAccountType.CUSTOMER, customerId, input.currency);
+      const balance = await client.getBalance(customerAccount.id);
+      const amountPaise = toMinorUnit(input.amount);
+      if (balance.available < amountPaise) {
+        throw new Error("Insufficient wallet balance");
+      }
+      return {
+        providerPaymentId: `wallet-order-${input.orderId}`,
+        provider: PaymentProviderWallet,
+        raw: {
+          customerAccountId: customerAccount.id,
+          amountPaise
+        }
+      };
+    },
+    async verifyPayment(providerPaymentId) {
+      return {
+        providerPaymentId,
+        status: "succeeded",
+        amount: 0,
+        currency: "INR",
+        provider: PaymentProviderWallet,
+        raw: {}
+      };
+    },
+    async fetchPaymentStatus(providerPaymentId) {
+      return this.verifyPayment(providerPaymentId);
+    },
+    async resolveProviderPaymentId(orderId) {
+      return `wallet-order-${orderId}`;
+    },
+    async createRefund(_input) {
+      throw new Error("Wallet refunds are handled via wallet hooks.onRefund");
+    },
+    verifyWebhook(_payload, _signature) {
+      return {
+        isValid: false
+      };
+    }
+  };
+}
+__name(createWalletPaymentAdapter, "createWalletPaymentAdapter");
+
+// src/typeorm/store.ts
+function toNumber(value) {
+  if (value == null) {
+    return 0;
+  }
+  return Number(value);
+}
+__name(toNumber, "toNumber");
+function toLedgerAccount(row) {
+  return {
+    id: row.id,
+    ownerType: row.ownerType,
+    ownerId: row.ownerId,
+    currency: row.currency,
+    availableBalance: toNumber(row.availableBalance),
+    heldBalance: toNumber(row.heldBalance)
+  };
+}
+__name(toLedgerAccount, "toLedgerAccount");
+function toLedgerHold(row) {
+  return {
+    id: row.id,
+    sourceAccountId: row.sourceAccountId,
+    targetAccountId: row.targetAccountId,
+    amount: toNumber(row.amount),
+    status: row.status,
+    referenceType: row.referenceType,
+    referenceId: row.referenceId,
+    idempotencyKey: row.idempotencyKey,
+    createdAt: new Date(row.createdDate)
+  };
+}
+__name(toLedgerHold, "toLedgerHold");
+function toLedgerEntry(row) {
+  return {
+    id: row.id,
+    accountId: row.accountId,
+    entryType: row.entryType,
+    amount: toNumber(row.amount),
+    balanceAfterAvailable: toNumber(row.balanceAfterAvailable),
+    balanceAfterHeld: toNumber(row.balanceAfterHeld),
+    idempotencyKey: row.idempotencyKey,
+    referenceType: row.referenceType,
+    referenceId: row.referenceId,
+    metadata: row.metadata,
+    createdAt: new Date(row.createdDate)
+  };
+}
+__name(toLedgerEntry, "toLedgerEntry");
+function isEntityManager(value) {
+  return value != null && typeof value === "object" && typeof value.getRepository === "function";
+}
+__name(isEntityManager, "isEntityManager");
+var _a2;
+var TypeOrmWalletStoreTx = (_a2 = class {
+  constructor(em) {
+    __publicField(this, "em");
+    this.em = em;
+  }
+  async getOrCreateAccount(type, ownerId, currency) {
+    const repo = this.em.getRepository(WalletAccountEntity);
+    let row = await repo.findOne({
+      where: {
+        ownerType: type,
+        ownerId,
+        currency
+      }
+    });
+    if (!row) {
+      row = repo.create({
+        ownerType: type,
+        ownerId,
+        currency,
+        availableBalance: "0",
+        heldBalance: "0"
+      });
+      row = await repo.save(row);
+    }
+    return toLedgerAccount(row);
+  }
+  async lockAccount(accountId) {
+    const row = await this.em.getRepository(WalletAccountEntity).createQueryBuilder("wa").setLock("pessimistic_write").where("wa.id = :id", {
+      id: accountId
+    }).getOne();
+    if (!row) {
+      throw new Error(`Wallet account ${accountId} not found`);
+    }
+    return toLedgerAccount(row);
+  }
+  async getAccountById(accountId) {
+    const row = await this.em.getRepository(WalletAccountEntity).findOne({
+      where: {
+        id: accountId
+      }
+    });
+    return row ? toLedgerAccount(row) : null;
+  }
+  async appendLedgerEntry(entry) {
+    const existing = await this.findLedgerByIdempotencyKey(entry.idempotencyKey);
+    if (existing) {
+      return existing;
+    }
+    const repo = this.em.getRepository(WalletLedgerEntryEntity);
+    try {
+      const row = await repo.save(repo.create({
+        accountId: entry.accountId,
+        entryType: entry.entryType,
+        amount: String(entry.amount),
+        balanceAfterAvailable: String(entry.balanceAfterAvailable),
+        balanceAfterHeld: String(entry.balanceAfterHeld),
+        idempotencyKey: entry.idempotencyKey,
+        referenceType: entry.referenceType,
+        referenceId: entry.referenceId,
+        metadata: entry.metadata
+      }));
+      return toLedgerEntry(row);
+    } catch (error) {
+      const err = error;
+      const code = err?.code || err?.errno;
+      if (code === "ER_DUP_ENTRY" || code === 1062) {
+        const dup = await this.findLedgerByIdempotencyKey(entry.idempotencyKey);
+        if (dup) {
+          return dup;
+        }
+        throw new DuplicateOperationError("Duplicate idempotency key", null);
+      }
+      throw error;
+    }
+  }
+  async updateBalances(accountId, deltas) {
+    const row = await this.em.getRepository(WalletAccountEntity).createQueryBuilder("wa").setLock("pessimistic_write").where("wa.id = :id", {
+      id: accountId
+    }).getOne();
+    if (!row) {
+      throw new Error(`Wallet account ${accountId} not found`);
+    }
+    const available = toNumber(row.availableBalance) + (deltas.availableDelta ?? 0);
+    const held = toNumber(row.heldBalance) + (deltas.heldDelta ?? 0);
+    if (available < 0 || held < 0) {
+      throw new Error("Balance cannot be negative");
+    }
+    row.availableBalance = String(available);
+    row.heldBalance = String(held);
+    const saved = await this.em.getRepository(WalletAccountEntity).save(row);
+    return toLedgerAccount(saved);
+  }
+  async findHoldByReference(ref) {
+    const row = await this.em.getRepository(WalletHoldEntity).findOne({
+      where: {
+        referenceType: ref.referenceType,
+        referenceId: ref.referenceId
+      },
+      order: {
+        id: "DESC"
+      }
+    });
+    return row ? toLedgerHold(row) : null;
+  }
+  async upsertHold(hold) {
+    const repo = this.em.getRepository(WalletHoldEntity);
+    let row;
+    if (hold.id != null) {
+      row = await repo.findOne({
+        where: {
+          id: hold.id
+        }
+      });
+    }
+    if (!row) {
+      row = await repo.findOne({
+        where: {
+          referenceType: hold.referenceType,
+          referenceId: hold.referenceId
+        }
+      });
+    }
+    if (!row) {
+      row = repo.create({
+        sourceAccountId: hold.sourceAccountId,
+        targetAccountId: hold.targetAccountId,
+        amount: String(hold.amount),
+        status: hold.status,
+        referenceType: hold.referenceType,
+        referenceId: hold.referenceId,
+        idempotencyKey: hold.idempotencyKey
+      });
+    } else {
+      row.sourceAccountId = hold.sourceAccountId;
+      row.targetAccountId = hold.targetAccountId;
+      row.amount = String(hold.amount);
+      row.status = hold.status;
+      row.idempotencyKey = hold.idempotencyKey;
+    }
+    const saved = await repo.save(row);
+    return toLedgerHold(saved);
+  }
+  async findLedgerByIdempotencyKey(key) {
+    const row = await this.em.getRepository(WalletLedgerEntryEntity).findOne({
+      where: {
+        idempotencyKey: key
+      }
+    });
+    return row ? toLedgerEntry(row) : null;
+  }
+  async listLedgerEntries(accountId, limit, offset) {
+    const rows = await this.em.getRepository(WalletLedgerEntryEntity).find({
+      where: {
+        accountId
+      },
+      order: {
+        id: "DESC"
+      },
+      take: limit,
+      skip: offset
+    });
+    return rows.map(toLedgerEntry);
+  }
+}, __name(_a2, "TypeOrmWalletStoreTx"), _a2);
+var _TypeOrmWalletStore = class _TypeOrmWalletStore {
+  constructor(connection) {
+    __publicField(this, "connection");
+    this.connection = connection;
+  }
+  async runInTransaction(fn, ctx) {
+    if (isEntityManager(ctx?.nativeTx)) {
+      return fn(new TypeOrmWalletStoreTx(ctx.nativeTx));
+    }
+    return this.connection.manager.transaction(async (em) => fn(new TypeOrmWalletStoreTx(em)));
+  }
+};
+__name(_TypeOrmWalletStore, "TypeOrmWalletStore");
+var TypeOrmWalletStore = _TypeOrmWalletStore;
+
+// src/typeorm/migrations/CreateWalletTables.ts
+async function indexExists(queryRunner, tableName, indexName) {
+  const rows = await queryRunner.query(`SELECT COUNT(1) AS c
+     FROM information_schema.statistics
+     WHERE table_schema = DATABASE()
+       AND table_name = ?
+       AND index_name = ?`, [
+    tableName,
+    indexName
+  ]);
+  return Number(rows[0]?.c ?? 0) > 0;
+}
+__name(indexExists, "indexExists");
+var _CreateWalletTables1790000000000 = class _CreateWalletTables1790000000000 {
+  async up(queryRunner) {
+    if (!await queryRunner.hasTable("wallet_account")) {
+      await queryRunner.query(`
+        CREATE TABLE \`wallet_account\` (
+          \`id\` int NOT NULL AUTO_INCREMENT,
+          \`owner_type\` varchar(32) NOT NULL,
+          \`owner_id\` int NOT NULL,
+          \`currency\` varchar(8) NOT NULL DEFAULT 'INR',
+          \`available_balance\` bigint NOT NULL DEFAULT 0,
+          \`held_balance\` bigint NOT NULL DEFAULT 0,
+          \`created_by\` int NULL,
+          \`created_date\` datetime NULL,
+          \`modified_by\` int NULL,
+          \`modified_date\` datetime NULL,
+          PRIMARY KEY (\`id\`)
+        ) ENGINE=InnoDB
+      `);
+    }
+    if (!await indexExists(queryRunner, "wallet_account", "IDX_wallet_account_owner_currency")) {
+      await queryRunner.query(`
+        CREATE UNIQUE INDEX \`IDX_wallet_account_owner_currency\`
+        ON \`wallet_account\` (\`owner_type\`, \`owner_id\`, \`currency\`)
+      `);
+    }
+    if (!await queryRunner.hasTable("wallet_ledger_entry")) {
+      await queryRunner.query(`
+        CREATE TABLE \`wallet_ledger_entry\` (
+          \`id\` int NOT NULL AUTO_INCREMENT,
+          \`account_id\` int NOT NULL,
+          \`entry_type\` varchar(32) NOT NULL,
+          \`amount\` bigint NOT NULL,
+          \`balance_after_available\` bigint NOT NULL,
+          \`balance_after_held\` bigint NOT NULL,
+          \`idempotency_key\` varchar(255) NOT NULL,
+          \`reference_type\` varchar(64) NULL,
+          \`reference_id\` varchar(128) NULL,
+          \`metadata\` json NULL,
+          \`created_by\` int NULL,
+          \`created_date\` datetime NULL,
+          \`modified_by\` int NULL,
+          \`modified_date\` datetime NULL,
+          PRIMARY KEY (\`id\`),
+          UNIQUE INDEX \`UQ_wallet_ledger_idempotency_key\` (\`idempotency_key\`)
+        ) ENGINE=InnoDB
+      `);
+    }
+    if (!await indexExists(queryRunner, "wallet_ledger_entry", "IDX_wallet_ledger_account_id")) {
+      await queryRunner.query(`
+        CREATE INDEX \`IDX_wallet_ledger_account_id\`
+        ON \`wallet_ledger_entry\` (\`account_id\`)
+      `);
+    }
+    if (!await queryRunner.hasTable("wallet_hold")) {
+      await queryRunner.query(`
+        CREATE TABLE \`wallet_hold\` (
+          \`id\` int NOT NULL AUTO_INCREMENT,
+          \`source_account_id\` int NOT NULL,
+          \`target_account_id\` int NOT NULL,
+          \`amount\` bigint NOT NULL,
+          \`status\` varchar(16) NOT NULL DEFAULT 'active',
+          \`reference_type\` varchar(64) NOT NULL,
+          \`reference_id\` varchar(128) NOT NULL,
+          \`idempotency_key\` varchar(255) NOT NULL,
+          \`created_by\` int NULL,
+          \`created_date\` datetime NULL,
+          \`modified_by\` int NULL,
+          \`modified_date\` datetime NULL,
+          PRIMARY KEY (\`id\`)
+        ) ENGINE=InnoDB
+      `);
+    }
+    if (!await indexExists(queryRunner, "wallet_hold", "IDX_wallet_hold_reference")) {
+      await queryRunner.query(`
+        CREATE INDEX \`IDX_wallet_hold_reference\`
+        ON \`wallet_hold\` (\`reference_type\`, \`reference_id\`)
+      `);
+    }
+  }
+  async down(queryRunner) {
+    if (await queryRunner.hasTable("wallet_hold")) {
+      await queryRunner.query("DROP TABLE `wallet_hold`");
+    }
+    if (await queryRunner.hasTable("wallet_ledger_entry")) {
+      await queryRunner.query("DROP TABLE `wallet_ledger_entry`");
+    }
+    if (await queryRunner.hasTable("wallet_account")) {
+      await queryRunner.query("DROP TABLE `wallet_account`");
+    }
+  }
+};
+__name(_CreateWalletTables1790000000000, "CreateWalletTables1790000000000");
+var CreateWalletTables1790000000000 = _CreateWalletTables1790000000000;
+
+// src/typeorm/metadata.ts
+function getWalletOrmMetadata() {
+  return {
+    entities: [
+      WalletAccountEntity,
+      WalletLedgerEntryEntity,
+      WalletHoldEntity
+    ],
+    migrations: [
+      CreateWalletTables1790000000000
+    ]
+  };
+}
+__name(getWalletOrmMetadata, "getWalletOrmMetadata");
+
+// src/plugin-types.ts
+var WALLET_PLUGIN_TOKEN = "multivendor-wallet.plugin";
+
+// src/plugin.ts
+function scheduleReconciliation(config, onRun) {
+  if (!config.reconciliation?.enabled || !config.flags.enabled) {
+    return void 0;
+  }
+  const cronExpr = config.reconciliation.cron ?? "0 2 * * *";
+  let intervalId;
+  try {
+    const cron = __require("node-cron");
+    return cron.schedule(cronExpr, () => {
+      void onRun();
+    });
+  } catch {
+    intervalId = setInterval(() => {
+      void onRun();
+    }, 24 * 60 * 60 * 1e3);
+    return {
+      stop: /* @__PURE__ */ __name(() => clearInterval(intervalId), "stop")
+    };
+  }
+}
+__name(scheduleReconciliation, "scheduleReconciliation");
+var _a3;
+var WalletPluginImpl = (_a3 = class {
+  constructor(config, store) {
+    __publicField(this, "client");
+    __publicField(this, "hooks");
+    __publicField(this, "flags");
+    __publicField(this, "http");
+    __publicField(this, "payment");
+    __publicField(this, "onAdminMutation");
+    __publicField(this, "resolveOrderCustomerId");
+    __publicField(this, "cronTask");
+    this.flags = config.flags;
+    this.onAdminMutation = config.onAdminMutation;
+    this.resolveOrderCustomerId = config.resolveOrderCustomerId;
+    this.client = new WalletLedgerClient(store, {
+      defaultCurrency: config.defaultCurrency ?? "INR",
+      platformOwnerId: config.platformOwnerId
+    });
+    this.hooks = createLifecycleHooks({
+      client: this.client,
+      platformOwnerId: config.platformOwnerId,
+      defaultCurrency: config.defaultCurrency ?? "INR",
+      flags: config.flags
+    });
+    this.http = buildWalletHttp(this, config.http);
+    this.payment = {
+      createWalletPaymentAdapter: /* @__PURE__ */ __name(() => createWalletPaymentAdapter(this), "createWalletPaymentAdapter")
+    };
+    if (config.reconciliation?.enabled && config.flags.enabled) {
+      this.cronTask = scheduleReconciliation(config, async () => {
+        const report = await runWalletReconciliation();
+        if (report.parityDeltas.length > 0 || report.cacheMismatches.length > 0) {
+          config.reconciliation?.onMismatch?.(report);
+          config.reconciliation?.onLog?.("warn", "wallet reconciliation mismatch", report);
+        } else {
+          config.reconciliation?.onLog?.("info", "wallet reconciliation ok");
+        }
+      });
+    }
+  }
+  isEnabled() {
+    return this.flags.enabled;
+  }
+  isLedgerWritesEnabled() {
+    return this.flags.enabled && this.flags.ledgerWrites;
+  }
+  isSettlementDebitEnabled() {
+    return this.flags.enabled && this.flags.settlementDebit;
+  }
+  isCheckoutEnabled() {
+    return this.flags.enabled && this.flags.checkout;
+  }
+  async shutdown() {
+    this.cronTask?.stop();
+  }
+}, __name(_a3, "WalletPluginImpl"), _a3);
+function registerWalletPlugin(config) {
+  if (config.dataSource == null) {
+    throw new Error("WalletPluginConfig.dataSource is required (host TypeORM Connection).");
+  }
+  bindWalletConnection(config.dataSource);
+  const store = new TypeOrmWalletStore(config.dataSource);
+  const plugin = new WalletPluginImpl(config, store);
+  bindWalletPlugin(plugin);
+  return plugin;
+}
+__name(registerWalletPlugin, "registerWalletPlugin");
+
+export { AdminWalletController, CreateWalletTables1790000000000, CustomerWalletController, DuplicateOperationError, HoldNotFoundError, HoldStatus, InsufficientBalanceError, InvalidAmountError, LedgerEntryType, PaymentProviderWallet, TypeOrmWalletStore, VendorWalletController, WALLET_PLUGIN_TOKEN, WalletAccountEntity, WalletAccountType, WalletConfigError, WalletError, WalletHoldEntity, WalletLedgerClient, WalletLedgerEntryEntity, createExpressWalletRouter, createWalletPaymentAdapter, fromMinorUnit, getWalletOrmMetadata, registerWalletPlugin, toMinorUnit };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map