@openora/core 0.4.0

package/dist/wallet/schema/index.d.ts

@@ -0,0 +1,491 @@
+export declare const walletTransactionTypeEnum: import("drizzle-orm/pg-core").PgEnum<["deposit", "withdrawal", "bet", "win", "loss", "bonus", "tip"]>;
+export declare const walletTransactionStatusEnum: import("drizzle-orm/pg-core").PgEnum<["pending", "processing", "completed", "failed", "rejected", "on_hold", "cancelled"]>;
+export declare const walletRailEnum: import("drizzle-orm/pg-core").PgEnum<["crypto", "fiat"]>;
+export declare const wallet: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "wallet";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "wallet";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        userId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "userId";
+            tableName: "wallet";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        balance: import("drizzle-orm/pg-core").PgColumn<{
+            name: "balance";
+            tableName: "wallet";
+            dataType: "string";
+            columnType: "PgNumeric";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        currency: import("drizzle-orm/pg-core").PgColumn<{
+            name: "currency";
+            tableName: "wallet";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updatedAt";
+            tableName: "wallet";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const walletTransaction: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "wallet_transaction";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "wallet_transaction";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        walletId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "walletId";
+            tableName: "wallet_transaction";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        type: import("drizzle-orm/pg-core").PgColumn<{
+            name: "type";
+            tableName: "wallet_transaction";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "deposit" | "loss" | "withdrawal" | "bet" | "win" | "bonus" | "tip";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["deposit", "withdrawal", "bet", "win", "loss", "bonus", "tip"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        amount: import("drizzle-orm/pg-core").PgColumn<{
+            name: "amount";
+            tableName: "wallet_transaction";
+            dataType: "string";
+            columnType: "PgNumeric";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        currency: import("drizzle-orm/pg-core").PgColumn<{
+            name: "currency";
+            tableName: "wallet_transaction";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "wallet_transaction";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "pending" | "rejected" | "processing" | "completed" | "failed" | "on_hold" | "cancelled";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["pending", "processing", "completed", "failed", "rejected", "on_hold", "cancelled"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: "pending" | "rejected" | "processing" | "completed" | "failed" | "on_hold" | "cancelled";
+        }>;
+        rail: import("drizzle-orm/pg-core").PgColumn<{
+            name: "rail";
+            tableName: "wallet_transaction";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "crypto" | "fiat";
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["crypto", "fiat"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: "crypto" | "fiat";
+        }>;
+        reviewedBy: import("drizzle-orm/pg-core").PgColumn<{
+            name: "reviewedBy";
+            tableName: "wallet_transaction";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        reviewedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "reviewedAt";
+            tableName: "wallet_transaction";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        reviewReason: import("drizzle-orm/pg-core").PgColumn<{
+            name: "reviewReason";
+            tableName: "wallet_transaction";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        providerName: import("drizzle-orm/pg-core").PgColumn<{
+            name: "providerName";
+            tableName: "wallet_transaction";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        providerRefId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "providerRefId";
+            tableName: "wallet_transaction";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: import("drizzle-orm/pg-core").PgColumn<{
+            name: "metadata";
+            tableName: "wallet_transaction";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        idempotencyKey: import("drizzle-orm/pg-core").PgColumn<{
+            name: "idempotencyKey";
+            tableName: "wallet_transaction";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "createdAt";
+            tableName: "wallet_transaction";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const autoWithdrawalRule: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "auto_withdrawal_rule";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "auto_withdrawal_rule";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        userId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "userId";
+            tableName: "auto_withdrawal_rule";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        threshold: import("drizzle-orm/pg-core").PgColumn<{
+            name: "threshold";
+            tableName: "auto_withdrawal_rule";
+            dataType: "string";
+            columnType: "PgNumeric";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        reason: import("drizzle-orm/pg-core").PgColumn<{
+            name: "reason";
+            tableName: "auto_withdrawal_rule";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdBy: import("drizzle-orm/pg-core").PgColumn<{
+            name: "createdBy";
+            tableName: "auto_withdrawal_rule";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "createdAt";
+            tableName: "auto_withdrawal_rule";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updatedAt";
+            tableName: "auto_withdrawal_rule";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export type Wallet = typeof wallet.$inferSelect;
+export type WalletTransaction = typeof walletTransaction.$inferSelect;
+export type AutoWithdrawalRule = typeof autoWithdrawalRule.$inferSelect;
+//# sourceMappingURL=index.d.ts.map

package/dist/wallet/schema/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/wallet/schema/index.ts"],"names":[],"mappings":"AAqBA,eAAO,MAAM,yBAAyB,uGAGrC,CAAC;AAEF,eAAO,MAAM,2BAA2B,4HAGvC,CAAC;AAEF,eAAO,MAAM,cAAc,0DAAsC,CAAC;AAElE,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQjB,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6C7B,CAAC;AAGF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAU7B,CAAC;AAEH,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,YAAY,CAAC;AAChD,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC,YAAY,CAAC;AACtE,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAC,YAAY,CAAC"}

package/dist/wallet/schema/index.js

@@ -0,0 +1,72 @@
+import { sql } from 'drizzle-orm';
+import { pgTable, uuid, text, decimal, timestamp, pgEnum, index, uniqueIndex, } from 'drizzle-orm/pg-core';
+import { WALLET_RAILS, WALLET_TRANSACTION_STATUSES, WALLET_TRANSACTION_TYPES, } from '@openora/core/contracts';
+// Enum values derive from the canonical tuples so the DB enum can never drift from
+// the contract. Editing the value set is a one-place change in wallet-tx.ts.
+export const walletTransactionTypeEnum = pgEnum('wallet_transaction_type', WALLET_TRANSACTION_TYPES);
+export const walletTransactionStatusEnum = pgEnum('wallet_transaction_status', WALLET_TRANSACTION_STATUSES);
+export const walletRailEnum = pgEnum('wallet_rail', WALLET_RAILS);
+export const wallet = pgTable('wallet', {
+    id: uuid().primaryKey().defaultRandom(),
+    userId: uuid().notNull().unique('wallet_user_id_unique'),
+    balance: decimal().notNull().default('0'),
+    currency: text().notNull().default('USD'),
+    updatedAt: timestamp({ withTimezone: true })
+        .notNull()
+        .$onUpdateFn(() => new Date()),
+});
+export const walletTransaction = pgTable('wallet_transaction', {
+    id: uuid().primaryKey().defaultRandom(),
+    walletId: uuid()
+        .notNull()
+        .references(() => wallet.id),
+    type: walletTransactionTypeEnum().notNull(),
+    amount: decimal().notNull(),
+    currency: text().notNull(),
+    status: walletTransactionStatusEnum()
+        .$type()
+        .notNull()
+        .default('pending'),
+    rail: walletRailEnum().$type(),
+    // Admin user id (cross-module). Bare uuid, no .references - the user table is
+    // owned by another domain.
+    reviewedBy: uuid(),
+    reviewedAt: timestamp({ withTimezone: true }),
+    reviewReason: text(),
+    // The concrete settlement provider (eg a PSP name) and its reference id (eg the
+    // PSP charge id), as first-class typed columns so they are filterable for
+    // reconciliation rather than buried in free-form JSON.
+    providerName: text(),
+    providerRefId: text(),
+    // Reserved escape hatch for genuinely free-form, non-queryable extras. Provider
+    // identity now lives in the typed columns above, not here.
+    metadata: text(),
+    // Client-supplied dedup key for deposit/withdraw. A wallet is 1:1 with its user, so
+    // scoping the unique index on walletId is equivalent to scoping on userId.
+    idempotencyKey: uuid(),
+    createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
+}, (t) => [
+    index('wallet_transaction_wallet_id_idx').on(t.walletId),
+    index('wallet_transaction_created_at_idx').on(t.createdAt),
+    index('wallet_transaction_type_idx').on(t.type),
+    index('wallet_transaction_status_idx').on(t.status),
+    index('wallet_transaction_rail_idx').on(t.rail),
+    index('wallet_transaction_currency_idx').on(t.currency),
+    index('wallet_transaction_provider_ref_id_idx').on(t.providerRefId),
+    uniqueIndex('wallet_transaction_wallet_id_idempotency_key_idx')
+        .on(t.walletId, t.idempotencyKey)
+        .where(sql `${t.idempotencyKey} IS NOT NULL`),
+]);
+// Per-player threshold override (unique userId); overrides the global autoWithdrawal.fiatThreshold.
+export const autoWithdrawalRule = pgTable('auto_withdrawal_rule', {
+    id: uuid().primaryKey().defaultRandom(),
+    userId: uuid().notNull().unique('auto_withdrawal_rule_user_id_unique'),
+    threshold: decimal().notNull(),
+    reason: text().notNull(),
+    createdBy: uuid().notNull(),
+    createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp({ withTimezone: true })
+        .notNull()
+        .$onUpdateFn(() => new Date()),
+});
+//# sourceMappingURL=index.js.map

package/dist/wallet/schema/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/wallet/schema/index.ts"],"names":[],"mappings":"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"}

package/dist/wallet/server.d.ts

@@ -0,0 +1,4 @@
+export { WalletService, WalletNotFoundError, InsufficientBalanceError, } from './service/wallet.service.js';
+export { createWalletRouter } from './router/index.js';
+export { default } from './plugin.js';
+//# sourceMappingURL=server.d.ts.map

package/dist/wallet/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/wallet/server.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,mBAAmB,EACnB,wBAAwB,GACzB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC"}

package/dist/wallet/server.js

@@ -0,0 +1,4 @@
+export { WalletService, WalletNotFoundError, InsufficientBalanceError, } from './service/wallet.service.js';
+export { createWalletRouter } from './router/index.js';
+export { default } from './plugin.js';
+//# sourceMappingURL=server.js.map

package/dist/wallet/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","sourceRoot":"","sources":["../../src/wallet/server.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,mBAAmB,EACnB,wBAAwB,GACzB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC"}

package/dist/wallet/service/wallet-commands.service.d.ts

@@ -0,0 +1,7 @@
+import type { WalletCommands, WalletDebitArgs, WalletDebitOutcome, WalletCreditArgs, WalletCreditOutcome } from '@openora/core/contracts';
+export declare class WalletCommandsService implements WalletCommands {
+    private writeLedgerRow;
+    debit(tx: unknown, { userId, amount, type }: WalletDebitArgs): Promise<WalletDebitOutcome>;
+    credit(tx: unknown, { userId, amount, type }: WalletCreditArgs): Promise<WalletCreditOutcome>;
+}
+//# sourceMappingURL=wallet-commands.service.d.ts.map

package/dist/wallet/service/wallet-commands.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet-commands.service.d.ts","sourceRoot":"","sources":["../../../src/wallet/service/wallet-commands.service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,eAAe,EACf,kBAAkB,EAClB,gBAAgB,EAChB,mBAAmB,EAEpB,MAAM,yBAAyB,CAAC;AAkBjC,qBAAa,qBAAsB,YAAW,cAAc;IAE1D,OAAO,CAAC,cAAc;IAgBhB,KAAK,CAAC,EAAE,EAAE,OAAO,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,eAAe,GAAG,OAAO,CAAC,kBAAkB,CAAC;IA6B1F,MAAM,CACV,EAAE,EAAE,OAAO,EACX,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,gBAAgB,GACzC,OAAO,CAAC,mBAAmB,CAAC;CAoBhC"}

package/dist/wallet/service/wallet-commands.service.js

@@ -0,0 +1,68 @@
+import { and, eq, gte, sql } from 'drizzle-orm';
+import { wallet, walletTransaction } from '../schema/index.js';
+import { railFor } from './wallet.service.js';
+// Round a money amount to 2 decimal places, avoiding binary float drift on the running balance.
+function round2(n) {
+    return Math.round(n * 100) / 100;
+}
+// Default in-process WALLET_COMMANDS implementation. Operates on the caller's
+// transaction handle, so a move commits or rolls back together with the caller's
+// other writes - the same atomicity the cross-module schema-write gave, now behind
+// a port the wallet module owns. Every move writes a `wallet_transaction` ledger row
+// (status `completed`, internal settlement so no provider ref) so gameplay shows in
+// transaction history. The `balance >= amount` guard in the UPDATE makes concurrent
+// debits safe (a lost race updates zero rows and we report the shortfall).
+export class WalletCommandsService {
+    // Completed, internal-settlement ledger row (no provider ref) shared by every gameplay move.
+    writeLedgerRow(txn, row, type, amount) {
+        return txn.insert(walletTransaction).values({
+            walletId: row.id,
+            type,
+            amount: amount.toString(),
+            currency: row.currency,
+            status: 'completed',
+            rail: railFor(row.currency),
+        });
+    }
+    async debit(tx, { userId, amount, type }) {
+        const txn = tx;
+        // `loss` is informational (stake already left at bet time): 0-amount row, balance untouched. Every other debit is real money.
+        if (type !== 'loss' && amount <= 0) {
+            throw new Error(`wallet debit amount must be positive (got ${amount})`);
+        }
+        const [row] = await txn.select().from(wallet).where(eq(wallet.userId, userId));
+        if (!row)
+            return { ok: false, available: 0 };
+        const available = Number(row.balance);
+        if (type === 'loss') {
+            await this.writeLedgerRow(txn, row, 'loss', 0);
+            return { ok: true, newBalance: available };
+        }
+        const debited = await txn
+            .update(wallet)
+            .set({ balance: sql `${wallet.balance} - ${amount}` })
+            .where(and(eq(wallet.id, row.id), gte(wallet.balance, amount.toString())))
+            .returning({ id: wallet.id });
+        if (debited.length !== 1)
+            return { ok: false, available };
+        await this.writeLedgerRow(txn, row, type, amount);
+        return { ok: true, newBalance: round2(available - Number(amount)) };
+    }
+    async credit(tx, { userId, amount, type }) {
+        const txn = tx;
+        if (amount <= 0) {
+            throw new Error(`wallet credit amount must be positive (got ${amount})`);
+        }
+        const [row] = await txn.select().from(wallet).where(eq(wallet.userId, userId));
+        // Fail closed: a credit never creates a wallet - a missing one is a caller bug.
+        if (!row)
+            return { ok: false, reason: 'wallet not found' };
+        await txn
+            .update(wallet)
+            .set({ balance: sql `${wallet.balance} + ${amount}` })
+            .where(eq(wallet.id, row.id));
+        await this.writeLedgerRow(txn, row, type, Number(amount));
+        return { ok: true, newBalance: round2(Number(row.balance) + Number(amount)) };
+    }
+}
+//# sourceMappingURL=wallet-commands.service.js.map