@riocrypto/common-server 1.0.2878 → 1.0.2880

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

@@ -0,0 +1,18 @@
+import { Country, Fiat, Processor, ProcessorRoutingConfig, ProcessorRoutingPurpose } from "@riocrypto/common";
+export interface ResolveProcessorParams {
+    country: Country;
+    fiat: Fiat;
+    purpose: ProcessorRoutingPurpose;
+    routingConfig?: ProcessorRoutingConfig;
+    excludedProcessors?: Processor[];
+    disabledProcessors?: Processor[];
+    customRioBankAccount?: {
+        processor?: Processor;
+    };
+    randomSeed?: number;
+}
+export interface ResolveProcessorResult {
+    processor?: Processor;
+    reason: "customRioBankAccount" | "customRioBankAccountWithoutRail" | "split" | "onlyCandidate" | "enabledRailWithoutShare" | "noEligibleCandidate" | "noEnabledCandidate";
+}
+export declare const resolveProcessor: ({ country, fiat, purpose, routingConfig, excludedProcessors, disabledProcessors, customRioBankAccount, randomSeed, }: ResolveProcessorParams) => ResolveProcessorResult;

package/build/helpers/resolve-processor.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveProcessor = void 0;
+const common_1 = require("@riocrypto/common");
+const getRule = (config, country, fiat, purpose) => { var _a, _b; return (_b = (_a = config === null || config === void 0 ? void 0 : config[country]) === null || _a === void 0 ? void 0 : _a[fiat]) === null || _b === void 0 ? void 0 : _b[purpose]; };
+// Renormalizes over the candidates it is given rather than assuming they still
+// add up to 100, which is what lets a rail drop out - excluded by environment, or
+// switched off by the customer - and have its share absorbed proportionally by
+// the rest.
+const pickByShare = (candidates, position) => {
+    const total = candidates.reduce((acc, c) => acc + c.percentage, 0);
+    let cursor = position * total;
+    for (const candidate of candidates) {
+        cursor -= candidate.percentage;
+        if (cursor < 0) {
+            return candidate.processor;
+        }
+    }
+    // Floating point can leave the cursor a hair above zero on the last step.
+    return candidates[candidates.length - 1].processor;
+};
+// Chooses the payment processor for a buy, a sell or a bank account verification
+// from the configured split.
+//
+// A percentage divides volume between the rails that are actually available to
+// the customer; it is not a switch. A rail left at zero, left out of the rule, or
+// belonging to a corridor with no rule at all still takes their orders when it is
+// the only one they have left enabled, which is why the candidate set comes from
+// the corridor rather than from the rule. Switching a rail off is the only way to
+// keep an order away from it.
+//
+// Does no IO of its own - the routing config and the user's readiness are passed
+// in - and the only nondeterminism is the per-order roll, which a caller can
+// pin down by supplying randomSeed. Because the roll happens once, the answer
+// belongs to the record that stores it: anything that needs to know which rail
+// an existing order uses reads it off the order rather than calling again.
+//
+// Only handles rails that participate in a split. Structural routing that is not
+// a commercial choice - Binance RFQ, COP, USD in the US or Mexico - stays in
+// getProcessor and never reaches here.
+const resolveProcessor = ({ country, fiat, purpose, routingConfig, excludedProcessors, disabledProcessors, customRioBankAccount, randomSeed, }) => {
+    const isEligible = (processor) => !(excludedProcessors === null || excludedProcessors === void 0 ? void 0 : excludedProcessors.includes(processor));
+    // A rail the customer has switched off for this direction is worthless whatever
+    // share it carries: on a buy they cannot send money to it, on a sell their bank
+    // will not accept the credit. Applies to every rail, verifiable or not - a bank
+    // can refuse a wire from Bancrea as easily as a SPEI transfer from Fintoc.
+    //
+    // Verifications are exempt because they are ours to place against an account the
+    // customer gave us, not a rail they have to accept.
+    const isUsable = (processor) => purpose === common_1.ProcessorRoutingPurpose.BankAccountVerification ||
+        !(disabledProcessors === null || disabledProcessors === void 0 ? void 0 : disabledProcessors.includes(processor));
+    // A custom Rio bank account outranks everything on buys, because it is where
+    // the money physically goes: `getBankDetails` returns it in place of the
+    // rail's own destination. Routing the order to a different processor would
+    // leave the order's processor and the account the payin lands in disagreeing,
+    // which breaks deposit matching, payout retry and the readiness gate at once.
+    // Sells and verifications never touch it - both are outbound.
+    if (customRioBankAccount && purpose === common_1.ProcessorRoutingPurpose.Buy) {
+        const { processor } = customRioBankAccount;
+        // Accounts predating the processor field have an unknown rail. Guessing
+        // would reintroduce the very mismatch this is here to prevent, so hand back
+        // to the structural path and leave these users exactly as they were until an
+        // admin records which rail the account belongs to.
+        if (!processor) {
+            return { reason: "customRioBankAccountWithoutRail" };
+        }
+        // Deliberately fail closed rather than fall through to the split. The payin
+        // destination is fixed, so if that rail cannot be used here the only honest
+        // options are to refuse the order or to keep sending payins to a provider we
+        // have stopped watching.
+        if (!isEligible(processor)) {
+            return { reason: "noEligibleCandidate" };
+        }
+        return { processor, reason: "customRioBankAccount" };
+    }
+    // An absent rule is read as every rail at zero rather than as a reason to stop.
+    // Bailing out here would hand the decision to the structural default, which
+    // knows nothing about which rails the customer accepts, and every corridor is
+    // ruleless until an admin first saves one - as is any corridor whose shares
+    // were all cleared, since the settings page stores that as no rule at all.
+    const rule = getRule(routingConfig, country, fiat, purpose);
+    // Starts from the corridor's rails rather than from the rails the rule names,
+    // because a percentage decides how volume is divided between the rails a
+    // customer can use - it is not what makes a rail usable. Also drops any share
+    // stored against a rail this purpose does not serve, which nothing dispatches.
+    const corridorProcessors = (0, common_1.getProcessorsForCorridor)(country, fiat, purpose);
+    const eligible = corridorProcessors.filter(isEligible);
+    if (!eligible.length) {
+        return { reason: "noEligibleCandidate" };
+    }
+    const candidates = eligible.filter(isUsable);
+    if (!candidates.length) {
+        return { reason: "noEnabledCandidate" };
+    }
+    const shares = candidates
+        .map((processor) => {
+        var _a;
+        return ({
+            processor,
+            percentage: Number((_a = rule === null || rule === void 0 ? void 0 : rule.percentages) === null || _a === void 0 ? void 0 : _a[processor]) || 0,
+        });
+    })
+        .filter((candidate) => candidate.percentage > 0);
+    // None of the rails this customer can use carries a share - or no rule is
+    // configured at all - so there is no split to draw from. Refusing the order
+    // would read a zero as "never use this rail", when all it says is where volume
+    // goes while there is somewhere else to send it. Prefers the corridor default
+    // and otherwise the corridor's own order, so the rail a customer in this
+    // position gets is predictable rather than rolled.
+    if (!shares.length) {
+        const fallback = (0, common_1.getDefaultProcessor)(country, fiat, purpose, excludedProcessors);
+        return {
+            processor: fallback && candidates.includes(fallback) ? fallback : candidates[0],
+            reason: "enabledRailWithoutShare",
+        };
+    }
+    if (shares.length === 1) {
+        return { processor: shares[0].processor, reason: "onlyCandidate" };
+    }
+    // Rolled per order, so the realized share converges on the configured
+    // percentages by order count. Nothing is persisted here: a caller that needs
+    // the same answer twice passes back the seed it used.
+    return {
+        processor: pickByShare(shares, randomSeed !== null && randomSeed !== void 0 ? randomSeed : Math.random()),
+        reason: "split",
+    };
+};
+exports.resolveProcessor = resolveProcessor;

package/build/index.d.ts

@@ -87,6 +87,10 @@ export * from "./models/admin-auth-dashboard-settings";
 export * from "./models/STP-mxn-withdrawal";
 export * from "./models/STP-deposit-CLABE";
 export * from "./models/STP-settings";
+export * from "./models/fintoc-mxn-withdrawal";
+export * from "./models/fintoc-deposit-CLABE";
+export * from "./models/processor-readiness";
+export * from "./models/payment-address-verification";
 export * from "./models/alfin-virtual-cci";
 export * from "./models/alfin-settings";
 export * from "./models/alfin-withdrawal";
@@ -175,6 +179,12 @@ export * from "./helpers/generate-idempotency-key-from-order";
 export * from "./helpers/generate-idempotency-key-from-bulk-payout";
 export * from "./helpers/get-is-fireblocks-signature-valid";
 export * from "./helpers/get-processor";
+export * from "./helpers/resolve-processor";
+export * from "./helpers/get-custom-rio-bank-account";
+export * from "./helpers/payin-destinations";
+export * from "./helpers/payin-verification";
+export * from "./helpers/processor-enablement";
+export * from "./helpers/record-observed-processor-readiness";
 export * from "./helpers/get-bulk-payment-from-reference";
 export * from "./helpers/extract-error-message";
 export * from "./helpers/get-exchange-rates-with-markups";

package/build/index.js

@@ -103,6 +103,10 @@ __exportStar(require("./models/admin-auth-dashboard-settings"), exports);
 __exportStar(require("./models/STP-mxn-withdrawal"), exports);
 __exportStar(require("./models/STP-deposit-CLABE"), exports);
 __exportStar(require("./models/STP-settings"), exports);
+__exportStar(require("./models/fintoc-mxn-withdrawal"), exports);
+__exportStar(require("./models/fintoc-deposit-CLABE"), exports);
+__exportStar(require("./models/processor-readiness"), exports);
+__exportStar(require("./models/payment-address-verification"), exports);
 __exportStar(require("./models/alfin-virtual-cci"), exports);
 __exportStar(require("./models/alfin-settings"), exports);
 __exportStar(require("./models/alfin-withdrawal"), exports);
@@ -191,6 +195,12 @@ __exportStar(require("./helpers/generate-idempotency-key-from-order"), exports);
 __exportStar(require("./helpers/generate-idempotency-key-from-bulk-payout"), exports);
 __exportStar(require("./helpers/get-is-fireblocks-signature-valid"), exports);
 __exportStar(require("./helpers/get-processor"), exports);
+__exportStar(require("./helpers/resolve-processor"), exports);
+__exportStar(require("./helpers/get-custom-rio-bank-account"), exports);
+__exportStar(require("./helpers/payin-destinations"), exports);
+__exportStar(require("./helpers/payin-verification"), exports);
+__exportStar(require("./helpers/processor-enablement"), exports);
+__exportStar(require("./helpers/record-observed-processor-readiness"), exports);
 __exportStar(require("./helpers/get-bulk-payment-from-reference"), exports);
 __exportStar(require("./helpers/extract-error-message"), exports);
 __exportStar(require("./helpers/get-exchange-rates-with-markups"), exports);

package/build/middlewares/get-order.js

@@ -39,6 +39,7 @@ const getOrder = (req, res, next, mongoose, onlyBankOrders) => __awaiter(void 0,
                 common_1.Processor.SPID,
                 common_1.Processor.SPEI_NVIO,
                 common_1.Processor.SPEI_STP,
+                common_1.Processor.SPEI_FINTOC,
             ].includes(order.processor)) {
                 req.order = order;
             }

package/build/models/bank-account-verification.d.ts

@@ -6,7 +6,7 @@ interface BankAccountVerificationAttrs {
     bankAccountId: string;
     status: BankAccountVerificationStatus;
     amount: number;
-    provider?: Processor.SPEI_STP | Processor.SPEI_NVIO | Processor.Alfin;
+    provider?: Processor.SPEI_STP | Processor.SPEI_NVIO | Processor.Alfin | Processor.SPEI_FINTOC;
     providerWithdrawalId?: string;
     SPEITrackingNumber?: string;
     CEPLink?: string;
@@ -21,7 +21,7 @@ interface BankAccountVerificationDoc extends Document {
     bankAccountId: string;
     status: BankAccountVerificationStatus;
     amount: number;
-    provider?: Processor.SPEI_STP | Processor.SPEI_NVIO | Processor.Alfin;
+    provider?: Processor.SPEI_STP | Processor.SPEI_NVIO | Processor.Alfin | Processor.SPEI_FINTOC;
     providerWithdrawalId?: string;
     SPEITrackingNumber?: string;
     CEPLink?: string;

package/build/models/bulk-bank-payment.js

@@ -48,6 +48,9 @@ const buildBulkBankPayment = (mongoose) => {
         bankAddress: {
             type: String,
         },
+        accountNumber: {
+            type: String,
+        },
         status: {
             type: String,
             required: true,

package/build/models/fintoc-deposit-CLABE.d.ts

@@ -0,0 +1,28 @@
+import { Mongoose, Model, Document, HydratedDocument } from "mongoose";
+interface FintocDepositCLABEAttrs {
+    createdAt: Date;
+    userId: string;
+    CLABE: string;
+    fintocAccountNumberId?: string;
+    processedFintocEventIds?: string[];
+    orderId?: string;
+    metadata?: Record<string, string>;
+    disabled?: boolean;
+    disabledAt?: Date;
+}
+interface FintocDepositCLABEDoc extends Document {
+    createdAt: Date;
+    userId: string;
+    CLABE: string;
+    fintocAccountNumberId?: string;
+    processedFintocEventIds?: string[];
+    orderId?: string;
+    metadata?: Record<string, string>;
+    disabled?: boolean;
+    disabledAt?: Date;
+}
+interface FintocDepositCLABEModel extends Model<FintocDepositCLABEDoc> {
+    build(attrs: FintocDepositCLABEAttrs): HydratedDocument<FintocDepositCLABEDoc>;
+}
+declare const buildFintocDepositCLABE: (mongoose: Mongoose) => FintocDepositCLABEModel;
+export { buildFintocDepositCLABE, FintocDepositCLABEDoc, FintocDepositCLABEAttrs, };

package/build/models/fintoc-deposit-CLABE.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFintocDepositCLABE = void 0;
+const buildFintocDepositCLABE = (mongoose) => {
+    if (mongoose.models.FintocDepositCLABE) {
+        return mongoose.model("FintocDepositCLABE");
+    }
+    const FintocDepositCLABESchema = new mongoose.Schema({
+        userId: {
+            type: String,
+        },
+        CLABE: {
+            type: String,
+        },
+        fintocAccountNumberId: {
+            type: String,
+        },
+        processedFintocEventIds: {
+            type: [String],
+            default: [],
+        },
+        orderId: {
+            type: String,
+            index: { unique: true, sparse: true },
+        },
+        metadata: {
+            type: mongoose.Schema.Types.Mixed,
+        },
+        disabled: {
+            type: Boolean,
+            default: false,
+        },
+        disabledAt: {
+            type: mongoose.Schema.Types.Date,
+        },
+        createdAt: {
+            type: mongoose.Schema.Types.Date,
+            required: true,
+        },
+    }, {
+        toJSON: {
+            transform(doc, ret) {
+                ret.id = ret._id.valueOf();
+                delete ret._id;
+                delete ret.__v;
+            },
+        },
+    });
+    FintocDepositCLABESchema.index({ userId: 1 }, { unique: true });
+    FintocDepositCLABESchema.statics.build = (attrs) => {
+        return new FintocDepositCLABE(attrs);
+    };
+    const FintocDepositCLABE = mongoose.model("FintocDepositCLABE", FintocDepositCLABESchema);
+    return FintocDepositCLABE;
+};
+exports.buildFintocDepositCLABE = buildFintocDepositCLABE;

package/build/models/fintoc-mxn-withdrawal.d.ts

@@ -0,0 +1,51 @@
+import { FintocMXNWithdrawalStatus } from "@riocrypto/common";
+import { Mongoose, Model, Document, HydratedDocument } from "mongoose";
+interface FintocMXNWithdrawalAttrs {
+    createdAt: Date;
+    type: "transaction" | "bankAccountVerification" | "liquidityOrder" | "internalTransfer";
+    orderId?: string;
+    numberOfParts?: number;
+    partsCompleted?: number;
+    bankAccountVerificationId?: string;
+    bulkBankPayoutId?: string;
+    internalTransferId?: string;
+    withdrawalIdempotencyKey?: string;
+    FintocWithdrawals: {
+        uuid: string;
+        fintocTransferId?: string;
+        trackingKey?: string;
+        idempotencyKey?: string;
+        partNumber: number;
+        amount: number;
+        reference: string;
+        status: FintocMXNWithdrawalStatus;
+    }[];
+    orderVersion?: number;
+}
+interface FintocMXNWithdrawalDoc extends Document {
+    createdAt: Date;
+    type: "transaction" | "bankAccountVerification" | "liquidityOrder" | "internalTransfer";
+    orderId?: string;
+    bankAccountVerificationId?: string;
+    numberOfParts?: number;
+    bulkBankPayoutId?: string;
+    internalTransferId?: string;
+    withdrawalIdempotencyKey?: string;
+    partsCompleted?: number;
+    orderVersion?: number;
+    FintocWithdrawals: {
+        uuid: string;
+        fintocTransferId?: string;
+        trackingKey?: string;
+        idempotencyKey?: string;
+        partNumber: number;
+        amount: number;
+        status: FintocMXNWithdrawalStatus;
+        reference: string;
+    }[];
+}
+interface FintocMXNWithdrawalModel extends Model<FintocMXNWithdrawalDoc> {
+    build(attrs: FintocMXNWithdrawalAttrs): HydratedDocument<FintocMXNWithdrawalDoc>;
+}
+declare const buildFintocMXNWithdrawal: (mongoose: Mongoose) => FintocMXNWithdrawalModel;
+export { buildFintocMXNWithdrawal, FintocMXNWithdrawalDoc, FintocMXNWithdrawalAttrs, };

package/build/models/fintoc-mxn-withdrawal.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFintocMXNWithdrawal = void 0;
+const common_1 = require("@riocrypto/common");
+const buildFintocMXNWithdrawal = (mongoose) => {
+    if (mongoose.models.FintocMXNWithdrawal) {
+        return mongoose.model("FintocMXNWithdrawal");
+    }
+    const FintocMXNWithdrawalSchema = new mongoose.Schema({
+        orderId: {
+            type: String,
+            index: { unique: true, sparse: true },
+        },
+        bankAccountVerificationId: {
+            type: String,
+            index: { unique: true, sparse: true },
+        },
+        internalTransferId: {
+            type: String,
+            index: { unique: true, sparse: true },
+        },
+        withdrawalIdempotencyKey: {
+            type: String,
+            index: { unique: true, sparse: true },
+        },
+        bulkBankPayoutId: {
+            type: String,
+            index: { unique: true, sparse: true },
+        },
+        numberOfParts: {
+            type: Number,
+        },
+        partsCompleted: {
+            type: Number,
+        },
+        type: {
+            type: String,
+            required: true,
+        },
+        createdAt: {
+            type: mongoose.Schema.Types.Date,
+            required: true,
+        },
+        FintocWithdrawals: {
+            type: [
+                {
+                    uuid: String,
+                    fintocTransferId: String,
+                    trackingKey: String,
+                    idempotencyKey: String,
+                    amount: Number,
+                    status: {
+                        type: String,
+                        enum: Object.values(common_1.FintocMXNWithdrawalStatus),
+                    },
+                    partNumber: Number,
+                    reference: String,
+                },
+            ],
+        },
+        orderVersion: {
+            type: Number,
+        },
+    }, {
+        toJSON: {
+            transform(doc, ret) {
+                ret.id = ret._id.valueOf();
+                delete ret._id;
+                delete ret.__v;
+                if (ret.FintocWithdrawals && Array.isArray(ret.FintocWithdrawals)) {
+                    ret.FintocWithdrawals = ret.FintocWithdrawals.map((withdrawal) => {
+                        if (withdrawal._id) {
+                            withdrawal.id = withdrawal._id.valueOf();
+                            delete withdrawal._id;
+                        }
+                        return withdrawal;
+                    });
+                }
+            },
+        },
+    });
+    FintocMXNWithdrawalSchema.statics.build = (attrs) => {
+        return new FintocMXNWithdrawal(attrs);
+    };
+    const FintocMXNWithdrawal = mongoose.model("FintocMXNWithdrawal", FintocMXNWithdrawalSchema);
+    return FintocMXNWithdrawal;
+};
+exports.buildFintocMXNWithdrawal = buildFintocMXNWithdrawal;

package/build/models/fireblocks-vault.d.ts

@@ -18,6 +18,10 @@ interface FireblocksVaultAttrs {
         bulkCryptoPaymentId: string;
         crypto: Crypto;
     }[];
+    activePaymentAddressVerifications?: {
+        verificationId: string;
+        crypto: Crypto;
+    }[];
 }
 interface FireblocksVaultDoc extends mongoose.Document {
     userId: string;
@@ -37,6 +41,10 @@ interface FireblocksVaultDoc extends mongoose.Document {
         bulkCryptoPaymentId: string;
         crypto: Crypto;
     }[];
+    activePaymentAddressVerifications?: {
+        verificationId: string;
+        crypto: Crypto;
+    }[];
 }
 interface FireblocksVaultModel extends mongoose.Model<FireblocksVaultDoc> {
     build(attrs: FireblocksVaultAttrs): HydratedDocument<FireblocksVaultDoc>;

package/build/models/fireblocks-vault.js

@@ -38,6 +38,14 @@ const buildFireblocksVault = (mongoose) => {
                 },
             ],
         },
+        activePaymentAddressVerifications: {
+            type: [
+                {
+                    verificationId: String,
+                    crypto: String,
+                },
+            ],
+        },
     }, {
         toJSON: {
             transform(doc, ret) {

package/build/models/internal-balances.d.ts

@@ -46,6 +46,9 @@ interface InternalBalancesDoc extends mongoose.Document {
     STP: {
         [key in Fiat & Crypto]: number;
     };
+    fintoc: {
+        [key in Fiat & Crypto]: number;
+    };
     alfin: {
         [key in Fiat & Crypto]: number;
     };

package/build/models/internal-balances.js

@@ -71,6 +71,9 @@ const buildInternalBalances = (mongoose) => {
         [common_1.TreasuryProvider.Alfin]: {
             type: Object,
         },
+        [common_1.TreasuryProvider.Fintoc]: {
+            type: Object,
+        },
     }, {
         toJSON: {
             transform(doc, ret) {

package/build/models/payment-address-verification.d.ts

@@ -0,0 +1,49 @@
+import { Crypto, ProcessorReadinessStatus, ProcessorReadinessVerificationMethod } from "@riocrypto/common";
+import { Mongoose, Model, Document, HydratedDocument } from "mongoose";
+interface PaymentAddressVerificationAttrs {
+    createdAt: Date;
+    userId: string;
+    crypto: Crypto;
+    fireblocksVaultId: string;
+    address: string;
+    memo?: string;
+    status: ProcessorReadinessStatus;
+    testAmount?: number;
+    observedTransfer?: {
+        amount: number;
+        blockchainTxId?: string;
+        fireblocksTransferId?: string;
+        originBlockchainAddress?: string;
+        receivedAt: Date;
+    };
+    verifiedAt?: Date;
+    verifiedVia?: ProcessorReadinessVerificationMethod;
+    verifiedByAdminId?: string;
+    verificationNote?: string;
+}
+interface PaymentAddressVerificationDoc extends Document {
+    createdAt: Date;
+    userId: string;
+    crypto: Crypto;
+    fireblocksVaultId: string;
+    address: string;
+    memo?: string;
+    status: ProcessorReadinessStatus;
+    testAmount?: number;
+    observedTransfer?: {
+        amount: number;
+        blockchainTxId?: string;
+        fireblocksTransferId?: string;
+        originBlockchainAddress?: string;
+        receivedAt: Date;
+    };
+    verifiedAt?: Date;
+    verifiedVia?: ProcessorReadinessVerificationMethod;
+    verifiedByAdminId?: string;
+    verificationNote?: string;
+}
+interface PaymentAddressVerificationModel extends Model<PaymentAddressVerificationDoc> {
+    build(attrs: PaymentAddressVerificationAttrs): HydratedDocument<PaymentAddressVerificationDoc>;
+}
+declare const buildPaymentAddressVerification: (mongoose: Mongoose) => PaymentAddressVerificationModel;
+export { buildPaymentAddressVerification, PaymentAddressVerificationDoc, PaymentAddressVerificationAttrs, };

package/build/models/payment-address-verification.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPaymentAddressVerification = void 0;
+// What we have proven about one crypto address a user pays us at. See the
+// PaymentAddressVerification type in common for why this exists and why it is
+// keyed by vault rather than by address.
+const buildPaymentAddressVerification = (mongoose) => {
+    if (mongoose.models.PaymentAddressVerification) {
+        return mongoose.model("PaymentAddressVerification");
+    }
+    const PaymentAddressVerificationSchema = new mongoose.Schema({
+        userId: {
+            type: String,
+            required: true,
+        },
+        crypto: {
+            type: String,
+            required: true,
+        },
+        fireblocksVaultId: {
+            type: String,
+            required: true,
+        },
+        address: {
+            type: String,
+            required: true,
+        },
+        memo: {
+            type: String,
+        },
+        status: {
+            type: String,
+            required: true,
+        },
+        testAmount: {
+            type: Number,
+        },
+        observedTransfer: {
+            type: Object,
+        },
+        verifiedAt: {
+            type: mongoose.Schema.Types.Date,
+        },
+        verifiedVia: {
+            type: String,
+        },
+        verifiedByAdminId: {
+            type: String,
+        },
+        verificationNote: {
+            type: String,
+        },
+        createdAt: {
+            type: mongoose.Schema.Types.Date,
+            required: true,
+        },
+    }, {
+        toJSON: {
+            transform(doc, ret) {
+                ret.id = ret._id.valueOf();
+                delete ret._id;
+                delete ret.__v;
+            },
+        },
+    });
+    // One record per address, where an address is a vault and an asset. Unique
+    // because the inbound webhook and a customer starting a test can arrive at the
+    // same moment, and two records disagreeing about status would let a test
+    // deposit match a row that nobody is looking at.
+    PaymentAddressVerificationSchema.index({ userId: 1, crypto: 1, fireblocksVaultId: 1 }, { unique: true });
+    PaymentAddressVerificationSchema.statics.build = (attrs) => {
+        return new PaymentAddressVerification(attrs);
+    };
+    const PaymentAddressVerification = mongoose.model("PaymentAddressVerification", PaymentAddressVerificationSchema);
+    return PaymentAddressVerification;
+};
+exports.buildPaymentAddressVerification = buildPaymentAddressVerification;