@openora/core 0.4.0 → 0.4.1-canary.100

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

@@ -1,70 +1,570 @@
-import { type EventBus, DrizzleService } from '@openora/core/server';
-import { type PaymentAdapter, type AdminUserDirectory, type PlatformConfig, type RateLimiterAdapter, type WalletRail, type PlayerTags, type AuditWritePort } from '@openora/core/contracts';
-import type { TransactionResult, WithdrawalQueueFilter, AutoWithdrawalRule } from '../contract/index.js';
+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 AuditWritePort, type TagEvaluationCommands, type TagKey, type User, type IdentityReader, type ClientMeta, type Uuid, type PaginationOptions } 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;
 export declare const WithdrawalNotFoundError: new (id: string) => Error;
-export declare const InsufficientBalanceError: new (available: unknown, requested: unknown) => Error;
+export declare const AutoWithdrawalConfigNotFoundError: new (id: string) => Error;
+export declare const BonusRolloverConfigNotFoundError: new (id: string) => Error;
+export declare const PlayerNotFoundError: 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 CurrencyMismatchError: new (requested: unknown, walletCurrency: unknown) => Error;
-export declare function railFor(currency: string): WalletRail;
+export declare const DepositAddressUnsupportedError: new () => Error;
+export declare const DestinationAddressRequiredError: new () => Error;
+export declare const BonusRolloverLockedError: new (locked: string) => Error;
+export declare const DestinationAddressNotWhitelistedError: new () => Error;
+export declare const WalletAssetNotFoundError: new (id: string) => Error;
+export declare const WalletAssetAlreadyExistsError: new () => Error;
+export declare const WalletAssetUnsupportedError: new () => Error;
+export declare const WalletAssetInUseError: new () => Error;
+export declare const WalletAssetUnknownProviderError: new () => Error;
+export declare const WalletAssetHasInFlightTransactionsError: new () => Error;
+export declare const WithdrawalAddressAlreadyExistsError: new () => Error;
+export declare const WithdrawalAddressLimitReachedError: new (limit: number) => Error;
+export declare const AmbiguousNetworkError: new (currency: unknown, networks: unknown) => Error;
+export declare const UnsupportedNetworkError: new (currency: unknown, network: unknown) => Error;
+export declare const WithdrawalDisabledError: new (currency: unknown) => Error;
+export declare const BelowMinimumWithdrawalError: new (amount: unknown, minimum: unknown, currency: unknown, network: unknown) => Error;
+export declare const AmbiguousDepositAddressError: new (address: unknown, network: unknown) => Error;
+/** 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;
+export declare function 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 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">;
+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;
 };
+/**
+ * Owns all wallet balance mutations and the withdrawal review/auto-approval
+ * pipeline. Every balance change is a transactional, idempotent-keyed ledger
+ * write (never a bare balance update) - `amount` is always a decimal string,
+ * mutated via SQL numeric arithmetic, never a JS float. Domain events emit only
+ * AFTER the owning transaction commits, and only for the non-replay branch of
+ * an idempotent call.
+ */
 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);
+    constructor({ drizzle, events, payment, paymentProviders, directory, identityReader, platformConfig, limiter, riskTags, tagEvaluationCommands, audit, }: WalletServiceDeps);
+    private assetsForCurrency;
+    private resolveRail;
+    private providerNameFor;
     private rateLimit;
-    /** Fail-closed KYC gate: when enabled, a withdrawal needs a passing status (verified|manually_overridden). */
     private assertKycForWithdrawal;
-    getBalance(userId: string): Promise<{
-        balance: number;
+    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
+     * crediting the balance twice, and rejects if the same key is reused with a
+     * different amount/currency (`IdempotencyKeyReuseError`). A GENUINE
+     * concurrent race (two first-attempts, same key, landing at once) can both
+     * 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({ userId, amount, currency, provider, idempotencyKey, }: {
-        userId: string;
-        amount: number;
+        userId: User['id'];
+        amount: string;
         currency: string;
         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>;
     private findDepositReplay;
     private assertReplayMatches;
+    private assertManualAdjustmentReplayMatches;
     private insertIdempotentTransaction;
-    /** Creates a PENDING withdrawal and HOLDS the funds (balance debited at request time). Funds are returned on reject/PSP-failure. */
-    withdraw({ userId, amount, currency, idempotencyKey, }: {
-        userId: string;
-        amount: number;
+    /**
+     * Creates a PENDING withdrawal and HOLDS the funds immediately (balance
+     * debited at request time, not on approval) - funds are returned on
+     * reject/PSP-failure. The debit is a conditional `UPDATE ... WHERE balance
+     * >= amount`, atomic with the row lock (`FOR UPDATE`) taken on the wallet,
+     * so two concurrent withdrawals can't both pass a balance check and
+     * double-spend. `idempotencyKey` replay semantics mirror `deposit()`. May
+     * return an already-`completed`/`processing` result if the request
+     * qualifies for (and passes) auto-approval - see `maybeAutoApprove`.
+     */
+    withdraw({ userId, amount, currency, network, idempotencyKey, destinationAddress, ip, userAgent, }: {
+        userId: User['id'];
+        amount: string;
         currency: string;
+        network?: string;
         idempotencyKey?: string;
-    }): Promise<TransactionResult>;
+        destinationAddress?: string;
+    } & ClientMeta): Promise<TransactionResult>;
     listWithdrawals(filters: WithdrawalQueueFilter): Promise<{
         items: {
             transactionId: string;
             userId: string;
+            playerId: string | null;
             username: string;
-            amount: number;
+            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;
+            txHash: string | null;
         }[];
         total: number;
         page: number;
@@ -75,40 +575,115 @@ 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: string, withdrawalId: string): 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>;
     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;
     setAutoWithdrawalRule({ userId, threshold, reason, createdBy, }: {
-        userId: string;
-        threshold: number;
+        userId: User['id'];
+        threshold: string;
         reason: string;
         createdBy: string;
     }): Promise<AutoWithdrawalRule>;
-    getAutoWithdrawalRule(userId: string): Promise<AutoWithdrawalRule | null>;
-    deleteAutoWithdrawalRule(userId: string): Promise<boolean>;
-    rejectWithdrawal(adminId: string, withdrawalId: string, reason: string): Promise<TransactionResult>;
-    getTransactions(userId: string, page: number, limit: number): Promise<{
+    getAutoWithdrawalRule(userId: User['id']): Promise<AutoWithdrawalRule | null>;
+    deleteAutoWithdrawalRule(userId: User['id']): Promise<boolean>;
+    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";
-            amount: number;
+            type: "deposit" | "loss" | "withdrawal" | "bet" | "win" | "bonus" | "tip" | "gift" | "rain" | "manual_credit" | "manual_debit";
+            amount: string;
             currency: string;
+            network: string | null;
             status: "pending" | "rejected" | "processing" | "completed" | "failed" | "on_hold" | "cancelled";
             createdAt: string;
+            reviewedBy: string | null;
+            reviewedAt: string | null;
+            reviewReason: string | null;
         }[];
         total: number;
         page: number;
         limit: number;
     }>;
+    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';
+    }>, 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 an address 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.
+     */
+    private requireWhitelistedWalletId;
+    /**
+     * The approved destination saved for this address, or null. Matched on the address itself
+     * rather than an id on the transaction, because a withdrawal is requested by address and may
+     * name one the player never saved.
+     */
+    private whitelistedWalletId;
+    /**
+     * 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