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

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/wallet/contract/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,EAKL,gBAAgB,EAChB,6BAA6B,EAC7B,2BAA2B,EAC5B,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAAE,gBAAgB,EAAE,6BAA6B,EAAE,2BAA2B,EAAE,CAAC;AASxF,eAAO,MAAM,mBAAmB;;;iBAG9B,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;iBAOlC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;iBAK7B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;iBAM9B,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;iBAGlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,eAAO,MAAM,0BAA0B;;;;iBAErC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAapC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAStC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,eAAO,MAAM,wBAAwB;;;;;;;;iBAQnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,eAAO,MAAM,gCAAgC;;;;iBAI3C,CAAC;AAEH,eAAO,MAAM,2BAA2B;;iBAAmC,CAAC;AAE5E,eAAO,MAAM,4BAA4B;;iBAAyC,CAAC;AAEnF,eAAO,MAAM,2BAA2B;;;iBAGtC,CAAC;AAEH,eAAO,MAAM,yBAAyB,wCAAoC,CAAC;AAC3E,eAAO,MAAM,0BAA0B;;iBAAoC,CAAC;AAE5E,eAAO,MAAM,yBAAyB;;iBAAmD,CAAC;AAC1F,eAAO,MAAM,oBAAoB;;;iBAG/B,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoE1B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/wallet/contract/index.ts"],"names":[],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmO1B,CAAC"}

package/dist/wallet/contract/index.js

@@ -1,68 +1,195 @@
-import { oc } from '@orpc/contract';
+import { eventIterator, oc } from '@orpc/contract';
 import * as z from 'zod';
-import { KycStatusSchema, MoneyAmountSchema, TimestampSchema, UuidSchema, WalletRailSchema, WalletTransactionStatusSchema, WalletTransactionTypeSchema, } from '@openora/core/contracts';
-import { PageQuerySchema, paginated } from '@openora/core/contracts/kit';
-export { WalletRailSchema, WalletTransactionStatusSchema, WalletTransactionTypeSchema };
+import { CurrencyTickerInputSchema, CurrencyTickerSchema, KycStatusSchema, MoneyAmountSchema, MONEY_PRECISION, MONEY_SCALE, TagKeySchema, TimestampSchema, UuidSchema, WalletRailSchema, WalletTransactionStatusSchema, WalletTransactionTypeSchema, WalletReconciliationFindingKindSchema, WalletReconciliationFindingStatusSchema, } from '@openora/core/contracts';
+import { PageQuerySchema, SortOrderSchema, paginated } from '@openora/core/contracts/kit';
+export { WalletRailSchema, WalletTransactionStatusSchema, WalletTransactionTypeSchema, WalletReconciliationFindingKindSchema, WalletReconciliationFindingStatusSchema, };
 // Deposit/withdraw amounts must be strictly positive; balances/thresholds may be zero.
 const PositiveMoneyAmountSchema = MoneyAmountSchema.refine((v) => Number(v) > 0, {
     message: 'must be greater than zero',
 });
-const WalletCurrencyCodeSchema = z.string().min(1);
+const WalletCurrencyCodeSchema = CurrencyTickerSchema;
+const WalletCurrencyInputSchema = CurrencyTickerInputSchema;
+// A currency does not identify a chain: USDT settles on ERC20, TRC20 and BEP20 with
+// different addresses, fees and minimums. Free-form rather than an enum because each
+// vendor spells chains its own way (ERC20 vs ETHEREUM vs eth-mainnet).
+const WalletNetworkSchema = z.string().trim().min(1).max(32);
+const WalletNetworkInputSchema = WalletNetworkSchema.transform((n) => n.toUpperCase());
+// One shape for both the saved address and the payout target: the whitelist check matches
+// them with an exact string equality, so an untrimmed paste on either side would look like
+// an address the player never saved. Deliberately no case transform - base58 rails (BTC
+// legacy, TRC20, Solana) are case-sensitive, so lowercasing would corrupt the address.
+const WalletAddressInputSchema = z.string().trim().min(8).max(128);
+const BASE58_LEGACY = '[a-km-zA-HJ-NP-Z1-9]{25,39}';
+const ADDRESS_PATTERN_BY_NETWORK = {
+    SEGWIT: new RegExp(`^((bc1|tb1|bcrt1)[a-z0-9]{25,87}|[13mn2]${BASE58_LEGACY})$`),
+    BITCOIN_CASH: new RegExp(`^((bitcoincash:|bchtest:)?[qp][a-z0-9]{41}|[13mn2]${BASE58_LEGACY})$`),
+    LITECOIN: new RegExp(`^((ltc1|tltc1)[a-z0-9]{25,87}|[LM3Qmn2]${BASE58_LEGACY})$`),
+    DOGECOIN: new RegExp(`^[DA9nm2][a-km-zA-HJ-NP-Z1-9]{25,39}$`),
+    XRP_LEDGER: /^r[1-9A-HJ-NP-Za-km-z]{24,34}$/,
+    ERC20: /^0x[a-fA-F0-9]{40}$/,
+    BEP20: /^0x[a-fA-F0-9]{40}$/,
+    TRC20: /^T[1-9A-HJ-NP-Za-km-z]{33}$/,
+    SOLANA: /^[1-9A-HJ-NP-Za-km-z]{32,44}$/,
+};
+/**
+ * Format check for a payout destination, per chain, looked up by `network.toUpperCase()`.
+ * A network with no entry in the table is ACCEPTED, falling back to the shared length
+ * bound (8-128 chars trimmed) instead of being rejected.
+ */
+export function isWalletAddressValidForNetwork(address, network) {
+    const pattern = ADDRESS_PATTERN_BY_NETWORK[network.toUpperCase()];
+    if (!pattern) {
+        return address.length >= 8 && address.length <= 128;
+    }
+    return pattern.test(address);
+}
 export const WalletBalanceSchema = z.object({
     balance: MoneyAmountSchema,
     currency: WalletCurrencyCodeSchema,
 });
+export const WalletBalancesSchema = z.object({
+    activeCurrency: WalletCurrencyCodeSchema,
+    balances: z.array(WalletBalanceSchema),
+});
+// A change *signal*, never the balance itself: carrying `{ currency, balance }` on the
+// stream would make the stream a money surface - a dropped or reordered event leaves a
+// stale number on screen with no self-correction. This shape only tells the client WHAT
+// changed; the client re-fetches getBalance(s)/listTransactions, which is cheap and
+// always internally consistent.
+export const WalletBalanceChangeReasonSchema = z.enum([
+    'deposit',
+    'withdrawal',
+    'adjustment',
+    'swap',
+]);
+export const WalletBalanceUpdateSchema = z.object({
+    eventId: UuidSchema,
+    currency: WalletCurrencyCodeSchema,
+    reason: WalletBalanceChangeReasonSchema,
+});
+export const SetActiveCurrencyInputSchema = z.object({ currency: WalletCurrencyCodeSchema });
+export const ActiveCurrencySchema = z.object({ activeCurrency: WalletCurrencyCodeSchema });
+// Shared by a manual adjustment's input direction and a transaction row's recorded
+// direction - a wallet move only ever goes one of these two ways.
+export const MANUAL_ADJUSTMENT_DIRECTIONS = ['credit', 'debit'];
+export const ManualAdjustmentDirectionSchema = z.enum(MANUAL_ADJUSTMENT_DIRECTIONS);
 export const WalletTransactionSchema = z.object({
     id: UuidSchema,
     type: WalletTransactionTypeSchema,
     amount: MoneyAmountSchema,
     currency: WalletCurrencyCodeSchema,
+    network: WalletNetworkSchema.nullable(),
     status: WalletTransactionStatusSchema,
+    // Which way this leg moved money - derived server-side from what the operation IS,
+    // never a caller input. Nullable: rows written before this column existed (and any
+    // row whose `type` never carried a recoverable direction, eg a pre-migration gift/
+    // rain/tip leg) have no direction on record.
+    direction: ManualAdjustmentDirectionSchema.nullable(),
     createdAt: TimestampSchema,
+    reviewReason: z.string().nullable(),
+});
+export const AdminWalletTransactionSchema = WalletTransactionSchema.extend({
+    reviewedBy: UuidSchema.nullable(),
+    reviewedAt: TimestampSchema.nullable(),
 });
 export const DepositInputSchema = z.object({
     amount: PositiveMoneyAmountSchema,
-    currency: WalletCurrencyCodeSchema,
+    currency: WalletCurrencyInputSchema,
     provider: z.string().optional(),
-    idempotencyKey: UuidSchema.optional(),
+    idempotencyKey: UuidSchema,
 });
-export const WithdrawInputSchema = z.object({
+// Bounded but otherwise unvalidated, like the address: each tag chain has its own format (an
+// XRP tag is a uint32, an XLM memo can be text or a hash), and the bound adapter is the only
+// thing that knows which. Tightening this here would break every chain but the one it was
+// tightened for; the adapter rejects a malformed tag at payout time.
+export const DestinationTagInputSchema = z.string().trim().min(1).max(64);
+export const WithdrawInputSchema = z
+    .object({
     amount: PositiveMoneyAmountSchema,
-    currency: WalletCurrencyCodeSchema,
+    currency: WalletCurrencyInputSchema,
+    network: WalletNetworkInputSchema.optional(),
     provider: z.string().optional(),
-    idempotencyKey: UuidSchema.optional(),
-    destinationAddress: z.string().optional(),
+    idempotencyKey: UuidSchema,
+    destinationAddress: WalletAddressInputSchema.optional(),
+    destinationTag: DestinationTagInputSchema.optional(),
+})
+    .superRefine((data, ctx) => {
+    if (data.network &&
+        data.destinationAddress &&
+        !isWalletAddressValidForNetwork(data.destinationAddress, data.network)) {
+        ctx.addIssue({
+            code: 'custom',
+            message: `not a valid ${data.network} address`,
+            path: ['destinationAddress'],
+        });
+    }
+});
+export const ManualWalletAdjustmentInputSchema = z.object({
+    userId: UuidSchema,
+    direction: ManualAdjustmentDirectionSchema,
+    currency: WalletCurrencyInputSchema,
+    amount: PositiveMoneyAmountSchema,
+    reason: z.string().trim().min(1),
+    idempotencyKey: UuidSchema,
 });
 export const TransactionResultSchema = z.object({
     transactionId: UuidSchema,
     status: WalletTransactionStatusSchema,
 });
+export const WALLET_TX_SORT_BY_VALUES = [
+    'createdAt',
+    'amount',
+    'type',
+    'status',
+    'currency',
+    'rail',
+    'reviewedAt',
+];
+export const WalletTransactionSortBySchema = z.enum(WALLET_TX_SORT_BY_VALUES).default('createdAt');
+export const WITHDRAWAL_SORT_BY_VALUES = [
+    'createdAt',
+    'amount',
+    'status',
+    'currency',
+    'rail',
+    'reviewedAt',
+];
+export const WithdrawalSortBySchema = z.enum(WITHDRAWAL_SORT_BY_VALUES).default('createdAt');
 export const ListPlayerTransactionsArgs = PageQuerySchema.extend({
     userId: UuidSchema,
+    sortBy: WalletTransactionSortBySchema.optional(),
+    sortOrder: SortOrderSchema.default('desc').optional(),
 });
 export const WithdrawalQueueItemSchema = z.object({
     transactionId: UuidSchema,
     userId: UuidSchema,
+    playerId: UuidSchema.nullable(),
     username: z.string(),
     amount: MoneyAmountSchema,
     currency: WalletCurrencyCodeSchema,
+    network: WalletNetworkSchema.nullable(),
     rail: WalletRailSchema.nullable(),
     status: WalletTransactionStatusSchema,
     kycStatus: KycStatusSchema.nullable(),
     riskTags: z.array(z.string()),
     requestedAt: TimestampSchema,
     destinationAddress: z.string().nullable(),
+    // An approver on a tag chain is releasing funds to an address shared by many accounts, so
+    // the tag is part of what they are approving, not a detail behind it.
+    destinationTag: z.string().nullable(),
     txHash: z.string().nullable(),
 });
 export const WithdrawalQueueFilterSchema = PageQuerySchema.extend({
     status: WalletTransactionStatusSchema.optional(),
-    currency: WalletCurrencyCodeSchema.optional(),
+    currency: WalletCurrencyInputSchema.optional(),
     rail: WalletRailSchema.optional(),
     minAmount: MoneyAmountSchema.optional(),
     maxAmount: MoneyAmountSchema.optional(),
     kycStatus: KycStatusSchema.optional(),
     dateFrom: TimestampSchema.optional(),
     dateTo: TimestampSchema.optional(),
+    sortBy: WithdrawalSortBySchema.optional(),
+    sortOrder: SortOrderSchema.default('desc').optional(),
 });
 export const AutoWithdrawalRuleSchema = z.object({
     id: UuidSchema,
@@ -79,20 +206,267 @@ export const SetAutoWithdrawalRuleInputSchema = z.object({
     reason: z.string().min(1),
 });
 export const AutoWithdrawalRuleKeySchema = z.object({ userId: UuidSchema });
+export const WalletAutoWithdrawalConfigSchema = z.object({
+    id: UuidSchema,
+    fiatThreshold: MoneyAmountSchema,
+    cryptoThreshold: MoneyAmountSchema,
+    excludeRiskFlags: z.array(TagKeySchema),
+    updatedBy: UuidSchema.nullable(),
+    updatedAt: TimestampSchema,
+    createdAt: TimestampSchema,
+});
+// wallet_auto_withdrawal_config.{fiatThreshold,cryptoThreshold} are decimal(18,8) - 10
+// integer digits max. Bounded here (not in the shared MoneyAmountSchema, which also backs
+// decimal(18,2) columns with a different integer-digit budget) so an out-of-range value is
+// a 4xx at the contract boundary instead of a DB overflow 500.
+const WalletAutoWithdrawalThresholdSchema = MoneyAmountSchema.refine((v) => (v.split('.').at(0) ?? '').length <= 10, { message: 'must have at most 10 integer digits' });
+export const SetWalletAutoWithdrawalConfigInputSchema = z.object({
+    fiatThreshold: WalletAutoWithdrawalThresholdSchema,
+    cryptoThreshold: WalletAutoWithdrawalThresholdSchema,
+    excludeRiskFlags: z.array(TagKeySchema),
+});
+export const BONUS_CREDIT_SOURCE_TYPES = ['gift', 'rain'];
+export const BonusCreditSourceTypeSchema = z.enum(BONUS_CREDIT_SOURCE_TYPES);
+export const BONUS_CREDIT_STATUSES = ['active', 'completed'];
+export const BonusCreditStatusSchema = z.enum(BONUS_CREDIT_STATUSES);
+export const MAX_BONUS_ROLLOVER_MULTIPLIER = '100';
+function decimalStringAtMost(value, maximum) {
+    const [valueWhole, valueFraction = ''] = value.split('.');
+    const [maximumWhole, maximumFraction = ''] = maximum.split('.');
+    const normalizedValueWhole = (valueWhole ?? '').replace(/^0+(?=\d)/, '');
+    const normalizedMaximumWhole = (maximumWhole ?? '').replace(/^0+(?=\d)/, '');
+    if (normalizedValueWhole.length !== normalizedMaximumWhole.length) {
+        return normalizedValueWhole.length < normalizedMaximumWhole.length;
+    }
+    if (normalizedValueWhole !== normalizedMaximumWhole) {
+        return normalizedValueWhole < normalizedMaximumWhole;
+    }
+    return valueFraction.padEnd(MONEY_SCALE, '0') <= maximumFraction.padEnd(MONEY_SCALE, '0');
+}
+export const BonusCreditSchema = z.object({
+    id: UuidSchema,
+    currency: WalletCurrencyCodeSchema,
+    sourceType: BonusCreditSourceTypeSchema,
+    creditedAmount: MoneyAmountSchema,
+    rolloverMultiplier: MoneyAmountSchema,
+    rolloverRequired: MoneyAmountSchema,
+    rolloverProgress: MoneyAmountSchema,
+    status: BonusCreditStatusSchema,
+    createdAt: TimestampSchema,
+    completedAt: TimestampSchema.nullable(),
+});
+export const BonusRolloverStatusSchema = z.object({
+    credits: z.array(BonusCreditSchema),
+});
+export const BonusRolloverStatusInputSchema = z
+    .object({ status: BonusCreditStatusSchema.optional() })
+    .default({});
+export const BonusRolloverConfigSchema = z.object({
+    id: UuidSchema,
+    multiplier: MoneyAmountSchema,
+    updatedAt: TimestampSchema,
+});
+export const SetBonusRolloverConfigInputSchema = z.object({
+    multiplier: PositiveMoneyAmountSchema.refine((value) => decimalStringAtMost(value, MAX_BONUS_ROLLOVER_MULTIPLIER), { message: `must be at most ${MAX_BONUS_ROLLOVER_MULTIPLIER}x` }),
+});
 export const ApproveWithdrawalInputSchema = z.object({ withdrawalId: UuidSchema });
 export const RejectWithdrawalInputSchema = z.object({
     withdrawalId: UuidSchema,
     reason: z.string().min(1),
 });
+// A vendor quote id is the vendor's own string, not a uuid we mint - bounded, never parsed.
+const SwapQuoteIdSchema = z.string().trim().min(1).max(128);
+export const SwapQuoteInputSchema = z.object({
+    fromCurrency: WalletCurrencyInputSchema,
+    toCurrency: WalletCurrencyInputSchema,
+    fromAmount: PositiveMoneyAmountSchema,
+});
+// `toAmount` is what the player receives, net of `fee`, and is the only binding number -
+// `rate` is informational and must never be multiplied out to reach an amount.
+export const SwapQuoteSchema = z.object({
+    quoteId: SwapQuoteIdSchema,
+    fromCurrency: WalletCurrencyCodeSchema,
+    toCurrency: WalletCurrencyCodeSchema,
+    fromAmount: MoneyAmountSchema,
+    toAmount: MoneyAmountSchema,
+    rate: MoneyAmountSchema,
+    fee: MoneyAmountSchema,
+    feeCurrency: WalletCurrencyCodeSchema,
+    asOf: TimestampSchema,
+    expiresAt: TimestampSchema,
+});
+export const SwapInputSchema = SwapQuoteInputSchema.extend({
+    // Optional: a vendor that does not hold quotes prices the swap at execution time.
+    quoteId: SwapQuoteIdSchema.optional(),
+    idempotencyKey: UuidSchema,
+});
+export const SwapResultSchema = z.object({
+    transactionId: UuidSchema,
+    status: WalletTransactionStatusSchema,
+    // Null until the vendor reports a fill - an async desk settles by webhook.
+    toAmount: MoneyAmountSchema.nullable(),
+});
 export const PaymentWebhookInputSchema = z.record(z.string(), z.unknown());
 export const PaymentWebhookOutputSchema = z.object({ ok: z.literal(true) });
-export const DepositAddressInputSchema = z.object({ currency: WalletCurrencyCodeSchema });
+// The vendor's raw JSON body plus the path-carried `provider` key (oRPC merges a route's
+// path params into the same top-level input object as the body). `provider` is never
+// attacker-trusted for routing to a signature key - the route resolves it against the
+// bound PaymentProviderRegistry and 404/401s identically to a bad signature on a miss.
+export const PaymentWebhookProviderInputSchema = z
+    .object({ provider: z.string().min(1) })
+    .catchall(z.unknown());
+export const DepositAddressInputSchema = z.object({
+    currency: WalletCurrencyInputSchema,
+    network: WalletNetworkInputSchema.optional(),
+});
 export const DepositAddressSchema = z.object({
     address: z.string(),
     currency: WalletCurrencyCodeSchema,
+    network: WalletNetworkSchema.optional(),
+    tag: z.string().optional(),
+});
+// Bounded to the column's integer-digit budget so an oversized value is a 4xx at the
+// contract boundary instead of a DB overflow 500.
+const WalletAssetAmountSchema = MoneyAmountSchema.refine((v) => (v.split('.').at(0) ?? '').length <= MONEY_PRECISION - MONEY_SCALE, { message: `must have at most ${MONEY_PRECISION - MONEY_SCALE} integer digits` });
+export const PublicWalletAssetSchema = z.object({
+    currency: WalletCurrencyCodeSchema,
+    network: WalletNetworkSchema,
+    minDeposit: MoneyAmountSchema,
+    minWithdrawal: MoneyAmountSchema,
+    withdrawalFee: MoneyAmountSchema,
+    depositEnabled: z.boolean(),
+    withdrawalEnabled: z.boolean(),
+});
+// Admin-only, same treatment as providerAssetId: which vendor settles a pair and its
+// sweep/pool policy are operational detail, never surfaced on the public catalog.
+export const WalletAssetSchema = PublicWalletAssetSchema.extend({
+    id: UuidSchema,
+    providerAssetId: z.string(),
+    // Null means the default single binding (PAYMENT_ADAPTER / PAYMENT_WEBHOOK_VERIFIER),
+    // never a vendor's name to parse - core treats this as an opaque operator-chosen key.
+    providerName: z.string().nullable(),
+    sweepDustThreshold: MoneyAmountSchema.nullable(),
+    sweepFeeCeiling: MoneyAmountSchema.nullable(),
+    poolLiquidityFloor: MoneyAmountSchema.nullable(),
+    createdAt: TimestampSchema,
+    updatedAt: TimestampSchema,
+});
+export const WalletAssetKeySchema = z.object({
+    currency: WalletCurrencyInputSchema,
+    network: WalletNetworkInputSchema,
 });
+export const CreateWalletAssetInputSchema = z.object({
+    currency: WalletCurrencyInputSchema,
+    network: WalletNetworkInputSchema,
+    providerAssetId: z.string().trim().min(1),
+    minDeposit: WalletAssetAmountSchema,
+    minWithdrawal: WalletAssetAmountSchema,
+    withdrawalFee: WalletAssetAmountSchema,
+    depositEnabled: z.boolean().default(true),
+    withdrawalEnabled: z.boolean().default(true),
+    // Validated against the bound PaymentProviderRegistry's names() at write time - an
+    // unvalidated typo would fall back to the default adapter, attempting eg a crypto
+    // payout through a PSP. Absent = the default single binding.
+    providerName: z.string().trim().min(1).optional(),
+    sweepDustThreshold: WalletAssetAmountSchema.optional(),
+    sweepFeeCeiling: WalletAssetAmountSchema.optional(),
+    poolLiquidityFloor: WalletAssetAmountSchema.optional(),
+});
+// The (currency, network) key is not mutable: renaming a pair is a delete plus a create,
+// so an in-flight vendor reference can't be rewritten out from under a pending
+// transaction. providerName is immutable the same way - it is deliberately absent here,
+// not merely optional; changing it is only possible via delete + re-create, which the
+// service blocks while a pending/processing transaction exists for the pair.
+export const UpdateWalletAssetInputSchema = WalletAssetKeySchema.extend({
+    providerAssetId: z.string().trim().min(1).optional(),
+    minDeposit: WalletAssetAmountSchema.optional(),
+    minWithdrawal: WalletAssetAmountSchema.optional(),
+    withdrawalFee: WalletAssetAmountSchema.optional(),
+    depositEnabled: z.boolean().optional(),
+    withdrawalEnabled: z.boolean().optional(),
+    sweepDustThreshold: WalletAssetAmountSchema.optional(),
+    sweepFeeCeiling: WalletAssetAmountSchema.optional(),
+    poolLiquidityFloor: WalletAssetAmountSchema.optional(),
+});
+// Shared by both cron-style admin triggers - the caller gets back the id of the
+// wallet_job_run row it claimed, nothing else, since the work itself runs async.
+export const JobRunResultSchema = z.object({ runId: UuidSchema });
+export const WalletReconciliationFindingSchema = z.object({
+    id: UuidSchema,
+    runId: UuidSchema,
+    providerName: z.string(),
+    kind: WalletReconciliationFindingKindSchema,
+    currency: WalletCurrencyCodeSchema.nullable(),
+    network: WalletNetworkSchema.nullable(),
+    amount: MoneyAmountSchema.nullable(),
+    address: z.string().nullable(),
+    tag: z.string().nullable(),
+    txHash: z.string().nullable(),
+    externalId: z.string().nullable(),
+    transactionId: UuidSchema.nullable(),
+    detail: z.string().nullable(),
+    status: WalletReconciliationFindingStatusSchema,
+    resolvedBy: UuidSchema.nullable(),
+    resolvedAt: TimestampSchema.nullable(),
+    resolutionNote: z.string().nullable(),
+    createdAt: TimestampSchema,
+});
+export const ListReconciliationFindingsInputSchema = PageQuerySchema.extend({
+    status: WalletReconciliationFindingStatusSchema.optional(),
+    kind: WalletReconciliationFindingKindSchema.optional(),
+    providerName: z.string().optional(),
+});
+// There is no third way to close a finding: crediting the player (a manual ledger entry
+// made elsewhere, referenced here by its transactionId) or dismissing it as a non-issue
+// (a mandatory note explaining why). Never a bare status flip with no evidence either way.
+export const ReconciliationResolutionSchema = z.discriminatedUnion('outcome', [
+    z.object({ outcome: z.literal('credited'), transactionId: UuidSchema }),
+    z.object({ outcome: z.literal('dismissed'), note: z.string().trim().min(1) }),
+]);
+export const ResolveReconciliationFindingInputSchema = z.object({
+    id: UuidSchema,
+    resolution: ReconciliationResolutionSchema,
+});
+export const WithdrawalAddressSchema = z.object({
+    id: UuidSchema,
+    label: z.string(),
+    currency: WalletCurrencyCodeSchema,
+    network: WalletNetworkSchema,
+    address: z.string(),
+    destinationTag: z.string().nullable(),
+    createdAt: TimestampSchema,
+});
+export const CreateWithdrawalAddressInputSchema = z
+    .object({
+    label: z.string().trim().min(1).max(50),
+    currency: WalletCurrencyInputSchema,
+    network: WalletNetworkInputSchema,
+    address: WalletAddressInputSchema,
+    destinationTag: DestinationTagInputSchema.optional(),
+})
+    .superRefine((data, ctx) => {
+    if (!isWalletAddressValidForNetwork(data.address, data.network)) {
+        ctx.addIssue({
+            code: 'custom',
+            message: `not a valid ${data.network} address`,
+            path: ['address'],
+        });
+    }
+});
+export const ListWithdrawalAddressesInputSchema = z.object({
+    currency: WalletCurrencyInputSchema.optional(),
+});
+export const WithdrawalAddressKeySchema = z.object({ id: UuidSchema });
 export const walletContract = {
     getBalance: oc.route({ method: 'GET', path: '/wallet/balance' }).output(WalletBalanceSchema),
+    getBalances: oc.route({ method: 'GET', path: '/wallet/balances' }).output(WalletBalancesSchema),
+    streamBalance: oc
+        .route({ method: 'GET', path: '/wallet/balance/stream' })
+        .output(eventIterator(WalletBalanceUpdateSchema)),
+    setActiveCurrency: oc
+        .route({ method: 'PUT', path: '/wallet/active-currency' })
+        .input(SetActiveCurrencyInputSchema)
+        .output(ActiveCurrencySchema),
     deposit: oc
         .route({ method: 'POST', path: '/wallet/deposit' })
         .input(DepositInputSchema)
@@ -101,14 +475,21 @@ export const walletContract = {
         .route({ method: 'POST', path: '/wallet/withdraw' })
         .input(WithdrawInputSchema)
         .output(TransactionResultSchema),
+    manualAdjustment: oc
+        .route({ method: 'POST', path: '/wallet/manual-adjustments' })
+        .input(ManualWalletAdjustmentInputSchema)
+        .output(TransactionResultSchema),
     listTransactions: oc
         .route({ method: 'GET', path: '/wallet/transactions' })
-        .input(PageQuerySchema)
+        .input(PageQuerySchema.extend({
+        sortBy: WalletTransactionSortBySchema.optional(),
+        sortOrder: SortOrderSchema.default('desc').optional(),
+    }))
         .output(paginated(WalletTransactionSchema)),
     listPlayerTransactions: oc
         .route({ method: 'GET', path: '/wallet/transactions/{userId}' })
         .input(ListPlayerTransactionsArgs)
-        .output(paginated(WalletTransactionSchema)),
+        .output(paginated(AdminWalletTransactionSchema)),
     withdrawals: {
         list: oc
             .route({ method: 'GET', path: '/wallet/withdrawals' })
@@ -137,15 +518,132 @@ export const walletContract = {
             .input(AutoWithdrawalRuleKeySchema)
             .output(z.boolean()),
     },
+    autoWithdrawalConfig: {
+        get: oc
+            .route({ method: 'GET', path: '/wallet/auto-withdrawal-config' })
+            .output(WalletAutoWithdrawalConfigSchema),
+        set: oc
+            .route({ method: 'PUT', path: '/wallet/auto-withdrawal-config' })
+            .input(SetWalletAutoWithdrawalConfigInputSchema)
+            .output(WalletAutoWithdrawalConfigSchema),
+    },
+    // Unauthenticated by design - which assets exist is not secret.
+    listAssets: oc
+        .route({ method: 'GET', path: '/wallet/assets' })
+        .output(z.array(PublicWalletAssetSchema)),
+    assets: {
+        list: oc
+            .route({ method: 'GET', path: '/wallet/admin/assets' })
+            .output(z.array(WalletAssetSchema)),
+        create: oc
+            .route({ method: 'POST', path: '/wallet/admin/assets' })
+            .input(CreateWalletAssetInputSchema)
+            .output(WalletAssetSchema),
+        update: oc
+            .route({ method: 'PUT', path: '/wallet/admin/assets/{currency}/{network}' })
+            .input(UpdateWalletAssetInputSchema)
+            .output(WalletAssetSchema),
+        delete: oc
+            .route({ method: 'DELETE', path: '/wallet/admin/assets/{currency}/{network}' })
+            .input(WalletAssetKeySchema)
+            .output(z.boolean()),
+    },
+    // Player-owned and player-scoped: an address book is personal data, never listed for
+    // an admin, so there is no admin counterpart to these three routes.
+    withdrawalAddresses: {
+        list: oc
+            .route({ method: 'GET', path: '/wallet/withdrawal-addresses' })
+            .input(ListWithdrawalAddressesInputSchema)
+            .output(z.array(WithdrawalAddressSchema)),
+        create: oc
+            .route({ method: 'POST', path: '/wallet/withdrawal-addresses' })
+            .input(CreateWithdrawalAddressInputSchema)
+            .output(WithdrawalAddressSchema),
+        delete: oc
+            .route({ method: 'DELETE', path: '/wallet/withdrawal-addresses/{id}' })
+            .input(WithdrawalAddressKeySchema)
+            .output(z.boolean()),
+    },
     deposits: {
         getAddress: oc
             .route({ method: 'POST', path: '/wallet/deposits/address' })
             .input(DepositAddressInputSchema)
             .output(DepositAddressSchema),
     },
+    bonusRolloverStatus: oc
+        .route({ method: 'GET', path: '/wallet/bonus-rollover/status' })
+        .input(BonusRolloverStatusInputSchema)
+        .output(BonusRolloverStatusSchema),
+    bonusRolloverConfig: {
+        get: oc
+            .route({ method: 'GET', path: '/backoffice/wallet/bonus-rollover-config' })
+            .output(BonusRolloverConfigSchema),
+        set: oc
+            .route({ method: 'PATCH', path: '/backoffice/wallet/bonus-rollover-config' })
+            .input(SetBonusRolloverConfigInputSchema)
+            .output(BonusRolloverConfigSchema),
+    },
+    swap: {
+        quote: oc
+            .route({ method: 'POST', path: '/wallet/swap/quote', summary: 'Price a currency swap' })
+            .input(SwapQuoteInputSchema)
+            .output(SwapQuoteSchema),
+        execute: oc
+            .route({ method: 'POST', path: '/wallet/swap', summary: 'Swap between own balances' })
+            .input(SwapInputSchema)
+            .output(SwapResultSchema),
+        // Unauthenticated like the payment webhook, and verified by its own SWAP_WEBHOOK_VERIFIER
+        // - a swap desk signs with a different key than the PSP.
+        webhook: oc
+            .route({ method: 'POST', path: '/wallet/swap/webhook' })
+            .input(PaymentWebhookInputSchema)
+            .output(PaymentWebhookOutputSchema),
+    },
     webhook: oc
         .route({ method: 'POST', path: '/wallet/webhook' })
         .input(PaymentWebhookInputSchema)
         .output(PaymentWebhookOutputSchema),
+    // Routes an inbound webhook to the named provider's adapter/verifier pair instead of
+    // the single default binding - see docs/adapters/payment.md "Multi-provider routing".
+    webhookForProvider: oc
+        .route({ method: 'POST', path: '/wallet/webhook/{provider}' })
+        .input(PaymentWebhookProviderInputSchema)
+        .output(PaymentWebhookOutputSchema),
+    custody: {
+        sweep: {
+            run: oc
+                .route({
+                method: 'POST',
+                path: '/wallet/custody/sweep/run',
+                summary: 'Enqueue a custody sweep cycle',
+            })
+                .output(JobRunResultSchema),
+        },
+    },
+    reconciliation: {
+        list: oc
+            .route({
+            method: 'GET',
+            path: '/wallet/reconciliation',
+            summary: 'List reconciliation findings',
+        })
+            .input(ListReconciliationFindingsInputSchema)
+            .output(paginated(WalletReconciliationFindingSchema)),
+        resolve: oc
+            .route({
+            method: 'POST',
+            path: '/wallet/reconciliation/{id}/resolve',
+            summary: 'Resolve a reconciliation finding as credited or dismissed',
+        })
+            .input(ResolveReconciliationFindingInputSchema)
+            .output(WalletReconciliationFindingSchema),
+        run: oc
+            .route({
+            method: 'POST',
+            path: '/wallet/reconciliation/run',
+            summary: 'Enqueue a reconciliation run',
+        })
+            .output(JobRunResultSchema),
+    },
 };
 //# sourceMappingURL=index.js.map