@openora/core 0.4.1-canary.15 → 0.4.1-canary.150

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

@@ -1,26 +1,549 @@
-import { type EventBus, DrizzleService } from '@openora/core/server';
-import { type PaymentAdapter, type PaymentWebhookEvent, type AdminUserDirectory, type PlatformConfig, type RateLimiterAdapter, type WalletRail, type PlayerTags, type AuditWritePort, type User } from '@openora/core/contracts';
-import { type WalletTransaction } from '../schema/index.js';
-import type { TransactionResult, WithdrawalQueueFilter, AutoWithdrawalRule } from '../contract/index.js';
-export declare const WalletNotFoundError: new (id: string) => Error;
-export declare const WithdrawalNotFoundError: new (id: string) => Error;
-export declare const InsufficientBalanceError: new (available: string, requested: string) => Error;
-export declare const WithdrawalNotPendingError: new () => Error;
-export declare const KycRequiredError: new () => Error;
-export declare const IdempotencyKeyReuseError: new () => Error;
-export declare const DepositAddressUnsupportedError: new () => Error;
-export declare const DestinationAddressRequiredError: new () => Error;
-export declare const CurrencyMismatchError: new (requested: unknown, walletCurrency: unknown) => Error;
-export declare function railFor(currency: string): WalletRail;
+import { type EventBus, type DrizzleDb, DrizzleService } from '@openora/core/server';
+import { type PaymentAdapter, type PaymentProviderRegistry, type PaymentWebhookEvent, type AdminUserDirectory, type PlatformConfig, type RateLimiterAdapter, type RateLimitKey, type WalletRail, type PlayerTags, type RgLimitsPort, type ExchangeRateReader, type AuditWritePort, type TagEvaluationCommands, type TagKey, type User, type IdentityReader, type ClientMeta, type Uuid, type PaginationOptions, type WalletProviderRef } from '@openora/core/contracts';
+import { type Wallet, type WalletTransaction } from '../schema/index.js';
+import type { TransactionResult, WithdrawalQueueFilter, AutoWithdrawalRule, WalletAutoWithdrawalConfig, WalletTransactionSortBy, BonusCredit, BonusCreditStatus, BonusRolloverConfig, WalletAsset, PublicWalletAsset, CreateWalletAssetInput, UpdateWalletAssetInput, ManualAdjustmentDirection, WithdrawalAddress, CreateWithdrawalAddressInput } from '../contract/index.js';
+export declare const WalletNotFoundError: new (id: string) => Error & {
+    data?: Record<string, string>;
+};
+export declare const WithdrawalNotFoundError: new (id: string) => Error & {
+    data?: Record<string, string>;
+};
+export declare const AutoWithdrawalConfigNotFoundError: new (id: string) => Error & {
+    data?: Record<string, string>;
+};
+export declare const BonusRolloverConfigNotFoundError: new (id: string) => Error & {
+    data?: Record<string, string>;
+};
+export declare const PlayerNotFoundError: new (id: string) => Error & {
+    data?: Record<string, string>;
+};
+export declare const InsufficientBalanceError: new (available: string, requested: string) => Error & {
+    data?: Record<string, string>;
+};
+export declare const WithdrawalNotPendingError: new () => Error & {
+    data?: Record<string, string>;
+};
+export declare const KycRequiredError: new () => Error & {
+    data?: Record<string, string>;
+};
+export declare const IdempotencyKeyReuseError: new () => Error & {
+    data?: Record<string, string>;
+};
+export declare const DepositAddressUnsupportedError: new () => Error & {
+    data?: Record<string, string>;
+};
+export declare const DestinationAddressRequiredError: new () => Error & {
+    data?: Record<string, string>;
+};
+export declare const BonusRolloverLockedError: new (locked: string) => Error & {
+    data?: Record<string, string>;
+};
+export declare const DestinationAddressNotWhitelistedError: new () => Error & {
+    data?: Record<string, string>;
+};
+export declare const WalletAssetNotFoundError: new (id: string) => Error & {
+    data?: Record<string, string>;
+};
+export declare const WalletAssetAlreadyExistsError: new () => Error & {
+    data?: Record<string, string>;
+};
+export declare const WalletAssetUnsupportedError: new () => Error & {
+    data?: Record<string, string>;
+};
+export declare const WalletAssetInUseError: new () => Error & {
+    data?: Record<string, string>;
+};
+export declare const WalletAssetHasIssuedAddressesError: new () => Error & {
+    data?: Record<string, string>;
+};
+export declare const WalletAssetUnknownProviderError: new () => Error & {
+    data?: Record<string, string>;
+};
+export declare const WalletAssetHasInFlightTransactionsError: new () => Error & {
+    data?: Record<string, string>;
+};
+export declare const WithdrawalAddressAlreadyExistsError: new () => Error & {
+    data?: Record<string, string>;
+};
+export declare const WithdrawalAddressLimitReachedError: new (limit: number) => Error & {
+    data?: Record<string, string>;
+};
+export declare const AmbiguousNetworkError: new (currency: unknown, networks: unknown) => Error & {
+    data?: Record<string, string>;
+};
+export declare const UnsupportedNetworkError: new (currency: unknown, network: unknown) => Error & {
+    data?: Record<string, string>;
+};
+export declare const WithdrawalDisabledError: new (currency: unknown) => Error & {
+    data?: Record<string, string>;
+};
+export declare const BelowMinimumWithdrawalError: new (amount: unknown, minimum: unknown, currency: unknown, network: unknown) => Error & {
+    data?: Record<string, string>;
+};
+export declare const DepositDisabledError: new (currency: unknown, network: unknown) => Error & {
+    data?: Record<string, string>;
+};
+export declare const BelowMinimumDepositError: new (amount: unknown, minimum: unknown, currency: unknown, network: unknown) => Error & {
+    data?: Record<string, string>;
+};
+export declare const AmbiguousDepositAddressError: new (address: unknown, network: unknown) => Error & {
+    data?: Record<string, string>;
+};
+export declare const DEFAULT_WALLET_CURRENCY = "USD";
+/** The catalog fields a payout decision needs - a structural subset of a wallet_asset row. */
+type WithdrawalAsset = {
+    network: string;
+    minWithdrawal: string;
+    withdrawalEnabled: boolean;
+};
+/**
+ * Pins the chain a payout settles on. With one payable network the choice is implied; with
+ * several an explicit network is mandatory, because picking one silently would send a
+ * player's USDT over a chain their receiving wallet may not support.
+ *
+ * `assets` is every catalog row for the currency, enabled or not, so the two empty cases
+ * stay distinguishable: no rows at all means the operator never configured this currency
+ * (a fiat PSP), and the caller's choice passes through unchecked; rows that are all
+ * withdrawal-disabled is a deliberate operator decision and fails closed.
+ */
+export declare function resolveWithdrawalNetwork(assets: readonly WithdrawalAsset[], currency: string, network?: string): string | null;
+/**
+ * Rejects a payout worth less than the operator's per-network floor. The floor is per chain,
+ * not per currency: moving USDT costs cents on BEP20 and dollars on ERC20, so one
+ * currency-wide minimum is either too high for the cheap chain or below the fee on the
+ * expensive one.
+ */
+export declare function assertAboveMinimumWithdrawal(assets: readonly WithdrawalAsset[], amount: string, currency: string, network: string | null): void;
+type DepositAsset = {
+    network: string;
+    minDeposit: string;
+    depositEnabled: boolean;
+};
+export declare function assertDepositAllowed(assets: readonly DepositAsset[], currency: string, network?: string): void;
+export declare function assertAboveMinimumDeposit(assets: readonly DepositAsset[], amount: string, currency: string, network?: string): void;
+export declare const railFor: (currency: string, cryptoCurrencies?: readonly string[]) => WalletRail;
+export declare const balanceKey: (currency: string) => string;
+export declare function creditWalletBalance(txn: DrizzleDb, walletId: Wallet['id'], currency: string, amount: string): Omit<import("drizzle-orm/pg-core").PgInsertBase<import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "wallet_balance";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "wallet_balance";
+            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_balance";
+            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;
+        }, {}, {}>;
+        currency: import("drizzle-orm/pg-core").PgColumn<{
+            name: "currency";
+            tableName: "wallet_balance";
+            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;
+        }, {}, {}>;
+        amount: import("drizzle-orm/pg-core").PgColumn<{
+            name: "amount";
+            tableName: "wallet_balance";
+            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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "createdAt";
+            tableName: "wallet_balance";
+            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: "wallet_balance";
+            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";
+}>, import("drizzle-orm/node-postgres").NodePgQueryResultHKT, {
+    amount: import("drizzle-orm/pg-core").PgColumn<{
+        name: "amount";
+        tableName: "wallet_balance";
+        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;
+    }, {}, {}>;
+}, {
+    amount: string;
+}, false, "onConflictDoNothing" | "onConflictDoUpdate" | "returning">, "onConflictDoNothing" | "onConflictDoUpdate" | "returning">;
+export declare function debitWalletBalance(txn: DrizzleDb, walletId: Wallet['id'], currency: string, amount: string): Omit<import("drizzle-orm/pg-core").PgUpdateBase<import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "wallet_balance";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "wallet_balance";
+            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_balance";
+            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;
+        }, {}, {}>;
+        currency: import("drizzle-orm/pg-core").PgColumn<{
+            name: "currency";
+            tableName: "wallet_balance";
+            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;
+        }, {}, {}>;
+        amount: import("drizzle-orm/pg-core").PgColumn<{
+            name: "amount";
+            tableName: "wallet_balance";
+            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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "createdAt";
+            tableName: "wallet_balance";
+            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: "wallet_balance";
+            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";
+}>, import("drizzle-orm/node-postgres").NodePgQueryResultHKT, undefined, {
+    amount: import("drizzle-orm/pg-core").PgColumn<{
+        name: "amount";
+        tableName: "wallet_balance";
+        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;
+    }, {}, {}>;
+}, {
+    amount: string;
+}, Record<"wallet_balance", "not-null">, [], false, "returning" | "where" | "leftJoin" | "rightJoin" | "innerJoin" | "fullJoin">, "returning" | "where" | "leftJoin" | "rightJoin" | "innerJoin" | "fullJoin">;
+export declare function readWalletBalance(txn: DrizzleDb, walletId: Wallet['id'], currency: string): Promise<string>;
+export declare function readWalletBalances(txn: DrizzleDb, userId: User['id']): Promise<{
+    activeCurrency: string;
+    balances: {
+        currency: string;
+        balance: string;
+    }[];
+}>;
+export declare function resolveWalletBalance(txn: DrizzleDb, userId: User['id']): Promise<{
+    balance: string;
+    currency: string;
+}>;
+export declare function providerRefCondition(providerName: string, providerRefId: WalletProviderRef['providerRefId']): import("drizzle-orm").SQL<unknown> | undefined;
+export declare function debitWithdrawableBalance(txn: DrizzleDb, walletId: Wallet['id'], currency: string, amount: string): Omit<import("drizzle-orm/pg-core").PgUpdateBase<import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "wallet_balance";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "wallet_balance";
+            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_balance";
+            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;
+        }, {}, {}>;
+        currency: import("drizzle-orm/pg-core").PgColumn<{
+            name: "currency";
+            tableName: "wallet_balance";
+            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;
+        }, {}, {}>;
+        amount: import("drizzle-orm/pg-core").PgColumn<{
+            name: "amount";
+            tableName: "wallet_balance";
+            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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "createdAt";
+            tableName: "wallet_balance";
+            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: "wallet_balance";
+            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";
+}>, import("drizzle-orm/node-postgres").NodePgQueryResultHKT, undefined, {
+    amount: import("drizzle-orm/pg-core").PgColumn<{
+        name: "amount";
+        tableName: "wallet_balance";
+        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;
+    }, {}, {}>;
+}, {
+    amount: string;
+}, Record<"wallet_balance", "not-null">, [], false, "returning" | "where" | "leftJoin" | "rightJoin" | "innerJoin" | "fullJoin">, "returning" | "where" | "leftJoin" | "rightJoin" | "innerJoin" | "fullJoin">;
+export declare function readLockedBonusAmount(txn: DrizzleDb, walletId: Wallet['id'], currency: string): Promise<string>;
+type DepositAddressResult = {
+    address: string;
+    currency: string;
+    network?: string;
+    tag?: string;
+};
 export type WalletServiceDeps = {
     drizzle: DrizzleService;
     events: EventBus;
     payment: PaymentAdapter;
+    paymentProviders: PaymentProviderRegistry;
+    identityReader: IdentityReader;
     directory?: AdminUserDirectory;
     platformConfig?: PlatformConfig;
-    limiter?: RateLimiterAdapter;
+    limiter?: RateLimiterAdapter<RateLimitKey>;
     riskTags?: PlayerTags;
+    tagEvaluationCommands?: TagEvaluationCommands;
     audit: AuditWritePort;
+    rgLimits?: RgLimitsPort;
+    rates?: ExchangeRateReader;
 };
 /**
  * Owns all wallet balance mutations and the withdrawal review/auto-approval
@@ -34,19 +557,46 @@ export declare class WalletService {
     private readonly drizzle;
     private readonly events;
     private readonly payment;
+    private readonly paymentProviders;
+    private readonly identityReader;
     private readonly directory?;
     private readonly platformConfig?;
     private readonly limiter?;
     private readonly riskTags?;
+    private readonly tagEvaluationCommands?;
     private readonly audit;
-    constructor({ drizzle, events, payment, directory, platformConfig, limiter, riskTags, audit, }: WalletServiceDeps);
+    private readonly rgLimits?;
+    private readonly rates?;
+    constructor({ drizzle, events, payment, paymentProviders, directory, identityReader, platformConfig, limiter, riskTags, tagEvaluationCommands, audit, rgLimits, rates, }: WalletServiceDeps);
+    private assetsForCurrency;
+    private depositAssetsForCurrency;
+    /**
+     * `network` is optional because not every deposit path knows one: `deposit()` takes a
+     * PSP amount and currency only, so it is gated currency-wide (any enabled network
+     * clears it). Per-network gating applies where a network is actually chosen, ie
+     * `getOrCreateDepositAddress`, which is the path that hands a player a chain address.
+     */
+    private assertDepositable;
+    private assertWithinRgDepositLimit;
+    private resolveRail;
+    private providerNameFor;
+    private paymentAdapterFor;
     private rateLimit;
-    /** Fail-closed KYC gate: when enabled, a withdrawal needs a passing status (verified|manually_overridden). */
     private assertKycForWithdrawal;
     getBalance(userId: User['id']): Promise<{
         balance: string;
         currency: string;
     }>;
+    getBalances(userId: User['id']): Promise<{
+        activeCurrency: string;
+        balances: {
+            currency: string;
+            balance: string;
+        }[];
+    }>;
+    setActiveCurrency(userId: User['id'], currency: string): Promise<{
+        activeCurrency: string;
+    }>;
     /**
      * `idempotencyKey` (when supplied) makes a retried deposit a no-op: a replay
      * returns the original committed result WITHOUT calling the PSP again or
@@ -56,6 +606,12 @@ export declare class WalletService {
      * reach the PSP, but the ledger insert's unique-index conflict still
      * guarantees only one balance credit - the loser's write becomes a replay
      * read of the winner's row.
+     *
+     * Deposit gating is network-aware when a network is known (e.g. via
+     * `getOrCreateDepositAddress`), but here we gate on "any network for this
+     * currency is enabled" because `provider` routing may resolve a specific
+     * network inside `processDeposit`. A fiat PSP (no networks) passes through
+     * unchecked; an explicit network route checks that specific network only.
      */
     deposit({ userId, amount, currency, provider, idempotencyKey, }: {
         userId: User['id'];
@@ -64,8 +620,24 @@ export declare class WalletService {
         provider?: string;
         idempotencyKey?: string;
     }): Promise<TransactionResult>;
+    manualAdjust({ adminId, userId, direction, amount, currency, reason, idempotencyKey, ip, userAgent, }: {
+        adminId: User['id'];
+        userId: User['id'];
+        direction: ManualAdjustmentDirection;
+        amount: string;
+        currency: string;
+        reason: string;
+        idempotencyKey: string;
+    } & ClientMeta): Promise<TransactionResult>;
+    /**
+     * Frees a reservation the PSP never charged. Failure to release only leaves the player's
+     * own headroom held until the row is reconciled, so it is logged rather than raised over
+     * the PSP error that caused it.
+     */
+    private releaseDepositReservation;
     private findDepositReplay;
     private assertReplayMatches;
+    private assertManualAdjustmentReplayMatches;
     private insertIdempotentTransaction;
     /**
      * Creates a PENDING withdrawal and HOLDS the funds immediately (balance
@@ -77,26 +649,31 @@ export declare class WalletService {
      * return an already-`completed`/`processing` result if the request
      * qualifies for (and passes) auto-approval - see `maybeAutoApprove`.
      */
-    withdraw({ userId, amount, currency, idempotencyKey, destinationAddress, }: {
+    withdraw({ userId, amount, currency, network, idempotencyKey, destinationAddress, destinationTag, ip, userAgent, }: {
         userId: User['id'];
         amount: string;
         currency: string;
+        network?: string;
         idempotencyKey?: string;
         destinationAddress?: string;
-    }): Promise<TransactionResult>;
+        destinationTag?: string;
+    } & ClientMeta): Promise<TransactionResult>;
     listWithdrawals(filters: WithdrawalQueueFilter): Promise<{
         items: {
             transactionId: string;
             userId: string;
+            playerId: string | null;
             username: string;
             amount: string;
             currency: string;
+            network: string | null;
             rail: "crypto" | "fiat" | null;
             status: "pending" | "rejected" | "processing" | "completed" | "failed" | "on_hold" | "cancelled";
-            kycStatus: "pending" | "not_started" | "verified" | "rejected" | "resubmission_requested" | "manually_overridden" | null;
+            kycStatus: "pending" | "not_started" | "approved" | "verified" | "rejected" | "resubmission_requested" | "manually_overridden" | null;
             riskTags: string[];
             requestedAt: string;
             destinationAddress: string | null;
+            destinationTag: string | null;
             txHash: string | null;
         }[];
         total: number;
@@ -108,21 +685,45 @@ export declare class WalletService {
      * or Failed + refund on PSP error. Robust PSP idempotency-key/reconciliation for a
      * lost-response is deferred - same scope boundary the deposit path declares.
      */
-    approveWithdrawal(adminId: User['id'], withdrawalId: WalletTransaction['id']): Promise<TransactionResult>;
+    approveWithdrawal(adminId: User['id'], withdrawalId: WalletTransaction['id'], meta?: ClientMeta): Promise<TransactionResult>;
     private flipToProcessing;
     private settleApproved;
     private finalizeFailedWithdrawal;
     reconcileWithdrawalStatus(event: Extract<PaymentWebhookEvent, {
         kind: 'withdrawal';
-    }>): Promise<void>;
+    }>, providerName?: string): Promise<void>;
     private maybeAutoApprove;
     private evaluateAutoApproval;
     private resolveAutoThreshold;
+    getAutoWithdrawalConfig(): Promise<WalletAutoWithdrawalConfig>;
+    getAutoWithdrawalConfigOrNull(): Promise<WalletAutoWithdrawalConfig | null>;
+    setAutoWithdrawalConfig(adminId: User['id'], { fiatThreshold, cryptoThreshold, excludeRiskFlags, }: {
+        fiatThreshold: string;
+        cryptoThreshold: string;
+        excludeRiskFlags: TagKey[];
+    }, meta?: ClientMeta): Promise<WalletAutoWithdrawalConfig>;
+    getBonusRolloverStatus(userId: User['id'], status?: BonusCreditStatus): Promise<{
+        credits: BonusCredit[];
+    }>;
+    getBonusRolloverConfig(): Promise<BonusRolloverConfig>;
+    getBonusRolloverConfigOrNull(): Promise<BonusRolloverConfig | null>;
+    setBonusRolloverConfig(adminId: User['id'], { multiplier }: {
+        multiplier: string;
+    }, meta?: ClientMeta): Promise<BonusRolloverConfig>;
+    listWalletAssets(): Promise<WalletAsset[]>;
+    listEnabledWalletAssets(): Promise<PublicWalletAsset[]>;
+    getWalletAsset(currency: string, network: string): Promise<WalletAsset | null>;
+    private assertAdapterSupports;
+    private assertProviderNameValid;
+    createWalletAsset(adminId: User['id'], input: CreateWalletAssetInput, meta?: ClientMeta): Promise<WalletAsset>;
+    updateWalletAsset(adminId: User['id'], { currency, network, ...changes }: UpdateWalletAssetInput, meta?: ClientMeta): Promise<WalletAsset>;
+    deleteWalletAsset(adminId: User['id'], currency: string, network: string, meta?: ClientMeta): Promise<boolean>;
     private autoApprovalKycStatus;
     private autoApprovalRiskTags;
     private autoApprovalHeuristics;
     private frequentWithdrawalWalletIds;
     private autoApprovalCaps;
+    private toPivotAmount;
     setAutoWithdrawalRule({ userId, threshold, reason, createdBy, }: {
         userId: User['id'];
         threshold: string;
@@ -131,30 +732,78 @@ export declare class WalletService {
     }): Promise<AutoWithdrawalRule>;
     getAutoWithdrawalRule(userId: User['id']): Promise<AutoWithdrawalRule | null>;
     deleteAutoWithdrawalRule(userId: User['id']): Promise<boolean>;
-    rejectWithdrawal(adminId: User['id'], withdrawalId: WalletTransaction['id'], reason: string): Promise<TransactionResult>;
-    getTransactions(userId: User['id'], page: number, limit: number): Promise<{
+    rejectWithdrawal(adminId: User['id'], withdrawalId: WalletTransaction['id'], reason: string, meta?: ClientMeta): Promise<TransactionResult>;
+    getTransactions({ userId, page, limit, sortBy, sortOrder, includeInternal, }: PaginationOptions<{
+        userId: User['id'];
+        includeInternal?: boolean;
+    }, WalletTransactionSortBy>): Promise<{
         items: {
             id: string;
-            type: "deposit" | "loss" | "withdrawal" | "bet" | "win" | "bonus" | "tip";
+            type: "withdrawal" | "bonus" | "deposit" | "loss" | "bet" | "win" | "tip" | "gift" | "rain" | "manual_credit" | "manual_debit" | "swap_out" | "swap_in" | "bet_reversal";
             amount: string;
             currency: string;
+            network: string | null;
             status: "pending" | "rejected" | "processing" | "completed" | "failed" | "on_hold" | "cancelled";
+            direction: "credit" | "debit" | null;
             createdAt: string;
+            reviewedBy: string | null;
+            reviewedAt: string | null;
+            reviewReason: string | null;
         }[];
         total: number;
         page: number;
         limit: number;
     }>;
-    getOrCreateDepositAddress(userId: User['id'], currency: string): Promise<{
-        address: string;
-        currency: string;
-    }>;
+    getOrCreateDepositAddress(userId: User['id'], currency: string, network?: string): Promise<DepositAddressResult>;
+    /**
+     * `providerName` is the vendor the webhook route already resolved (verifier + adapter
+     * came from the same registry entry) - it is only used to label a finding when this
+     * deposit can't be attributed, never to look anything up. Defaults to the single
+     * default binding for callers (tests, a poller with no named provider) that don't care.
+     */
     creditDepositByAddress(event: Extract<PaymentWebhookEvent, {
         kind: 'deposit';
-    }>): Promise<void>;
+    }>, providerName?: string): Promise<void>;
     private userIdForWallet;
     private findByIdempotencyKey;
     private findDepositAddress;
     private findDepositAddressByAddress;
+    /**
+     * The player's own payout address book. Every method here is scoped on `userId` - a
+     * saved address is personal data with no admin read path, so there is
+     * deliberately no variant of these that takes an arbitrary user id.
+     */
+    listWithdrawalAddresses(userId: Uuid, currency?: string): Promise<WithdrawalAddress[]>;
+    createWithdrawalAddress(userId: Uuid, input: CreateWithdrawalAddressInput, meta?: Partial<ClientMeta>): Promise<WithdrawalAddress>;
+    /**
+     * Refuses a payout to a destination the provider has not approved. A no-op for an adapter that
+     * does not whitelist, and for a fiat rail, which has no address at all.
+     *
+     * The tag is matched as strictly as the address. On a tag chain one exchange address is shared
+     * by every account behind it, so an address-only check would let a player whitelist their own
+     * account at that exchange and then pay out to a stranger's tag at the same address - an
+     * auto-approved withdrawal would do it with nobody looking.
+     */
+    private requireWhitelistedWalletId;
+    /**
+     * The approved destination saved for this (address, tag) pair, or null. Matched on the pair
+     * itself rather than an id on the transaction, because a withdrawal is requested by address
+     * and may name one the player never saved. An absent tag matches only a row saved without
+     * one: a tagged payout against an untagged whitelist row is a different beneficiary.
+     */
+    private whitelistedWalletId;
+    /** Frees a reserved slot the vendor refused. Idempotent: a row already gone is a no-op. */
+    private releaseWithdrawalAddressSlot;
+    /**
+     * Delegates to the bound payment adapter when it whitelists destinations, and returns nothing
+     * to store when it does not. A vendor failure propagates rather than being swallowed: saving
+     * the address anyway would produce a row that looks usable and fails only once the player has
+     * committed to a payout.
+     */
+    private whitelistWithdrawalAddress;
+    /** False when the row does not exist OR belongs to someone else - the caller cannot
+     * tell the two apart, which is what stops the id space being probed. */
+    deleteWithdrawalAddress(userId: Uuid, id: WithdrawalAddress['id'], meta?: Partial<ClientMeta>): Promise<boolean>;
 }
+export {};
 //# sourceMappingURL=wallet.service.d.ts.map