@riocrypto/common-server 1.0.2480 → 1.0.2483

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

@@ -94,6 +94,7 @@ export * from "./models/liquidity-reservation";
 export * from "./models/axe-slack-thread";
 export * from "./models/axe-telegram-thread";
 export * from "./models/auth-activity-slack-thread";
+export * from "./models/twap-session";
 export * from "./clients/axios-with-logging";
 export * from "./clients/slack-client";
 export * from "./clients/fireblocks-client";

package/build/index.js

@@ -110,6 +110,7 @@ __exportStar(require("./models/liquidity-reservation"), exports);
 __exportStar(require("./models/axe-slack-thread"), exports);
 __exportStar(require("./models/axe-telegram-thread"), exports);
 __exportStar(require("./models/auth-activity-slack-thread"), exports);
+__exportStar(require("./models/twap-session"), exports);
 __exportStar(require("./clients/axios-with-logging"), exports);
 __exportStar(require("./clients/slack-client"), exports);
 __exportStar(require("./clients/fireblocks-client"), exports);

package/build/models/rio-settings.d.ts

@@ -72,6 +72,16 @@ interface RioSettingsAttrs {
             dates: string[];
         };
     };
+    defaultTWAPSettings: {
+        [key in Fiat]?: {
+            [key in Side]: {
+                isEnabled: boolean;
+                spread: number;
+                minClipSize: number;
+                interval: number;
+            };
+        };
+    };
 }
 interface RioSettingsDoc extends mongoose.Document {
     platformFee: number;
@@ -144,6 +154,16 @@ interface RioSettingsDoc extends mongoose.Document {
             dates: string[];
         };
     };
+    defaultTWAPSettings: {
+        [key in Fiat]?: {
+            [key in Side]: {
+                isEnabled: boolean;
+                spread: number;
+                minClipSize: number;
+                interval: number;
+            };
+        };
+    };
 }
 interface RioSettingsModel extends mongoose.Model<RioSettingsDoc> {
     build(attrs: RioSettingsAttrs): RioSettingsDoc;

package/build/models/rio-settings.js

@@ -66,6 +66,9 @@ const buildRioSettings = (mongoose) => {
         holidays: {
             type: Object,
         },
+        defaultTWAPSettings: {
+            type: Object,
+        },
     }, {
         toJSON: {
             transform(doc, ret) {

package/build/models/twap-session.d.ts

@@ -0,0 +1,38 @@
+import { Fiat, Crypto, Side, TWAPSessionStatus } from "@riocrypto/common";
+import { Mongoose, Model, Document } from "mongoose";
+interface TWAPSessionAttrs {
+    createdAt: Date;
+    status: TWAPSessionStatus;
+    side: Side;
+    crypto: Crypto;
+    fiat: Fiat;
+    amountToTrade: number;
+    amountTraded: number;
+    amountRemaining: number;
+    tradeCurrency: Fiat | Crypto;
+    spread: number;
+    clipSize: number;
+    interval: number;
+    isRunning: boolean;
+}
+interface TWAPSessionModel extends Model<TWAPSessionDoc> {
+    build(attrs: TWAPSessionAttrs): TWAPSessionDoc;
+}
+interface TWAPSessionDoc extends Document {
+    id: string;
+    createdAt: Date;
+    status: TWAPSessionStatus;
+    side: Side;
+    crypto: Crypto;
+    fiat: Fiat;
+    amountToTrade: number;
+    amountTraded: number;
+    amountRemaining: number;
+    tradeCurrency: Fiat | Crypto;
+    spread: number;
+    clipSize: number;
+    interval: number;
+    isRunning: boolean;
+}
+declare const buildTWAPSession: (mongoose: Mongoose) => TWAPSessionModel;
+export { buildTWAPSession, TWAPSessionDoc, TWAPSessionAttrs };

package/build/models/twap-session.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTWAPSession = void 0;
+const buildTWAPSession = (mongoose) => {
+    if (mongoose.models.TWAPSession) {
+        return mongoose.model("TWAPSession");
+    }
+    const TWAPSessionSchema = new mongoose.Schema({
+        createdAt: {
+            type: Date,
+            required: true,
+        },
+        status: {
+            type: String,
+            required: true,
+        },
+        side: {
+            type: String,
+            required: true,
+        },
+        crypto: {
+            type: String,
+            required: true,
+        },
+        fiat: {
+            type: String,
+            required: true,
+        },
+        amountToTrade: {
+            type: Number,
+            required: true,
+        },
+        amountTraded: {
+            type: Number,
+            required: true,
+        },
+        amountRemaining: {
+            type: Number,
+            required: true,
+        },
+        tradeCurrency: {
+            type: String,
+            required: true,
+        },
+        spread: {
+            type: Number,
+            required: true,
+        },
+        clipSize: {
+            type: Number,
+            required: true,
+        },
+        interval: {
+            type: Number,
+            required: true,
+        },
+        isRunning: {
+            type: Boolean,
+            required: true,
+        },
+    }, {
+        toJSON: {
+            transform(doc, ret) {
+                ret.id = ret._id.valueOf();
+                delete ret._id;
+                delete ret.__v;
+            },
+        },
+    });
+    TWAPSessionSchema.statics.build = (attrs) => {
+        return new TWAPSession(attrs);
+    };
+    const TWAPSession = mongoose.model("TWAPSession", TWAPSessionSchema);
+    return TWAPSession;
+};
+exports.buildTWAPSession = buildTWAPSession;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riocrypto/common-server",
-  "version": "1.0.2480",
+  "version": "1.0.2483",
   "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.2249",
+    "@riocrypto/common": "^1.0.2250",
     "@types/express": "^4.17.13",
     "axios": "^1.7.4",
     "crypto-js": "^4.2.0",