@riocrypto/common-server 1.0.2877 → 1.0.2879

package/build/helpers/payin-destinations.js

@@ -0,0 +1,286 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPayinDestinations = exports.getPayinBankDetails = exports.PER_USER_PAYIN_PROCESSORS = void 0;
+const common_1 = require("@riocrypto/common");
+const rio_bank_account_1 = require("../models/rio-bank-account");
+const STP_deposit_CLABE_1 = require("../models/STP-deposit-CLABE");
+const fintoc_deposit_CLABE_1 = require("../models/fintoc-deposit-CLABE");
+const alfin_virtual_cci_1 = require("../models/alfin-virtual-cci");
+const processor_readiness_1 = require("../models/processor-readiness");
+const cluster_client_1 = require("../clients/cluster-client");
+// Rails that give each user their own destination, which therefore has to exist
+// before we can tell a customer where to pay. Every other rail is a shared house
+// account that is always available.
+exports.PER_USER_PAYIN_PROCESSORS = [
+    common_1.Processor.SPEI_STP,
+    common_1.Processor.SPEI_FINTOC,
+    common_1.Processor.Alfin,
+];
+const MEXICO_COMPANY_NAME = "RAMPA BLOCKCHAIN SAPI DE CV";
+const MEXICO_COMPANY_ADDRESS = "Ave. Lázaro Cardenas 2400, Residencial San Agustin 1 Sector, San Pedro Garza Garcia, CP 66260, Mexico";
+const MEXICO_RFC = "RBL2206107N8";
+const PERU_COMPANY_NAME = "Rampa Machu S.A.C.";
+const PERU_COMPANY_ADDRESS = "Calle General de la Fuente, Edificio 393, dep. 102, Lima, Perú, 17076";
+const PERU_RUC = "20610425713";
+// Rio's Alfin Cuenta Vista per currency. A CCIV is reachable only through the
+// interbank clearing house, so a customer who banks at Alfin cannot pay one from
+// inside Alfin and needs the underlying account number. Note that a payment sent
+// here carries no CCIV, so Alfin raises no payin notification for it: it is only
+// picked up by the treasury statement import and has to be matched by hand.
+const ALFIN_ACCOUNT_NUMBER_BY_FIAT = {
+    [common_1.Fiat.PEN]: "01818233900001",
+    [common_1.Fiat.USD]: "01818233900002",
+};
+// Shared house accounts. Kept here rather than in the order-payment path so the
+// customer-facing whitelisting list and the payment instructions on an order can
+// never drift apart.
+const getStaticPayinBankDetails = (processor, fiat) => {
+    if (processor === common_1.Processor.SPEI_NVIO) {
+        return {
+            bankName: "NVIO",
+            companyName: MEXICO_COMPANY_NAME,
+            companyAddress: MEXICO_COMPANY_ADDRESS,
+            CLABE: "710969000021237966",
+            RFC: MEXICO_RFC,
+        };
+    }
+    if (processor === common_1.Processor.SPEI) {
+        return {
+            bankName: "Fondeadora",
+            companyName: MEXICO_COMPANY_NAME,
+            companyAddress: MEXICO_COMPANY_ADDRESS,
+            CLABE: "699180600005533135",
+            RFC: MEXICO_RFC,
+        };
+    }
+    if (processor === common_1.Processor.SPID) {
+        return {
+            bankName: "Banco Bancrea, S.A.",
+            companyName: MEXICO_COMPANY_NAME,
+            companyAddress: "Ave. Lázaro Cardenas 2400 INT B51. Residencial San Agustin 1er SEC, San Pedro Garza Garcia, Nuevo Leon, Mexico 66260",
+            CLABE: "152580220000044256",
+            RFC: MEXICO_RFC,
+        };
+    }
+    if (processor === common_1.Processor.Interbank) {
+        if (fiat === common_1.Fiat.PEN) {
+            return {
+                bankName: "Interbank",
+                companyName: PERU_COMPANY_NAME,
+                companyAddress: PERU_COMPANY_ADDRESS,
+                accountNumber: "200-3004741070",
+                CCI: "003-200-003004741070-36",
+                RUC: PERU_RUC,
+            };
+        }
+        if (fiat === common_1.Fiat.USD) {
+            return {
+                bankName: "Interbank",
+                companyName: PERU_COMPANY_NAME,
+                companyAddress: PERU_COMPANY_ADDRESS,
+                accountNumber: "200-3004741088",
+                CCI: "003-200-003004741088-38",
+                RUC: PERU_RUC,
+            };
+        }
+        return {};
+    }
+    if (processor === common_1.Processor.BinanceRFQ) {
+        return {
+            bankName: "Binance RFQ",
+            companyName: MEXICO_COMPANY_NAME,
+            companyAddress: "Ave. Lázaro Cardenas 2400 INT B51. Residencial San Agustin 1er SEC, San Pedro Garza Garcia, Nuevo Leon, Mexico 66260",
+            accountNumber: "Rio Binance account",
+        };
+    }
+    if (processor === common_1.Processor.Coltefinanciera) {
+        return {
+            bankName: "Coltefinanciera",
+            companyName: "RAMPA COLOMBIA S.A.S.",
+            companyAddress: "Cl. 82 # 18-36 Oficina 301, Bogotá D.C., Colombia",
+            accountNumber: "4060002029",
+            NIT: "901700811-9",
+        };
+    }
+    return {};
+};
+// Looks up (and by default creates) the user's own destination on a per-user
+// rail. With `provision` false it reports what exists without calling out to the
+// provider, which is what the whitelisting list needs so that merely viewing the
+// page does not allocate account numbers at Fintoc or Alfin.
+const getPerUserPayinBankDetails = ({ mongoose, processor, fiat, userId, provision, }) => __awaiter(void 0, void 0, void 0, function* () {
+    if (processor === common_1.Processor.SPEI_STP) {
+        const STPDepositCLABE = (0, STP_deposit_CLABE_1.buildSTPDepositCLABE)(mongoose);
+        const existing = yield STPDepositCLABE.findOne({ userId });
+        let CLABE = existing === null || existing === void 0 ? void 0 : existing.CLABE;
+        if (!CLABE) {
+            if (!provision) {
+                return undefined;
+            }
+            const clusterClient = yield (0, cluster_client_1.buildClusterClient)();
+            CLABE = (yield clusterClient.generateSTPDepositCLABE(userId)).CLABE;
+        }
+        return {
+            bankName: "Sistema de Transferencias y Pagos, S.A. de C.V.",
+            companyName: MEXICO_COMPANY_NAME,
+            companyAddress: MEXICO_COMPANY_ADDRESS,
+            CLABE,
+            RFC: MEXICO_RFC,
+        };
+    }
+    if (processor === common_1.Processor.SPEI_FINTOC) {
+        const FintocDepositCLABE = (0, fintoc_deposit_CLABE_1.buildFintocDepositCLABE)(mongoose);
+        // A user has exactly one Fintoc CLABE and it never changes. The orderId
+        // filter only excludes legacy per-order rows that predate that rule.
+        const existing = yield FintocDepositCLABE.findOne({
+            userId,
+            $or: [{ orderId: { $exists: false } }, { orderId: null }],
+            disabled: { $ne: true },
+        });
+        let CLABE = existing === null || existing === void 0 ? void 0 : existing.CLABE;
+        if (!CLABE) {
+            if (!provision) {
+                return undefined;
+            }
+            const clusterClient = yield (0, cluster_client_1.buildClusterClient)();
+            CLABE = (yield clusterClient.generateFintocDepositCLABE(userId)).CLABE;
+        }
+        return {
+            bankName: "Fintoc",
+            companyName: MEXICO_COMPANY_NAME,
+            companyAddress: MEXICO_COMPANY_ADDRESS,
+            CLABE,
+            RFC: MEXICO_RFC,
+        };
+    }
+    if (processor === common_1.Processor.Alfin) {
+        const AlfinVirtualCci = (0, alfin_virtual_cci_1.buildAlfinVirtualCci)(mongoose);
+        const existing = yield AlfinVirtualCci.findOne({ userId, fiat });
+        let CCIV = existing === null || existing === void 0 ? void 0 : existing.CCIV;
+        if (!CCIV) {
+            if (!provision) {
+                return undefined;
+            }
+            const clusterClient = yield (0, cluster_client_1.buildClusterClient)();
+            CCIV = (yield clusterClient.generateAlfinVirtualCci(userId, fiat)).CCIV;
+        }
+        return {
+            bankName: "Alfin Banco",
+            companyName: PERU_COMPANY_NAME,
+            companyAddress: PERU_COMPANY_ADDRESS,
+            accountNumber: ALFIN_ACCOUNT_NUMBER_BY_FIAT[fiat],
+            CCI: CCIV,
+            RUC: PERU_RUC,
+        };
+    }
+    return undefined;
+});
+// The account a customer must pay into to fund a buy order on a given rail.
+// A custom Rio bank account replaces the rail's own destination outright, which
+// is why routing has to know that account's processor - see resolveProcessor.
+const getPayinBankDetails = ({ mongoose, processor, fiat, country, user, }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c;
+    const rioBankAccountId = (_c = (_b = (_a = user.rioBankAccount) === null || _a === void 0 ? void 0 : _a[country]) === null || _b === void 0 ? void 0 : _b[fiat]) === null || _c === void 0 ? void 0 : _c.id;
+    if (rioBankAccountId) {
+        const RioBankAccount = (0, rio_bank_account_1.buildRioBankAccount)(mongoose);
+        const rioBankAccount = yield RioBankAccount.findById(rioBankAccountId);
+        if (!rioBankAccount) {
+            throw new common_1.NotFoundError("Rio bank account");
+        }
+        return {
+            bankName: rioBankAccount.bankName,
+            bankAddress: rioBankAccount.bankAddress,
+            companyName: rioBankAccount.companyName,
+            companyAddress: rioBankAccount.companyAddress,
+            accountNumber: rioBankAccount.accountNumber,
+            CLABE: rioBankAccount.CLABE,
+            RUC: rioBankAccount.RUC,
+            RFC: rioBankAccount.RFC,
+            CCI: rioBankAccount.CCI,
+        };
+    }
+    if (exports.PER_USER_PAYIN_PROCESSORS.includes(processor)) {
+        const details = yield getPerUserPayinBankDetails({
+            mongoose,
+            processor,
+            fiat,
+            userId: user.id,
+            provision: true,
+        });
+        return details || {};
+    }
+    return getStaticPayinBankDetails(processor, fiat);
+});
+exports.getPayinBankDetails = getPayinBankDetails;
+// Every account a user may be asked to pay into for one corridor, for the page
+// that tells them what to whitelist at their bank. Read-only by default so that
+// viewing the list never allocates anything at a provider; pass `provision` to
+// create the destinations that do not exist yet.
+const getPayinDestinations = ({ mongoose, user, country, fiat, processors, provision = false, }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _d, _e;
+    const ProcessorReadiness = (0, processor_readiness_1.buildProcessorReadiness)(mongoose);
+    const readiness = yield ProcessorReadiness.find({
+        userId: user.id,
+        country,
+        fiat,
+    })
+        .select({ processor: 1, status: 1, enablement: 1 })
+        .lean();
+    const readinessByProcessor = new Map(readiness.map((record) => [record.processor, record]));
+    const isEnabled = (processor) => {
+        var _a, _b, _c;
+        return ((_c = (_b = (_a = readinessByProcessor.get(processor)) === null || _a === void 0 ? void 0 : _a.enablement) === null || _b === void 0 ? void 0 : _b[common_1.Side.Buy]) === null || _c === void 0 ? void 0 : _c.isEnabled) !==
+            false;
+    };
+    const destinations = [];
+    for (const processor of processors) {
+        let bankDetails;
+        if (exports.PER_USER_PAYIN_PROCESSORS.includes(processor)) {
+            bankDetails = yield getPerUserPayinBankDetails({
+                mongoose,
+                processor,
+                fiat,
+                userId: user.id,
+                provision,
+            });
+        }
+        else {
+            bankDetails = getStaticPayinBankDetails(processor, fiat);
+        }
+        // A rail with no destination for this fiat (Interbank outside PEN/USD, say)
+        // is not something the customer can whitelist, so it is left off the list
+        // rather than shown as an empty row.
+        const isProvisioned = Boolean(bankDetails && (bankDetails.CLABE || bankDetails.CCI || bankDetails.accountNumber));
+        if (!bankDetails) {
+            destinations.push({
+                processor,
+                bankDetails: {},
+                isProvisioned: false,
+                isEnabled: isEnabled(processor),
+                readinessStatus: (_d = readinessByProcessor.get(processor)) === null || _d === void 0 ? void 0 : _d.status,
+            });
+            continue;
+        }
+        if (!isProvisioned) {
+            continue;
+        }
+        destinations.push({
+            processor,
+            bankDetails,
+            isProvisioned: true,
+            isEnabled: isEnabled(processor),
+            readinessStatus: (_e = readinessByProcessor.get(processor)) === null || _e === void 0 ? void 0 : _e.status,
+        });
+    }
+    return destinations;
+});
+exports.getPayinDestinations = getPayinDestinations;

package/build/helpers/payin-verification.d.ts

@@ -0,0 +1,30 @@
+import { Country, Fiat, Processor, ProcessorReadinessStatus } from "@riocrypto/common";
+import { Mongoose } from "mongoose";
+export declare const extractTestReference: (reference: string | undefined | null) => string | undefined;
+export declare const startPayinVerification: ({ mongoose, userId, country, fiat, processor, CLABE, }: {
+    mongoose: Mongoose;
+    userId: string;
+    country: Country;
+    fiat: Fiat;
+    processor: Processor;
+    CLABE?: string | undefined;
+}) => Promise<{
+    reference: string;
+    amount: number;
+    status: ProcessorReadinessStatus;
+}>;
+export interface PayinVerificationMatch {
+    userId: string;
+    country: Country;
+    fiat: Fiat;
+    processor: Processor;
+}
+export declare const matchPendingPayinVerification: ({ mongoose, reference, amount, fiat, processor, originCLABE, originAccountHolderName, }: {
+    mongoose: Mongoose;
+    reference: string | undefined | null;
+    amount: number;
+    fiat: Fiat;
+    processor: Processor;
+    originCLABE?: string | undefined;
+    originAccountHolderName?: string | undefined;
+}) => Promise<PayinVerificationMatch | undefined>;

package/build/helpers/payin-verification.js

@@ -0,0 +1,162 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchPendingPayinVerification = exports.startPayinVerification = exports.extractTestReference = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const common_1 = require("@riocrypto/common");
+const processor_readiness_1 = require("../models/processor-readiness");
+const logger_1 = __importDefault(require("../services/logger"));
+// Distinctive prefix so a test reference cannot be confused with an order or
+// bulk payment reference (which use "RIO-" and "SPR" prefixes). Matching keys off
+// this pattern, which is what lets the inbound handlers recognise a test deposit
+// before they attempt to match it to an order.
+const TEST_REFERENCE_PREFIX = "RIOV";
+const TEST_REFERENCE_BODY_LENGTH = 10;
+const TEST_REFERENCE_PATTERN = new RegExp(`${TEST_REFERENCE_PREFIX}[0-9A-HJ-NP-Z]{${TEST_REFERENCE_BODY_LENGTH}}`);
+// Crockford-style alphabet: no I, L, O or U, so a customer retyping the reference
+// off a screen cannot turn it into a different valid token.
+const TOKEN_ALPHABET = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+const buildTestReference = () => {
+    const bytes = crypto_1.default.randomBytes(TEST_REFERENCE_BODY_LENGTH);
+    let body = "";
+    for (let i = 0; i < TEST_REFERENCE_BODY_LENGTH; i += 1) {
+        body += TOKEN_ALPHABET[bytes[i] % TOKEN_ALPHABET.length];
+    }
+    return `${TEST_REFERENCE_PREFIX}${body}`;
+};
+// Centavos rather than whole units: it widens the space of possible amounts and
+// makes an accidental collision with an unrelated payment of the same size far
+// less likely, which matters on the shared house rails where the reference is the
+// only thing tying a deposit to a user.
+const buildTestAmount = () => (0, common_1.roundToDecimals)(1 + crypto_1.default.randomInt(0, 899) / 100, 2);
+const extractTestReference = (reference) => {
+    var _a;
+    if (!reference) {
+        return undefined;
+    }
+    return (_a = TEST_REFERENCE_PATTERN.exec(reference.toUpperCase())) === null || _a === void 0 ? void 0 : _a[0];
+};
+exports.extractTestReference = extractTestReference;
+// Opens a penny test: the customer sends us this exact amount with this exact
+// reference, and the inbound handler for the rail marks them verified when it
+// arrives. Deliberately does not touch an already-verified record - there is
+// nothing left to prove.
+//
+// Proving a rail works does not switch it on, and never switching it on does not
+// stop it being used: enablement is the customer's own decision and lives on the
+// same record under enablement. A test is how they find out a rail works before an
+// order depends on it, not how they get access to it.
+//
+// The token does not expire. Whitelisting an account at a bank can take days of
+// back and forth at the customer's end, and expiring the token in the middle of
+// that would reject a transfer they were told to send - the worst possible
+// outcome, since the deposit has already left their account.
+const startPayinVerification = ({ mongoose, userId, country, fiat, processor, CLABE, }) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!(0, common_1.isPayinVerifiable)(processor)) {
+        throw new common_1.GenericInputError("This payment rail cannot be verified with a test deposit");
+    }
+    const ProcessorReadiness = (0, processor_readiness_1.buildProcessorReadiness)(mongoose);
+    const existing = yield ProcessorReadiness.findOne({
+        userId,
+        country,
+        fiat,
+        processor,
+    });
+    if ((existing === null || existing === void 0 ? void 0 : existing.status) === common_1.ProcessorReadinessStatus.Verified) {
+        throw new common_1.GenericInputError("This payment rail is already verified for this account");
+    }
+    // Reuse the outstanding token rather than issuing a new one, so a customer who
+    // reloads the page and has already sent the deposit is not left with a
+    // reference we no longer recognise.
+    if ((existing === null || existing === void 0 ? void 0 : existing.status) === common_1.ProcessorReadinessStatus.AwaitingTestDeposit &&
+        existing.testReference &&
+        existing.testAmount) {
+        return {
+            reference: existing.testReference,
+            amount: existing.testAmount,
+            status: existing.status,
+        };
+    }
+    const reference = buildTestReference();
+    const amount = buildTestAmount();
+    yield ProcessorReadiness.updateOne({ userId, country, fiat, processor }, {
+        $set: Object.assign({ status: common_1.ProcessorReadinessStatus.AwaitingTestDeposit, testReference: reference, testAmount: amount }, (CLABE ? { CLABE } : {})),
+        $unset: {
+            observedOriginCLABE: "",
+            observedOriginAccountHolderName: "",
+        },
+        $setOnInsert: {
+            createdAt: new Date(),
+            userId,
+            country,
+            fiat,
+            processor,
+        },
+    }, { upsert: true });
+    return {
+        reference,
+        amount,
+        status: common_1.ProcessorReadinessStatus.AwaitingTestDeposit,
+    };
+});
+exports.startPayinVerification = startPayinVerification;
+// Called from each rail's inbound deposit handler BEFORE it tries to match the
+// deposit to an order. A test token is random, so it will not collide with a real
+// order reference - but order matching does substring comparisons, so running it
+// first could still claim a test deposit by accident.
+//
+// Requires both the token and the exact amount. The token alone is unguessable,
+// so the amount is defence in depth rather than the primary control; a token hit
+// with the wrong amount is left unverified on purpose, so it surfaces through the
+// normal unrecognised-payment path where a human looks at it.
+const matchPendingPayinVerification = ({ mongoose, reference, amount, fiat, processor, originCLABE, originAccountHolderName, }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const testReference = (0, exports.extractTestReference)(reference);
+    if (!testReference) {
+        return undefined;
+    }
+    const ProcessorReadiness = (0, processor_readiness_1.buildProcessorReadiness)(mongoose);
+    try {
+        // Single atomic transition, so a webhook and a poller delivering the same
+        // deposit cannot both claim it.
+        const matched = yield ProcessorReadiness.findOneAndUpdate({
+            testReference,
+            status: common_1.ProcessorReadinessStatus.AwaitingTestDeposit,
+            fiat,
+            processor,
+            testAmount: (0, common_1.roundToDecimals)(amount, 2),
+        }, {
+            $set: Object.assign(Object.assign({ status: common_1.ProcessorReadinessStatus.Verified, verifiedAt: new Date(), verifiedVia: common_1.ProcessorReadinessVerificationMethod.TestDeposit }, (originCLABE ? { observedOriginCLABE: originCLABE } : {})), (originAccountHolderName
+                ? { observedOriginAccountHolderName: originAccountHolderName }
+                : {})),
+        }, { new: true });
+        if (!matched) {
+            return undefined;
+        }
+        return {
+            userId: matched.userId,
+            country: matched.country,
+            fiat: matched.fiat,
+            processor: matched.processor,
+        };
+    }
+    catch (error) {
+        // Must never break crediting a payment. Falling through leaves the deposit to
+        // the normal matching path, which at worst raises it as unrecognised.
+        (_a = logger_1.default
+            .getLogger()) === null || _a === void 0 ? void 0 : _a.error(`Unable to match pending payin verification ${testReference}: ${error}`);
+        return undefined;
+    }
+});
+exports.matchPendingPayinVerification = matchPendingPayinVerification;

package/build/helpers/processor-enablement.d.ts

@@ -0,0 +1,19 @@
+import { Country, Fiat, Processor, Side } from "@riocrypto/common";
+import { Mongoose } from "mongoose";
+export declare const getDisabledProcessors: ({ mongoose, userId, country, fiat, side, }: {
+    mongoose: Mongoose;
+    userId: string;
+    country: Country;
+    fiat: Fiat;
+    side: Side;
+}) => Promise<Processor[]>;
+export declare const setProcessorEnablement: ({ mongoose, userId, country, fiat, side, processor, isEnabled, adminId, }: {
+    mongoose: Mongoose;
+    userId: string;
+    country: Country;
+    fiat: Fiat;
+    side: Side;
+    processor: Processor;
+    isEnabled: boolean;
+    adminId?: string | undefined;
+}) => Promise<void>;

package/build/helpers/processor-enablement.js

@@ -0,0 +1,87 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setProcessorEnablement = exports.getDisabledProcessors = void 0;
+const common_1 = require("@riocrypto/common");
+const processor_readiness_1 = require("../models/processor-readiness");
+// Enablement is asked per side, so the purpose is fixed by the direction rather
+// than chosen by the caller: verifications are ours to place and are never gated.
+const getPurpose = (side) => side === common_1.Side.Buy
+    ? common_1.ProcessorRoutingPurpose.Buy
+    : common_1.ProcessorRoutingPurpose.Sell;
+// Rails the user has switched off for one corridor and one direction, which order
+// routing skips. On a buy that means a rail their bank will not let them send
+// money to; on a sell, one it will not accept credits from.
+//
+// Only explicit refusals count. A rail with no record is enabled, which is what
+// keeps a customer who has never opened their account settings trading exactly as
+// they did before.
+const getDisabledProcessors = ({ mongoose, userId, country, fiat, side, }) => __awaiter(void 0, void 0, void 0, function* () {
+    const ProcessorReadiness = (0, processor_readiness_1.buildProcessorReadiness)(mongoose);
+    const readiness = yield ProcessorReadiness.find({
+        userId,
+        country,
+        fiat,
+        [`enablement.${side}.isEnabled`]: false,
+    })
+        .select({ processor: 1 })
+        .lean();
+    return readiness.map((record) => record.processor);
+});
+exports.getDisabledProcessors = getDisabledProcessors;
+// Turns a rail on or off for one user in one direction, which is what order
+// routing gates on. Deliberately says nothing about verification: a customer can
+// enable a rail they have never tested, and switching one off leaves its test
+// deposit result intact so turning it back on later does not mean testing again.
+//
+// Refuses to switch off the last rail standing. Enabling nothing means we have
+// nowhere to send their money, and finding that out when they try to place an
+// order is worse than being told here.
+const setProcessorEnablement = ({ mongoose, userId, country, fiat, side, processor, isEnabled, adminId, }) => __awaiter(void 0, void 0, void 0, function* () {
+    const corridorProcessors = (0, common_1.getProcessorsForCorridor)(country, fiat, getPurpose(side));
+    if (!corridorProcessors.includes(processor)) {
+        throw new common_1.GenericInputError(side === common_1.Side.Buy
+            ? "This payment rail is not available for this country and currency"
+            : "This payout rail is not available for this country and currency");
+    }
+    if (!isEnabled) {
+        const disabled = yield (0, exports.getDisabledProcessors)({
+            mongoose,
+            userId,
+            country,
+            fiat,
+            side,
+        });
+        const stillEnabled = corridorProcessors.filter((candidate) => candidate !== processor && !disabled.includes(candidate));
+        if (!stillEnabled.length) {
+            throw new common_1.GenericInputError(side === common_1.Side.Buy
+                ? "At least one payment account has to stay enabled for this currency, otherwise there is nowhere to send your orders"
+                : "At least one payout account has to stay enabled for this currency, otherwise there is nowhere to pay your orders from");
+        }
+    }
+    const ProcessorReadiness = (0, processor_readiness_1.buildProcessorReadiness)(mongoose);
+    yield ProcessorReadiness.updateOne({ userId, country, fiat, processor }, {
+        $set: {
+            [`enablement.${side}`]: Object.assign({ isEnabled, updatedAt: new Date() }, (adminId ? { updatedByAdminId: adminId } : {})),
+        },
+        $setOnInsert: {
+            createdAt: new Date(),
+            userId,
+            country,
+            fiat,
+            processor,
+            // The record may not exist yet: enablement is the first thing a customer
+            // touches on a rail they have never tested.
+            status: common_1.ProcessorReadinessStatus.Provisioned,
+        },
+    }, { upsert: true });
+});
+exports.setProcessorEnablement = setProcessorEnablement;

package/build/helpers/record-observed-processor-readiness.d.ts

@@ -0,0 +1,10 @@
+import { Country, Fiat, Processor } from "@riocrypto/common";
+import { Mongoose } from "mongoose";
+export declare const recordObservedProcessorReadiness: ({ mongoose, userId, country, fiat, processor, CLABE, }: {
+    mongoose: Mongoose;
+    userId: string;
+    country: Country;
+    fiat: Fiat;
+    processor: Processor;
+    CLABE?: string | undefined;
+}) => Promise<void>;

package/build/helpers/record-observed-processor-readiness.js

@@ -0,0 +1,65 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordObservedProcessorReadiness = void 0;
+const common_1 = require("@riocrypto/common");
+const processor_readiness_1 = require("../models/processor-readiness");
+const logger_1 = __importDefault(require("../services/logger"));
+const DUPLICATE_KEY_ERROR_CODE = 11000;
+// Records that money has actually arrived from a user through a rail, which is
+// the strongest evidence there is that they can pay into it - stronger than a
+// penny test, because it is a real payment at real size. Called from the payment
+// matching paths so the record stays current without anyone maintaining it.
+//
+// Only touches verification. A rail the customer has switched off stays off even
+// if a payment turns up on it, because the account they cannot send to next month
+// is not made usable by one that arrived this month.
+//
+// Never downgrades an existing verified record: an admin override stays
+// attributed to the admin who granted it.
+const recordObservedProcessorReadiness = ({ mongoose, userId, country, fiat, processor, CLABE, }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const ProcessorReadiness = (0, processor_readiness_1.buildProcessorReadiness)(mongoose);
+    try {
+        yield ProcessorReadiness.updateOne({
+            userId,
+            country,
+            fiat,
+            processor,
+            status: { $ne: common_1.ProcessorReadinessStatus.Verified },
+        }, {
+            $set: Object.assign({ status: common_1.ProcessorReadinessStatus.Verified, verifiedAt: new Date(), verifiedVia: common_1.ProcessorReadinessVerificationMethod.ObservedDeposit }, (CLABE ? { CLABE } : {})),
+            $setOnInsert: {
+                createdAt: new Date(),
+                userId,
+                country,
+                fiat,
+                processor,
+            },
+        }, { upsert: true });
+    }
+    catch (error) {
+        // The filter excludes already-verified records, so upsert tries to insert
+        // and the unique index rejects it. That is the desired outcome - the rail is
+        // verified - so it is not an error.
+        if ((error === null || error === void 0 ? void 0 : error.code) === DUPLICATE_KEY_ERROR_CODE) {
+            return;
+        }
+        // Readiness is an optimization of the routing gate, never a condition for
+        // crediting a payment, so a failure here must not fail the caller.
+        (_a = logger_1.default
+            .getLogger()) === null || _a === void 0 ? void 0 : _a.error(`Unable to record observed processor readiness for user ${userId} on ${processor}: ${error}`);
+    }
+});
+exports.recordObservedProcessorReadiness = recordObservedProcessorReadiness;