@riocrypto/common-server 1.0.2479 → 1.0.2481

package/build/clients/cluster-client.d.ts

@@ -1,4 +1,4 @@
-import { Quote, Fiat, Crypto, BitsoBankAccount, Side, Country, Order, CryptoAddress, BankAccount, ChainedQuote, AuthRole, Auth, ImportOrderData, TreasuryProvider, FXProvider, EmarketsFXTrade, ExternalTradingAlgorithm, ExternalTrade, ExternalTradeType, ExternalTradingProvider, ExternalTradingAlgorithmType, STPMXNWithdrawal, AuthPermission, DeferredPaymentType, TwoWaySettlementType, OrderType, EmarketsSettlementType, EmarketsOrderType } from "@riocrypto/common";
+import { Quote, Fiat, Crypto, BitsoBankAccount, Side, Country, Order, CryptoAddress, BankAccount, AuthRole, Auth, ImportOrderData, TreasuryProvider, FXProvider, EmarketsFXTrade, ExternalTradingAlgorithm, ExternalTrade, ExternalTradeType, ExternalTradingProvider, ExternalTradingAlgorithmType, STPMXNWithdrawal, AuthPermission, DeferredPaymentType, TwoWaySettlementType, OrderType, EmarketsSettlementType, EmarketsOrderType } from "@riocrypto/common";
 declare class ClusterClient {
     private baseUrl;
     private clusterApiKey;
@@ -30,8 +30,6 @@ declare class ClusterClient {
         timeInForceStartsAt?: Date;
         timeInForceEndsAt?: Date;
     }): Promise<Quote>;
-    getNewChainedQuote(chainedOrderId: string, chainedQuote: ChainedQuote, newOriginAmount?: number): Promise<ChainedQuote>;
-    getBidQuote(userId: string, side: Side, country: Country, fiat: Fiat, crypto: Crypto, amountFiat?: number, amountCrypto?: number, USBankTransferMethod?: "ach_push" | "wire", netPrice?: string): Promise<Quote>;
     getCryptoAddresses(userId: string, crypto: Crypto): Promise<CryptoAddress[]>;
     createOrder({ quoteId, userAddressId, payoutBankAccountId, parentOrderId, notes, isAxeTaker, }: {
         quoteId: string;

package/build/clients/cluster-client.js

@@ -103,50 +103,6 @@ class ClusterClient {
             return response.data.quote;
         });
     }
-    getNewChainedQuote(chainedOrderId, chainedQuote, newOriginAmount) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.axios.post(`${this.baseUrl}/api/quotes/chained`, {
-                chainedOrderId,
-                originFiat: chainedQuote.originFiat,
-                destinationFiat: chainedQuote.destinationFiat,
-                originAmountFiat: newOriginAmount,
-                originUserId: chainedQuote.originUserId,
-                destinationUserId: chainedQuote.destinationUserId,
-                crypto: chainedQuote.crypto,
-                originCountry: chainedQuote.originCountry,
-                destinationCountry: chainedQuote.destinationCountry,
-                discount: chainedQuote.discount,
-                markup: chainedQuote.markup,
-                noMarkups: chainedQuote.noMarkups,
-                reissueAfterExpiration: chainedQuote.reissueAfterExpiration,
-            }, {
-                headers: {
-                    "x-cluster-api-key": this.clusterApiKey,
-                },
-            });
-            return response.data.chainedQuote;
-        });
-    }
-    getBidQuote(userId, side, country, fiat, crypto, amountFiat, amountCrypto, USBankTransferMethod, netPrice) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.axios.post(`${this.baseUrl}/api/quotes`, {
-                userId,
-                side,
-                crypto,
-                fiat,
-                amountFiat,
-                amountCrypto,
-                country,
-                USBankTransferMethod,
-                netPrice,
-            }, {
-                headers: {
-                    "x-cluster-api-key": this.clusterApiKey,
-                },
-            });
-            return response.data.quote;
-        });
-    }
     getCryptoAddresses(userId, crypto) {
         return __awaiter(this, void 0, void 0, function* () {
             const response = yield this.axios.get(`${this.baseUrl}/api/addresses?userId=${userId}&crypto=${crypto}`, {

package/build/clients/fireblocks-client.d.ts

@@ -27,7 +27,7 @@ declare class FireblocksClient {
     getExchangeFiatBalance(): Promise<number>;
     getTransactions(vaultId: string, crypto: Crypto, nextPage?: string): Promise<any>;
     getDepositAddress(vaultId: string, crypto: Crypto): Promise<string>;
-    createVault(userId: string, name: string, type: "transactional" | "managed", number?: number): Promise<string>;
+    createVault(userId: string, name: string, type: "transactional", number?: number): Promise<string>;
     createWallet(vaultId: string, crypto: Crypto): Promise<string>;
     internalTransfer(rioId: string, crypto: Crypto, sourceVaultId: string, destinationVaultId: string, amountCrypto: number, notes?: string): Promise<string>;
     externalTransfer(rioId: string, crypto: Crypto, sourceVaultId: string, destinationAddress: string, amountCrypto: number, notes?: string): Promise<string>;

package/build/clients/secret-manager-client.d.ts

@@ -8,22 +8,34 @@ declare class SecretManagerClient {
     private readonly POLL_INTERVAL_MS;
     constructor(env: RioEnv);
     /**
-     * Get a secret value from cache or fetch it from Secret Manager
-     * Once fetched, the secret will be cached and automatically refreshed every 15 seconds
+     * Get a secret value from cache or fetch the entire secret file
+     * Once fetched, all secrets are cached and automatically refreshed every hour
      */
     getSecretValue(secretId: string): Promise<string | null>;
     /**
-     * Fetch a secret value directly from Secret Manager without using the cache
+     * Refresh the entire secret cache by fetching the complete secret file
      */
-    private fetchSecretValue;
+    private refreshSecretCache;
     /**
-     * Set up cache entry with polling for a secret
+     * Set up cache with polling for the entire secret file
      */
     private setupCacheWithPolling;
     /**
-     * Clear the cache for a specific secret or all secrets
+     * Clear the entire secret cache
      */
-    clearCache(secretId?: string): void;
+    clearCache(): void;
+    /**
+     * Get all cached secrets (useful for debugging)
+     */
+    getAllSecrets(): Record<string, string> | null;
+    /**
+     * Get cache status information
+     */
+    getCacheStatus(): {
+        isLoaded: boolean;
+        secretCount: number;
+        lastFetched: Date | null;
+    };
 }
 export declare const secretManagerClient: SecretManagerClient;
 export {};

package/build/clients/secret-manager-client.js

@@ -39,7 +39,7 @@ const fs = __importStar(require("fs"));
 class SecretManagerClient {
     constructor(env) {
         this.env = env;
-        this.secretCache = new Map();
+        this.secretCache = null;
         this.POLL_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
         const secretFilePath = "/etc/secrets/secret-manager/secret-manager-service-account-key.json";
         const secretFileContents = fs.readFileSync(secretFilePath, "utf8");
@@ -56,29 +56,34 @@ class SecretManagerClient {
         });
     }
     /**
-     * Get a secret value from cache or fetch it from Secret Manager
-     * Once fetched, the secret will be cached and automatically refreshed every 15 seconds
+     * Get a secret value from cache or fetch the entire secret file
+     * Once fetched, all secrets are cached and automatically refreshed every hour
      */
     getSecretValue(secretId) {
         return __awaiter(this, void 0, void 0, function* () {
-            // Check if the secret is already in the cache
-            const cachedSecret = this.secretCache.get(secretId);
-            if (cachedSecret) {
-                return cachedSecret.value;
+            // Check if we have a cache and the secret exists
+            if (this.secretCache && this.secretCache.secrets[secretId]) {
+                return this.secretCache.secrets[secretId];
             }
-            // If not in cache, fetch it and set up polling
-            const value = yield this.fetchSecretValue(secretId);
-            if (value) {
-                this.setupCacheWithPolling(secretId, value);
+            // If not in cache or cache doesn't exist, fetch entire secret file
+            const success = yield this.refreshSecretCache();
+            if (!success) {
+                return null;
             }
-            return value;
+            // Check again after refresh
+            if (this.secretCache && this.secretCache.secrets[secretId]) {
+                return this.secretCache.secrets[secretId];
+            }
+            // Secret not found even after refresh
+            console.error(`Secret ${secretId} not found in secret file`);
+            return null;
         });
     }
     /**
-     * Fetch a secret value directly from Secret Manager without using the cache
+     * Refresh the entire secret cache by fetching the complete secret file
      */
-    fetchSecretValue(secretId) {
-        var _a, _b;
+    refreshSecretCache() {
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
             let file;
             if (this.env === common_1.RioEnv.Development) {
@@ -105,7 +110,14 @@ class SecretManagerClient {
                         throw new Error("No payload data");
                     }
                     const secrets = JSON.parse(version.payload.data.toString());
-                    return secrets[secretId];
+                    // Clear existing polling if it exists
+                    if ((_c = this.secretCache) === null || _c === void 0 ? void 0 : _c.pollingInterval) {
+                        clearInterval(this.secretCache.pollingInterval);
+                    }
+                    // Set up new cache with polling
+                    this.setupCacheWithPolling(secrets);
+                    console.info(`Refreshed ${Object.keys(secrets).length} secrets from ${file}`);
+                    return true;
                 }
                 catch (err) {
                     attempt++;
@@ -117,74 +129,77 @@ class SecretManagerClient {
                         continue;
                     }
                     else {
-                        console.error(`Failed to access secret ${secretId}:`, err);
-                        return null;
+                        console.error(`Failed to access secret file ${file}:`, err);
+                        return false;
                     }
                 }
             }
-            console.error(`Failed to access secret ${secretId} after ${maxRetries} attempts.`);
-            return null;
+            console.error(`Failed to access secret file ${file} after ${maxRetries} attempts.`);
+            return false;
         });
     }
     /**
-     * Set up cache entry with polling for a secret
+     * Set up cache with polling for the entire secret file
      */
-    setupCacheWithPolling(secretId, initialValue) {
+    setupCacheWithPolling(secrets) {
         // Only set up polling in non-test environments
         if (process.env.NODE_ENV === "test") {
-            // For test environments, just cache the value without polling
-            this.secretCache.set(secretId, {
-                value: initialValue,
+            // For test environments, just cache the secrets without polling
+            this.secretCache = {
+                secrets,
                 pollingInterval: null,
-            });
+                lastFetched: new Date(),
+            };
             return;
         }
-        // Set up polling interval to refresh the secret
+        // Set up polling interval to refresh all secrets
         const pollingInterval = setInterval(() => __awaiter(this, void 0, void 0, function* () {
             try {
-                const newValue = yield this.fetchSecretValue(secretId);
-                if (newValue) {
-                    const currentCached = this.secretCache.get(secretId);
-                    // Only update and log if the value has changed
-                    if (currentCached && currentCached.value !== newValue) {
-                        console.info(`Secret ${secretId} has been updated`);
-                        this.secretCache.set(secretId, {
-                            value: newValue,
-                            pollingInterval: currentCached.pollingInterval,
-                        });
-                    }
+                const success = yield this.refreshSecretCache();
+                if (!success) {
+                    console.error("Failed to refresh secret cache during polling");
                 }
             }
             catch (error) {
-                console.error(`Error polling secret ${secretId}:`, error);
+                console.error("Error polling secrets:", error);
             }
         }), this.POLL_INTERVAL_MS);
-        // Store the initial value and polling interval
-        this.secretCache.set(secretId, {
-            value: initialValue,
+        // Store the cache with polling interval
+        this.secretCache = {
+            secrets,
             pollingInterval,
-        });
+            lastFetched: new Date(),
+        };
     }
     /**
-     * Clear the cache for a specific secret or all secrets
+     * Clear the entire secret cache
      */
-    clearCache(secretId) {
-        if (secretId) {
-            const cached = this.secretCache.get(secretId);
-            if (cached && cached.pollingInterval) {
-                clearInterval(cached.pollingInterval);
-            }
-            this.secretCache.delete(secretId);
-        }
-        else {
-            // Clear all cached secrets
-            this.secretCache.forEach((cached) => {
-                if (cached.pollingInterval) {
-                    clearInterval(cached.pollingInterval);
-                }
-            });
-            this.secretCache.clear();
+    clearCache() {
+        var _a;
+        if ((_a = this.secretCache) === null || _a === void 0 ? void 0 : _a.pollingInterval) {
+            clearInterval(this.secretCache.pollingInterval);
         }
+        this.secretCache = null;
+    }
+    /**
+     * Get all cached secrets (useful for debugging)
+     */
+    getAllSecrets() {
+        var _a;
+        return ((_a = this.secretCache) === null || _a === void 0 ? void 0 : _a.secrets) || null;
+    }
+    /**
+     * Get cache status information
+     */
+    getCacheStatus() {
+        var _a;
+        return {
+            isLoaded: !!this.secretCache,
+            secretCount: this.secretCache
+                ? Object.keys(this.secretCache.secrets).length
+                : 0,
+            lastFetched: ((_a = this.secretCache) === null || _a === void 0 ? void 0 : _a.lastFetched) || null,
+        };
     }
 }
 exports.secretManagerClient = new SecretManagerClient(process.env.RIO_ENV || process.env.NEXT_PUBLIC_RIO_ENV);

package/build/index.d.ts

@@ -40,8 +40,6 @@ export * from "./models/invoice";
 export * from "./models/mismatched-bank-payment";
 export * from "./models/bank-transfer";
 export * from "./models/webhook-registration";
-export * from "./models/chained-quote";
-export * from "./models/chained-order";
 export * from "./models/bitso-bank-account";
 export * from "./models/bitso-receiving-account";
 export * from "./models/bitso-fx-order";
@@ -52,7 +50,6 @@ export * from "./models/circle-payout";
 export * from "./models/market-data";
 export * from "./models/telegram-session";
 export * from "./models/temporary-verification";
-export * from "./models/bid";
 export * from "./models/rio-bank-account";
 export * from "./models/address-verification";
 export * from "./models/bank-account-verification";

package/build/index.js

@@ -56,8 +56,6 @@ __exportStar(require("./models/invoice"), exports);
 __exportStar(require("./models/mismatched-bank-payment"), exports);
 __exportStar(require("./models/bank-transfer"), exports);
 __exportStar(require("./models/webhook-registration"), exports);
-__exportStar(require("./models/chained-quote"), exports);
-__exportStar(require("./models/chained-order"), exports);
 __exportStar(require("./models/bitso-bank-account"), exports);
 __exportStar(require("./models/bitso-receiving-account"), exports);
 __exportStar(require("./models/bitso-fx-order"), exports);
@@ -68,7 +66,6 @@ __exportStar(require("./models/circle-payout"), exports);
 __exportStar(require("./models/market-data"), exports);
 __exportStar(require("./models/telegram-session"), exports);
 __exportStar(require("./models/temporary-verification"), exports);
-__exportStar(require("./models/bid"), exports);
 __exportStar(require("./models/rio-bank-account"), exports);
 __exportStar(require("./models/address-verification"), exports);
 __exportStar(require("./models/bank-account-verification"), exports);

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

@@ -2,7 +2,7 @@ import { Crypto } from "@riocrypto/common";
 import mongoose from "mongoose";
 interface FireblocksVaultAttrs {
     userId: string;
-    type: "transactional" | "managed";
+    type: "transactional";
     fireblocksVaultId: string;
     depositAddresses?: {
         [key: string]: string;
@@ -18,7 +18,7 @@ interface FireblocksVaultAttrs {
 }
 interface FireblocksVaultDoc extends mongoose.Document {
     userId: string;
-    type: "transactional" | "managed";
+    type: "transactional";
     fireblocksVaultId: string;
     depositAddresses?: {
         [key: string]: string;

package/build/models/order.d.ts

@@ -42,11 +42,9 @@ interface OrderAttrs {
     markup?: number;
     expiredQuotes?: string[];
     imported?: boolean;
-    managedWallet?: boolean;
     USBankTransferMethod?: "wire" | "ach_push";
     isAfterHours?: boolean;
     isSurgePricing?: boolean;
-    chainedOrderId?: string;
     netPrice: number;
     requestedNetPrice?: number;
     payoutAddressId?: string;
@@ -173,10 +171,8 @@ interface OrderDoc extends Document {
     markup?: number;
     expiredQuotes?: string[];
     imported?: boolean;
-    managedWallet?: boolean;
     USBankTransferMethod?: "wire" | "ach_push";
     isAfterHours?: boolean;
-    chainedOrderId?: string;
     netPrice: number;
     requestedNetPrice?: number;
     payoutAddressId?: string;

package/build/models/order.js

@@ -199,18 +199,12 @@ const buildOrder = (mongoose) => {
         imported: {
             type: Boolean,
         },
-        managedWallet: {
-            type: Boolean,
-        },
         USBankTransferMethod: {
             type: String,
         },
         isAfterHours: {
             type: Boolean,
         },
-        chainedOrderId: {
-            type: String,
-        },
         exchangeRateOrders: [
             {
                 amount: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riocrypto/common-server",
-  "version": "1.0.2479",
+  "version": "1.0.2481",
   "description": "",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -28,7 +28,7 @@
     "@google-cloud/secret-manager": "^5.3.0",
     "@google-cloud/storage": "^6.9.5",
     "@hyperdx/node-opentelemetry": "^0.7.0",
-    "@riocrypto/common": "^1.0.2246",
+    "@riocrypto/common": "^1.0.2249",
     "@types/express": "^4.17.13",
     "axios": "^1.7.4",
     "crypto-js": "^4.2.0",

package/build/models/bid.d.ts

@@ -1,31 +0,0 @@
-import { BidStatus } from "@riocrypto/common";
-import { Mongoose, Model, Document } from "mongoose";
-interface BidAttrs {
-    createdAt: Date;
-    userId: string;
-    quoteId: string;
-    status: BidStatus;
-    message?: string;
-    notes?: string;
-    file?: string;
-    cryptoAddress?: string;
-    USBankTransferMethod?: "wire" | "ach_push";
-    externalAccountId?: string;
-}
-interface BidDoc extends Document {
-    createdAt: Date;
-    userId: string;
-    quoteId: string;
-    status: BidStatus;
-    message?: string;
-    notes?: string;
-    file?: string;
-    cryptoAddress?: string;
-    USBankTransferMethod?: "wire" | "ach_push";
-    externalAccountId?: string;
-}
-interface BidModel extends Model<BidDoc> {
-    build(attrs: BidAttrs): BidDoc;
-}
-declare const buildBid: (mongoose: Mongoose) => BidModel;
-export { buildBid, BidDoc, BidAttrs };

package/build/models/bid.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildBid = void 0;
-const buildBid = (mongoose) => {
-    // if model is already defined, return it
-    if (mongoose.models.Bid) {
-        return mongoose.model("Bid");
-    }
-    const BidSchema = new mongoose.Schema({
-        createdAt: {
-            type: mongoose.Schema.Types.Date,
-            required: true,
-        },
-        userId: {
-            type: String,
-            required: true,
-        },
-        quoteId: {
-            type: String,
-            required: true,
-        },
-        status: {
-            type: String,
-            required: true,
-        },
-        message: {
-            type: String,
-        },
-        notes: {
-            type: String,
-        },
-        file: {
-            type: String,
-        },
-        cryptoAddress: {
-            type: String,
-        },
-        USBankTransferMethod: {
-            type: String,
-        },
-        externalAccountId: {
-            type: String,
-        },
-    }, {
-        toJSON: {
-            transform(doc, ret) {
-                ret.id = ret._id.valueOf();
-                delete ret._id;
-                delete ret.__v;
-            },
-        },
-    });
-    BidSchema.statics.build = (attrs) => {
-        return new Bid(attrs);
-    };
-    const Bid = mongoose.model("Bid", BidSchema);
-    return Bid;
-};
-exports.buildBid = buildBid;

package/build/models/chained-order.d.ts

@@ -1,65 +0,0 @@
-import { Country, Fees, Fiat, Crypto, OrderStatus, Processor } from "@riocrypto/common";
-import { Mongoose, Model, Document } from "mongoose";
-interface ChainedOrderAttrs {
-    originUserId: string;
-    destinationUserId: string;
-    chainedQuoteId: string;
-    crypto: Crypto;
-    price: number;
-    originFiat: Fiat;
-    destinationFiat: Fiat;
-    originCountry: Country;
-    destinationCountry: Country;
-    originAmountFiat: number;
-    destinationAmountFiat: number;
-    originOrderId: string;
-    destinationOrderId: string;
-    originOrderStatus: OrderStatus;
-    destinationOrderStatus: OrderStatus;
-    originOrderProcessor: Processor;
-    destinationOrderProcessor: Processor;
-    destinationBankAccountId?: string;
-    fees: Fees;
-    createdAt: Date;
-    brokerId?: string;
-    notes?: string;
-    netPrice: number;
-    requestedNetPrice?: number;
-    markup?: number;
-    discount?: number;
-    expiredQuotes?: string[];
-}
-interface ChainedOrderDoc extends Document {
-    originUserId: string;
-    destinationUserId: string;
-    chainedQuoteId: string;
-    crypto: Crypto;
-    price: number;
-    originFiat: Fiat;
-    destinationFiat: Fiat;
-    originCountry: Country;
-    destinationCountry: Country;
-    originAmountFiat: number;
-    destinationAmountFiat: number;
-    originOrderId: string;
-    destinationOrderId: string;
-    originOrderStatus: OrderStatus;
-    destinationOrderStatus: OrderStatus;
-    originOrderProcessor: Processor;
-    destinationOrderProcessor: Processor;
-    destinationBankAccountId?: string;
-    fees: Fees;
-    createdAt: Date;
-    brokerId?: string;
-    notes?: string;
-    netPrice: number;
-    requestedNetPrice?: number;
-    markup?: number;
-    discount?: number;
-    expiredQuotes?: string[];
-}
-interface ChainedOrderModel extends Model<ChainedOrderDoc> {
-    build(attrs: ChainedOrderAttrs): ChainedOrderDoc;
-}
-declare const buildChainedOrder: (mongoose: Mongoose) => ChainedOrderModel;
-export { buildChainedOrder, ChainedOrderDoc, ChainedOrderAttrs };

package/build/models/chained-order.js

@@ -1,134 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildChainedOrder = void 0;
-const buildChainedOrder = (mongoose) => {
-    // if model is already defined, return it
-    if (mongoose.models.ChainedOrder) {
-        return mongoose.model("ChainedOrder");
-    }
-    const ChainedOrderSchema = new mongoose.Schema({
-        originUserId: {
-            type: String,
-            required: true,
-        },
-        destinationUserId: {
-            type: String,
-            required: true,
-        },
-        destinationBankAccountId: {
-            type: String,
-        },
-        chainedQuoteId: {
-            type: String,
-            required: true,
-        },
-        crypto: {
-            type: String,
-            required: true,
-        },
-        price: {
-            type: Number,
-        },
-        originFiat: {
-            type: String,
-            required: true,
-        },
-        destinationFiat: {
-            type: String,
-            required: true,
-        },
-        originCountry: {
-            type: String,
-            required: true,
-        },
-        destinationCountry: {
-            type: String,
-            required: true,
-        },
-        originAmountFiat: {
-            type: Number,
-            required: true,
-        },
-        destinationAmountFiat: {
-            type: Number,
-            required: true,
-        },
-        originOrderId: {
-            type: String,
-            required: true,
-        },
-        destinationOrderId: {
-            type: String,
-            required: true,
-        },
-        originOrderStatus: {
-            type: String,
-            required: true,
-        },
-        destinationOrderStatus: {
-            type: String,
-            required: true,
-        },
-        originOrderProcessor: {
-            type: String,
-            required: true,
-        },
-        destinationOrderProcessor: {
-            type: String,
-            required: true,
-        },
-        fees: {
-            processingFeeFiat: {
-                type: Number,
-            },
-            transferFeeFiat: {
-                type: Number,
-            },
-            platformFeeFiat: {
-                type: Number,
-            },
-            platformFeeFiatTax: {
-                type: Number,
-            },
-        },
-        brokerId: {
-            type: String,
-        },
-        notes: {
-            type: String,
-        },
-        createdAt: {
-            type: mongoose.Schema.Types.Date,
-            required: true,
-        },
-        netPrice: {
-            type: Number,
-        },
-        markup: {
-            type: Number,
-        },
-        discount: {
-            type: Number,
-        },
-        expiredQuotes: {
-            type: [String],
-        },
-        requestedNetPrice: {
-            type: Number,
-        },
-    }, {
-        toJSON: {
-            transform(doc, ret) {
-                ret.id = ret._id.valueOf();
-                delete ret._id;
-                delete ret.__v;
-            },
-        },
-    });
-    ChainedOrderSchema.statics.build = (attrs) => {
-        return new ChainedOrder(attrs);
-    };
-    const ChainedOrder = mongoose.model("ChainedOrder", ChainedOrderSchema);
-    return ChainedOrder;
-};
-exports.buildChainedOrder = buildChainedOrder;

package/build/models/chained-quote.d.ts

@@ -1,59 +0,0 @@
-import { Country, Fees, Fiat, Crypto } from "@riocrypto/common";
-import { Mongoose, Model, Document } from "mongoose";
-interface ChainedQuoteAttrs {
-    originUserId: string;
-    destinationUserId: string;
-    crypto: Crypto;
-    originFiat: Fiat;
-    destinationFiat: Fiat;
-    expiresAt?: Date;
-    originCountry: Country;
-    destinationCountry: Country;
-    originAmountFiat: number;
-    destinationAmountFiat: number;
-    originQuoteId: string;
-    destinationQuoteId: string;
-    fees: Fees;
-    price: number;
-    discount?: number;
-    markup?: number;
-    noMarkups: boolean;
-    isRequote: boolean;
-    reissueAfterExpiration: boolean;
-    createdAt: Date;
-    brokerId?: string;
-    netPrice: number;
-    requestedNetPrice?: number;
-    staticAmountField: "origin" | "destination";
-}
-interface ChainedQuoteDoc extends Document {
-    originUserId: string;
-    destinationUserId: string;
-    crypto: Crypto;
-    originFiat: Fiat;
-    destinationFiat: Fiat;
-    expiresAt?: Date;
-    originCountry: Country;
-    destinationCountry: Country;
-    originAmountFiat: number;
-    destinationAmountFiat: number;
-    originQuoteId: string;
-    destinationQuoteId: string;
-    fees: Fees;
-    price: number;
-    discount?: number;
-    markup?: number;
-    noMarkups: boolean;
-    isRequote: boolean;
-    reissueAfterExpiration: boolean;
-    createdAt: Date;
-    brokerId?: string;
-    netPrice: number;
-    requestedNetPrice?: number;
-    staticAmountField: "origin" | "destination";
-}
-interface ChainedQuoteModel extends Model<ChainedQuoteDoc> {
-    build(attrs: ChainedQuoteAttrs): ChainedQuoteDoc;
-}
-declare const buildChainedQuote: (mongoose: Mongoose) => ChainedQuoteModel;
-export { buildChainedQuote, ChainedQuoteDoc, ChainedQuoteAttrs };

package/build/models/chained-quote.js

@@ -1,117 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildChainedQuote = void 0;
-const buildChainedQuote = (mongoose) => {
-    // if model is already defined, return it
-    if (mongoose.models.ChainedQuote) {
-        return mongoose.model("ChainedQuote");
-    }
-    const ChainedQuoteSchema = new mongoose.Schema({
-        originUserId: {
-            type: String,
-            required: true,
-        },
-        destinationUserId: {
-            type: String,
-            required: true,
-        },
-        crypto: {
-            type: String,
-            required: true,
-        },
-        originFiat: {
-            type: String,
-            required: true,
-        },
-        destinationFiat: {
-            type: String,
-            required: true,
-        },
-        expiresAt: {
-            type: mongoose.Schema.Types.Date,
-        },
-        staticAmountField: {
-            type: String,
-        },
-        originCountry: {
-            type: String,
-            required: true,
-        },
-        destinationCountry: {
-            type: String,
-            required: true,
-        },
-        originAmountFiat: {
-            type: Number,
-            required: true,
-        },
-        destinationAmountFiat: {
-            type: Number,
-            required: true,
-        },
-        originQuoteId: {
-            type: String,
-            required: true,
-        },
-        destinationQuoteId: {
-            type: String,
-            required: true,
-        },
-        fees: {
-            processingFeeFiat: {
-                type: Number,
-            },
-            transferFeeFiat: {
-                type: Number,
-            },
-            platformFeeFiat: {
-                type: Number,
-            },
-            platformFeeFiatTax: {
-                type: Number,
-            },
-        },
-        price: {
-            type: Number,
-        },
-        discount: {
-            type: Number,
-        },
-        markup: {
-            type: Number,
-        },
-        noMarkups: {
-            type: Boolean,
-        },
-        isRequote: {
-            type: Boolean,
-        },
-        brokerId: {
-            type: String,
-        },
-        createdAt: {
-            type: mongoose.Schema.Types.Date,
-            required: true,
-        },
-        netPrice: {
-            type: Number,
-        },
-        requestedNetPrice: {
-            type: Number,
-        },
-    }, {
-        toJSON: {
-            transform(doc, ret) {
-                ret.id = ret._id.valueOf();
-                delete ret._id;
-                delete ret.__v;
-            },
-        },
-    });
-    ChainedQuoteSchema.statics.build = (attrs) => {
-        return new ChainedQuote(attrs);
-    };
-    const ChainedQuote = mongoose.model("ChainedQuote", ChainedQuoteSchema);
-    return ChainedQuote;
-};
-exports.buildChainedQuote = buildChainedQuote;