protobuf-platform 1.2.657 → 1.2.659

package/scripts/verify-precision-rg-contract.js

@@ -0,0 +1,180 @@
+'use strict';
+
+// Contract checks only: financial/Redis lifecycle regressions belong to services.
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+const { execFileSync } = require('node:child_process');
+const root = path.resolve(__dirname, '..');
+const baseline = '960a899e90da887fa0831f321dff22517dfa9dff';
+const readOld = (file) => execFileSync('git', ['show', `${baseline}:${file}`], { cwd: root, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });
+const normalize = (text) => text.replace(/\/\/[^\n]*/g, '').replace(/\s+/g, ' ').trim();
+function declarations(source) {
+  const out = new Map();
+  const pattern = /\b(message|enum)\s+(\w+)\s*\{/g;
+  for (const match of source.matchAll(pattern)) {
+    let depth = 1;
+    let end = match.index + match[0].length;
+    const start = end;
+    while (depth) {
+      const char = source[end++];
+      assert.ok(char, 'Unclosed declaration');
+      if (char === '{') depth += 1;
+      if (char === '}') depth -= 1;
+    }
+    out.set(match[2], normalize(source.slice(start, end - 1)));
+  }
+  return out;
+}
+const additions = {
+  ExecuteGameplayPrecisionCommandRequest: 'string preparation_generation = 5; string preparation_fingerprint = 6; GameplayPrecisionRgEvidence rg_admission = 7;',
+  GameplayPrecisionResult: 'repeated GameplayPrecisionAccountingLeg accounting_legs = 17; string preparation_generation = 18; string preparation_fingerprint = 19; string command_key = 20; string request_fingerprint = 21;',
+};
+let preserved = 0;
+for (const domain of ['user', 'payment']) {
+  const file = `${domain}/${domain}.proto`;
+  const oldSource = readOld(file);
+  const newSource = fs.readFileSync(path.join(root, file), 'utf8');
+  const current = declarations(newSource);
+  for (const [name, body] of declarations(oldSource)) {
+    assert.equal(current.get(name), body + (additions[name] ? ` ${additions[name]}` : ''), name);
+    preserved += 1;
+  }
+  const rpcPattern = /rpc\s+\w+\s*\([^;]+;/g;
+  const newRpcs = new Set([...newSource.matchAll(rpcPattern)].map((m) => normalize(m[0])));
+  for (const match of oldSource.matchAll(rpcPattern)) assert.ok(newRpcs.has(normalize(match[0])), match[0]);
+}
+console.log(`PASS: ${preserved} existing message/enum declarations and all existing RPCs preserved`);
+
+function oldBindings(domain) {
+  const sandbox = { exports: {}, require, console };
+  vm.runInNewContext(readOld(`${domain}/${domain}_pb.js`), sandbox, { filename: `legacy-${domain}` });
+  return sandbox.exports;
+}
+const payment = require('../payment/payment_pb');
+const user = require('../user/user_pb');
+const oldPayment = oldBindings('payment');
+const oldUser = oldBindings('user');
+const roundtrip = (value) => value.constructor.deserializeBinary(value.serializeBinary());
+const large = '900719925474099312345678901234567890';
+const evidence = new payment.GameplayPrecisionRgEvidence();
+evidence.setCommandKey('immutable-command');
+evidence.setRequestFingerprint('immutable-request');
+evidence.setPreparationGeneration(large);
+evidence.setPreparationFingerprint('generation-fingerprint');
+evidence.setAccountingCurrency('BTC');
+evidence.setAccountingScale(8);
+evidence.setRequestedDebitMinor('0');
+evidence.setState('RELEASED');
+evidence.setReceiptId('release-receipt');
+const command = new payment.ExecuteGameplayPrecisionCommandRequest();
+command.setCommandId('same-command');
+command.setCallbackAction('bet');
+command.setPreparationGeneration(large);
+command.setPreparationFingerprint('generation-fingerprint');
+command.setRgAdmission(evidence);
+const legacyCommand = oldPayment.ExecuteGameplayPrecisionCommandRequest.deserializeBinary(command.serializeBinary());
+assert.equal(legacyCommand.getCommandId(), 'same-command');
+assert.equal(legacyCommand.getCallbackAction(), 'bet');
+const oldRequest = new oldPayment.ExecuteGameplayPrecisionCommandRequest();
+oldRequest.setCommandId('legacy-command');
+const newFromOld = payment.ExecuteGameplayPrecisionCommandRequest.deserializeBinary(oldRequest.serializeBinary());
+assert.equal(newFromOld.getPreparationGeneration(), '');
+assert.equal(newFromOld.hasRgAdmission(), false);
+const prepared = new payment.PrepareGameplayPrecisionCommandRequest();
+prepared.setCommand(command);
+prepared.setMode(payment.GameplayPrecisionPrepareMode.GAMEPLAY_PRECISION_REPREPARE);
+prepared.setReprepareRequestId('retry-id');
+prepared.setExpectedGeneration(large);
+prepared.setExpectedPreparationFingerprint('generation-fingerprint');
+prepared.setPreviousRelease(evidence);
+assert.deepEqual(roundtrip(prepared).toObject(), prepared.toObject());
+assert.equal(roundtrip(prepared).getPreviousRelease().getRequestedDebitMinor(), '0');
+assert.equal(roundtrip(prepared).getExpectedGeneration(), large);
+console.log('PASS: reprepare/release evidence, large IDs, zero debit and mixed-version requests');
+
+const leg = new payment.GameplayPrecisionAccountingLeg();
+leg.setIntegerDeltaMinor(`-${large}`);
+leg.setFractionalDeltaNumerator('-1');
+leg.setFractionalDeltaDenominator(large);
+leg.setAccountingCurrency('ETH');
+leg.setAccountingScale(18);
+const result = new payment.GameplayPrecisionResult();
+result.setStatus('STALE_PREPARATION');
+result.setPreparationGeneration(large);
+result.setPreparationFingerprint('generation-fingerprint');
+result.setAccountingLegsList([leg]);
+assert.deepEqual(roundtrip(result).toObject(), result.toObject());
+assert.equal(oldPayment.GameplayPrecisionResult.deserializeBinary(result.serializeBinary()).getStatus(), 'STALE_PREPARATION');
+const preparation = new payment.GameplayPrecisionPreparation();
+preparation.setGeneration(large);
+preparation.setRequestedDebitMinor('0');
+preparation.setRequiresRgAdmission(true);
+preparation.setAccountingLegsList([leg]);
+const response = new payment.PrepareGameplayPrecisionCommandResponse();
+response.setStatus('PREPARED');
+response.setPreparation(preparation);
+assert.deepEqual(roundtrip(response).toObject(), response.toObject());
+assert.equal(roundtrip(response).getPreparation().getCashLedgerEntryId(), '');
+response.setStatus('COMMITTED');
+response.setCommittedResult(result);
+assert.deepEqual(roundtrip(response).toObject(), response.toObject());
+console.log('PASS: stale/result envelopes, signed exact legs, scale 18, missing cash watermark');
+
+const binding = new user.PrecisionRgBinding();
+binding.setUserId('17');
+binding.setCommandKey('immutable-command');
+binding.setRequestFingerprint('immutable-request');
+binding.setPrecisionSessionId('session');
+binding.setPreparationGeneration(large);
+binding.setPreparationFingerprint('generation-fingerprint');
+binding.setAccountingCurrency('USD');
+binding.setAccountingScale(2);
+binding.setRequestedDebitMinor('0');
+binding.setGameSessionId('game-session');
+binding.setProviderTransactionId('transaction');
+binding.setRoundId('round');
+for (const action of Object.values(user.PrecisionRgAction)) {
+  const request = new user.PrecisionRgAdmissionRequest();
+  request.setAction(action);
+  request.setBinding(binding);
+  request.setPreviousReleaseReceiptId('previous-release');
+  request.setAdmissionReceiptId('admission');
+  assert.deepEqual(roundtrip(request).toObject(), request.toObject());
+}
+for (const state of Object.values(user.PrecisionRgState)) {
+  for (const outcome of Object.values(user.PrecisionRgOutcome)) {
+    const reply = new user.PrecisionRgAdmissionResponse();
+    reply.setState(state);
+    reply.setOutcome(outcome);
+    reply.setBinding(binding);
+    reply.setCurrentGeneration(large);
+    reply.setAdmissionReceiptId('admission');
+    reply.setReleaseReceiptId('release');
+    reply.setCommitReceiptId('commit');
+    const decision = new user.EvaluateResponsibleGamingDecisionResponse();
+    decision.setAllowed(false);
+    decision.setReasonKey('policy-denied');
+    reply.setDecision(decision);
+    assert.deepEqual(roundtrip(reply).toObject(), reply.toObject());
+  }
+}
+assert.equal(new user.PrecisionRgAdmissionRequest().getAction(), 0);
+assert.equal(new user.PrecisionRgAdmissionResponse().getOutcome(), 0);
+assert.equal(new user.PrecisionRgAdmissionResponse().getState(), 0);
+const legacyDecision = new oldUser.EvaluateResponsibleGamingDecisionResponse();
+legacyDecision.setAllowed(true);
+assert.deepEqual(Buffer.from(user.EvaluateResponsibleGamingDecisionResponse.deserializeBinary(legacyDecision.serializeBinary()).serializeBinary()), Buffer.from(legacyDecision.serializeBinary()));
+console.log('PASS: all RG actions/states/outcomes, receipts, zero debit, safe defaults and legacy decision wire');
+
+const userService = require('../user/user_grpc_pb').UserService;
+const paymentService = require('../payment/payment_grpc_pb').PaymentService;
+assert.equal(userService.transitionPrecisionRgAdmission.path, '/user.User/transitionPrecisionRgAdmission');
+assert.equal(paymentService.prepareGameplayPrecisionCommand.path, '/payment.Payment/prepareGameplayPrecisionCommand');
+assert.equal(userService.transitionPrecisionRgAdmission.requestType, user.PrecisionRgAdmissionRequest);
+assert.equal(paymentService.prepareGameplayPrecisionCommand.responseType, payment.PrepareGameplayPrecisionCommandResponse);
+const exported = require('../index');
+assert.equal(exported.user.messages.PrecisionRgBinding, user.PrecisionRgBinding);
+assert.equal(exported.payment.messages.GameplayPrecisionPreparation, payment.GameplayPrecisionPreparation);
+console.log('PASS: generated gRPC paths/types and package exports');

package/user/user.proto

@@ -205,6 +205,8 @@ service User {
     rpc reserveResponsibleGamingLossExposure(ReserveResponsibleGamingLossExposureRequest) returns (ReserveResponsibleGamingLossExposureResponse);
     rpc finalizeResponsibleGamingLossExposure(FinalizeResponsibleGamingLossExposureRequest) returns (FinalizeResponsibleGamingLossExposureResponse);
     rpc updateResponsibleGamingTimeUsage(UpdateResponsibleGamingTimeUsageRequest) returns (UpdateResponsibleGamingTimeUsageResponse);
+    rpc transitionPrecisionRgAdmission(PrecisionRgAdmissionRequest)
+        returns (PrecisionRgAdmissionResponse);
 }
 //Technical
 message PingRequest { string ping = 1; }
@@ -2590,4 +2592,58 @@ message UpdateResponsibleGamingTimeUsageResponse {
     bool limit_reached = 8;
     optional string reason_key = 9;
     optional ResponsibleGamingDecisionDetails decision_details = 10;
-}
+}
+enum PrecisionRgAction {
+    PRECISION_RG_ACTION_UNSPECIFIED = 0;
+    PRECISION_RG_RESERVE = 1;
+    PRECISION_RG_RELEASE = 2;
+    PRECISION_RG_COMMIT = 3;
+    PRECISION_RG_READ = 4;
+}
+enum PrecisionRgState {
+    PRECISION_RG_STATE_UNKNOWN = 0;
+    PRECISION_RG_RESERVED = 1;
+    PRECISION_RG_DENIED = 2;
+    PRECISION_RG_RELEASED = 3;
+    PRECISION_RG_COMMITTED = 4;
+}
+enum PrecisionRgOutcome {
+    PRECISION_RG_OUTCOME_UNSPECIFIED = 0;
+    PRECISION_RG_OK = 1;
+    PRECISION_RG_POLICY_DENIED = 2;
+    PRECISION_RG_CONFLICT = 3;
+    PRECISION_RG_STALE_GENERATION = 4;
+    PRECISION_RG_RELEASE_REQUIRED = 5;
+    PRECISION_RG_INVALID_STATE = 6;
+    PRECISION_RG_STATE_UNAVAILABLE = 7;
+}
+message PrecisionRgBinding {
+    string user_id = 1;
+    string command_key = 2;
+    string request_fingerprint = 3;
+    string precision_session_id = 4;
+    string preparation_generation = 5;
+    string preparation_fingerprint = 6;
+    string accounting_currency = 7;
+    uint32 accounting_scale = 8;
+    string requested_debit_minor = 9;
+    string game_session_id = 10;
+    string provider_transaction_id = 11;
+    string round_id = 12;
+}
+message PrecisionRgAdmissionRequest {
+    PrecisionRgAction action = 1;
+    PrecisionRgBinding binding = 2;
+    string previous_release_receipt_id = 3;
+    string admission_receipt_id = 4;
+}
+message PrecisionRgAdmissionResponse {
+    PrecisionRgOutcome outcome = 1;
+    PrecisionRgState state = 2;
+    PrecisionRgBinding binding = 3;
+    string current_generation = 4;
+    string admission_receipt_id = 5;
+    string release_receipt_id = 6;
+    string commit_receipt_id = 7;
+    EvaluateResponsibleGamingDecisionResponse decision = 8;
+}

package/user/user_grpc_pb.js

@@ -939,6 +939,28 @@ function deserialize_user_PongResponse(buffer_arg) {
   return user_pb.PongResponse.deserializeBinary(new Uint8Array(buffer_arg));
 }
 
+function serialize_user_PrecisionRgAdmissionRequest(arg) {
+  if (!(arg instanceof user_pb.PrecisionRgAdmissionRequest)) {
+    throw new Error('Expected argument of type user.PrecisionRgAdmissionRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_user_PrecisionRgAdmissionRequest(buffer_arg) {
+  return user_pb.PrecisionRgAdmissionRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_user_PrecisionRgAdmissionResponse(arg) {
+  if (!(arg instanceof user_pb.PrecisionRgAdmissionResponse)) {
+    throw new Error('Expected argument of type user.PrecisionRgAdmissionResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_user_PrecisionRgAdmissionResponse(buffer_arg) {
+  return user_pb.PrecisionRgAdmissionResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
 function serialize_user_PrepareUserKycVerificationRequest(arg) {
   if (!(arg instanceof user_pb.PrepareUserKycVerificationRequest)) {
     throw new Error('Expected argument of type user.PrepareUserKycVerificationRequest');
@@ -4244,6 +4266,17 @@ adminResetResponsibleGamingPolicy: {
     responseSerialize: serialize_user_UpdateResponsibleGamingTimeUsageResponse,
     responseDeserialize: deserialize_user_UpdateResponsibleGamingTimeUsageResponse,
   },
+  transitionPrecisionRgAdmission: {
+    path: '/user.User/transitionPrecisionRgAdmission',
+    requestStream: false,
+    responseStream: false,
+    requestType: user_pb.PrecisionRgAdmissionRequest,
+    responseType: user_pb.PrecisionRgAdmissionResponse,
+    requestSerialize: serialize_user_PrecisionRgAdmissionRequest,
+    requestDeserialize: deserialize_user_PrecisionRgAdmissionRequest,
+    responseSerialize: serialize_user_PrecisionRgAdmissionResponse,
+    responseDeserialize: deserialize_user_PrecisionRgAdmissionResponse,
+  },
 };
 
 exports.UserClient = grpc.makeGenericClientConstructor(UserService, 'User');