@rainlanguage/ui-components 0.0.1-alpha.21 → 0.0.1-alpha.210

package/dist/services/index.d.ts

@@ -1,2 +1,3 @@
-export { fetchParseRegistry, fetchRegistryDotrains, validateStrategies } from './registry';
+export { fetchParseRegistry, fetchRegistryDotrains, validateOrders } from './registry';
+export { loadRegistryUrl } from './loadRegistryUrl';
 export type { RegistryDotrain, RegistryFile } from './registry';

package/dist/services/index.js

@@ -1 +1,2 @@
-export { fetchParseRegistry, fetchRegistryDotrains, validateStrategies } from './registry';
+export { fetchParseRegistry, fetchRegistryDotrains, validateOrders } from './registry';
+export { loadRegistryUrl } from './loadRegistryUrl';

package/dist/services/loadRegistryUrl.d.ts

@@ -0,0 +1,2 @@
+import { RegistryManager } from '../providers/registry/RegistryManager';
+export declare function loadRegistryUrl(url: string, registryManager: RegistryManager): Promise<void>;

package/dist/services/loadRegistryUrl.js

@@ -0,0 +1,22 @@
+import { RegistryManager } from '../providers/registry/RegistryManager';
+import { DotrainRegistry } from '@rainlanguage/orderbook';
+export async function loadRegistryUrl(url, registryManager) {
+    if (!url) {
+        throw new Error('No URL provided');
+    }
+    if (!registryManager) {
+        throw new Error('Registry manager is required');
+    }
+    try {
+        const validationResult = await DotrainRegistry.validate(url);
+        if (validationResult.error) {
+            throw new Error(validationResult.error.readableMsg);
+        }
+        registryManager.setRegistry(url);
+        window.location.reload();
+    }
+    catch (e) {
+        const errorMessage = e instanceof Error ? e.message : 'Failed to update registry URL';
+        throw new Error(errorMessage);
+    }
+}

package/dist/services/pairTradesChartData.d.ts

@@ -0,0 +1,47 @@
+import type { RaindexTrade, RaindexVaultToken } from '@rainlanguage/orderbook';
+import type { UTCTimestamp } from 'lightweight-charts';
+export declare const BUCKET_SECONDS_24_HOURS = 900;
+export declare const BUCKET_SECONDS_7_DAYS = 3600;
+export declare const BUCKET_SECONDS_30_DAYS = 14400;
+export declare const BUCKET_SECONDS_1_YEAR = 86400;
+export declare const CHART_COLORS: {
+    readonly BUY_VOLUME: "#26a69a";
+    readonly BUY_VOLUME_TRANSPARENT: "rgba(38, 166, 154, 0.5)";
+    readonly SELL_VOLUME: "#ef5350";
+    readonly SELL_VOLUME_TRANSPARENT: "rgba(239, 83, 80, 0.5)";
+    readonly PRICE_LINE: "#5c6bc0";
+    readonly ZERO_LINE: "#888888";
+};
+export declare function getBucketSecondsForTimeDelta(timeDeltaSeconds: number): number;
+export type TradingPair = {
+    baseToken: RaindexVaultToken;
+    quoteToken: RaindexVaultToken;
+};
+export type PricePoint = {
+    time: UTCTimestamp;
+    value: number;
+};
+export type VolumePoint = {
+    time: UTCTimestamp;
+    value: number;
+    color?: string;
+};
+export type PairTradesChartData = {
+    pricePoints: PricePoint[];
+    buyVolumePoints: VolumePoint[];
+    sellVolumePoints: VolumePoint[];
+};
+export declare function extractPairsFromTrades(trades: RaindexTrade[]): TradingPair[];
+export declare function getDefaultPair(trades: RaindexTrade[]): TradingPair | null;
+export declare function getTokenLabel(token: RaindexVaultToken): string;
+export declare function pairsAreEqual(pairA: TradingPair, pairB: TradingPair): boolean;
+export declare function findPairIndex(pairs: TradingPair[], targetPair: TradingPair): number;
+export declare function flipTradingPair(pair: TradingPair): TradingPair;
+export declare function formatChartTimestamp(timestampSeconds: number, timeDeltaSeconds: number): string;
+export type TransformPairTradesInput = {
+    trades: RaindexTrade[];
+    baseTokenAddress: string;
+    quoteTokenAddress: string;
+    timeDeltaSeconds: number;
+};
+export declare function transformPairTrades(input: TransformPairTradesInput): PairTradesChartData;

package/dist/services/pairTradesChartData.js

@@ -0,0 +1,190 @@
+import { sortBy } from 'lodash';
+import { TIME_DELTA_24_HOURS, TIME_DELTA_7_DAYS, TIME_DELTA_30_DAYS } from './time';
+export const BUCKET_SECONDS_24_HOURS = 900;
+export const BUCKET_SECONDS_7_DAYS = 3600;
+export const BUCKET_SECONDS_30_DAYS = 14400;
+export const BUCKET_SECONDS_1_YEAR = 86400;
+export const CHART_COLORS = {
+    BUY_VOLUME: '#26a69a',
+    BUY_VOLUME_TRANSPARENT: 'rgba(38, 166, 154, 0.5)',
+    SELL_VOLUME: '#ef5350',
+    SELL_VOLUME_TRANSPARENT: 'rgba(239, 83, 80, 0.5)',
+    PRICE_LINE: '#5c6bc0',
+    ZERO_LINE: '#888888'
+};
+export function getBucketSecondsForTimeDelta(timeDeltaSeconds) {
+    if (timeDeltaSeconds <= TIME_DELTA_24_HOURS)
+        return BUCKET_SECONDS_24_HOURS;
+    if (timeDeltaSeconds <= TIME_DELTA_7_DAYS)
+        return BUCKET_SECONDS_7_DAYS;
+    if (timeDeltaSeconds <= TIME_DELTA_30_DAYS)
+        return BUCKET_SECONDS_30_DAYS;
+    return BUCKET_SECONDS_1_YEAR;
+}
+function getTokenAddressLower(trade, which) {
+    const change = which === 'in' ? trade.inputVaultBalanceChange : trade.outputVaultBalanceChange;
+    return change.token.address.toLowerCase();
+}
+function tradeMatchesPair(trade, baseTokenAddress, quoteTokenAddress) {
+    const inAddr = getTokenAddressLower(trade, 'in');
+    const outAddr = getTokenAddressLower(trade, 'out');
+    const baseLower = baseTokenAddress.toLowerCase();
+    const quoteLower = quoteTokenAddress.toLowerCase();
+    return ((inAddr === baseLower && outAddr === quoteLower) ||
+        (inAddr === quoteLower && outAddr === baseLower));
+}
+function getTradeAmounts(trade, baseTokenAddress) {
+    const inAddr = getTokenAddressLower(trade, 'in');
+    const baseLower = baseTokenAddress.toLowerCase();
+    const inFormattedAmount = trade.inputVaultBalanceChange.formattedAmount;
+    const outFormattedAmount = trade.outputVaultBalanceChange.formattedAmount;
+    const inAmt = Math.abs(parseFloat(inFormattedAmount));
+    const outAmt = Math.abs(parseFloat(outFormattedAmount));
+    if (!Number.isFinite(inAmt) || !Number.isFinite(outAmt))
+        return null;
+    const isBuy = inAddr === baseLower;
+    return {
+        baseAmount: isBuy ? inAmt : outAmt,
+        quoteAmount: isBuy ? outAmt : inAmt,
+        isBuy
+    };
+}
+export function extractPairsFromTrades(trades) {
+    const pairMap = new Map();
+    for (const trade of trades) {
+        const inToken = trade.inputVaultBalanceChange.token;
+        const outToken = trade.outputVaultBalanceChange.token;
+        const inAddr = inToken.address.toLowerCase();
+        const outAddr = outToken.address.toLowerCase();
+        const [firstAddr, secondAddr] = inAddr < outAddr ? [inAddr, outAddr] : [outAddr, inAddr];
+        const pairKey = `${firstAddr}-${secondAddr}`;
+        if (!pairMap.has(pairKey)) {
+            const [baseToken, quoteToken] = inAddr < outAddr ? [inToken, outToken] : [outToken, inToken];
+            pairMap.set(pairKey, { baseToken, quoteToken });
+        }
+    }
+    return Array.from(pairMap.values());
+}
+export function getDefaultPair(trades) {
+    if (trades.length === 0)
+        return null;
+    const sortedTrades = sortBy(trades, (t) => Number(t.timestamp));
+    const oldestTrade = sortedTrades[0];
+    const inToken = oldestTrade.inputVaultBalanceChange.token;
+    const outToken = oldestTrade.outputVaultBalanceChange.token;
+    const inAddr = inToken.address.toLowerCase();
+    const outAddr = outToken.address.toLowerCase();
+    if (inAddr < outAddr) {
+        return { baseToken: inToken, quoteToken: outToken };
+    }
+    else {
+        return { baseToken: outToken, quoteToken: inToken };
+    }
+}
+export function getTokenLabel(token) {
+    if (token.symbol && token.symbol.trim() !== '') {
+        return token.symbol;
+    }
+    const addr = token.address;
+    if (addr.length >= 10) {
+        return `${addr.slice(0, 6)}...${addr.slice(-4)}`;
+    }
+    return addr;
+}
+export function pairsAreEqual(pairA, pairB) {
+    return (pairA.baseToken.address.toLowerCase() === pairB.baseToken.address.toLowerCase() &&
+        pairA.quoteToken.address.toLowerCase() === pairB.quoteToken.address.toLowerCase());
+}
+export function findPairIndex(pairs, targetPair) {
+    return pairs.findIndex((p) => pairsAreEqual(p, targetPair));
+}
+export function flipTradingPair(pair) {
+    return {
+        baseToken: pair.quoteToken,
+        quoteToken: pair.baseToken
+    };
+}
+export function formatChartTimestamp(timestampSeconds, timeDeltaSeconds) {
+    const date = new Date(timestampSeconds * 1000);
+    const day = date.getDate();
+    const month = date.toLocaleString('en-US', { month: 'short' });
+    const hours = date.getHours().toString().padStart(2, '0');
+    const minutes = date.getMinutes().toString().padStart(2, '0');
+    if (timeDeltaSeconds <= TIME_DELTA_24_HOURS) {
+        return `${month} ${day} ${hours}:${minutes}`;
+    }
+    else if (timeDeltaSeconds <= TIME_DELTA_7_DAYS) {
+        return `${month} ${day} ${hours}:00`;
+    }
+    else {
+        return `${month} ${day}`;
+    }
+}
+export function transformPairTrades(input) {
+    const { trades, baseTokenAddress, quoteTokenAddress, timeDeltaSeconds } = input;
+    const bucketSeconds = getBucketSecondsForTimeDelta(timeDeltaSeconds);
+    const now = Math.floor(Date.now() / 1000);
+    const cutoff = now - timeDeltaSeconds;
+    const filteredTrades = trades.filter((trade) => {
+        const ts = Number(trade.timestamp);
+        if (ts < cutoff || ts > now)
+            return false;
+        return tradeMatchesPair(trade, baseTokenAddress, quoteTokenAddress);
+    });
+    const priceAggregator = new Map();
+    const buyVolumeBuckets = new Map();
+    const sellVolumeBuckets = new Map();
+    for (const trade of filteredTrades) {
+        const amounts = getTradeAmounts(trade, baseTokenAddress);
+        if (!amounts)
+            continue;
+        const { baseAmount, quoteAmount, isBuy } = amounts;
+        if (baseAmount === 0)
+            continue;
+        const ts = Number(trade.timestamp);
+        const existing = priceAggregator.get(ts);
+        if (existing) {
+            priceAggregator.set(ts, {
+                sumBase: existing.sumBase + baseAmount,
+                sumQuote: existing.sumQuote + quoteAmount
+            });
+        }
+        else {
+            priceAggregator.set(ts, { sumBase: baseAmount, sumQuote: quoteAmount });
+        }
+        const bucketTime = Math.floor(ts / bucketSeconds) * bucketSeconds;
+        const volumeMap = isBuy ? buyVolumeBuckets : sellVolumeBuckets;
+        const existingVol = volumeMap.get(bucketTime) ?? 0;
+        volumeMap.set(bucketTime, existingVol + baseAmount);
+    }
+    const pricePoints = [];
+    for (const [ts, agg] of priceAggregator.entries()) {
+        if (agg.sumBase === 0)
+            continue;
+        const price = agg.sumQuote / agg.sumBase;
+        if (!Number.isFinite(price))
+            continue;
+        pricePoints.push({ time: ts, value: price });
+    }
+    const buyVolumePoints = [];
+    for (const [bucketTime, vol] of buyVolumeBuckets.entries()) {
+        buyVolumePoints.push({
+            time: bucketTime,
+            value: vol,
+            color: CHART_COLORS.BUY_VOLUME
+        });
+    }
+    const sellVolumePoints = [];
+    for (const [bucketTime, vol] of sellVolumeBuckets.entries()) {
+        sellVolumePoints.push({
+            time: bucketTime,
+            value: -vol,
+            color: CHART_COLORS.SELL_VOLUME
+        });
+    }
+    return {
+        pricePoints: sortBy(pricePoints, (p) => p.time),
+        buyVolumePoints: sortBy(buyVolumePoints, (p) => p.time),
+        sellVolumePoints: sortBy(sellVolumePoints, (p) => p.time)
+    };
+}

package/dist/services/registry.d.ts

@@ -1,4 +1,4 @@
-import type { InvalidStrategyDetail, ValidStrategyDetail } from '../types/strategy';
+import type { InvalidOrderDetail, ValidOrderDetail } from '../types/order';
 export type RegistryFile = {
     name: string;
     url: string;
@@ -7,9 +7,9 @@ export type RegistryDotrain = {
     name: string;
     dotrain: string;
 };
-export interface StrategyValidationResult {
-    validStrategies: ValidStrategyDetail[];
-    invalidStrategies: InvalidStrategyDetail[];
+export interface OrderValidationResult {
+    validOrders: ValidOrderDetail[];
+    invalidOrders: InvalidOrderDetail[];
 }
 /**
  * Fetches and parses a file registry from a given URL.
@@ -28,4 +28,4 @@ export declare const fetchParseRegistry: (url: string) => Promise<{
     url: string;
 }[]>;
 export declare const fetchRegistryDotrains: (url: string) => Promise<RegistryDotrain[]>;
-export declare function validateStrategies(registryDotrains: RegistryDotrain[]): Promise<StrategyValidationResult>;
+export declare function validateOrders(registryDotrains: RegistryDotrain[]): Promise<OrderValidationResult>;

package/dist/services/registry.js

@@ -1,4 +1,4 @@
-import { DotrainOrderGui } from '@rainlanguage/orderbook/js_api';
+import { DotrainOrderGui } from '@rainlanguage/orderbook';
 /**
  * Fetches and parses a file registry from a given URL.
  * The registry is expected to be a text file where each line contains a file name and URL separated by a space.
@@ -53,10 +53,10 @@ export const fetchRegistryDotrains = async (url) => {
     }));
     return dotrains;
 };
-export async function validateStrategies(registryDotrains) {
-    const strategiesPromises = registryDotrains.map(async (registryDotrain) => {
+export async function validateOrders(registryDotrains) {
+    const ordersPromises = registryDotrains.map(async (registryDotrain) => {
         try {
-            const result = await DotrainOrderGui.getStrategyDetails(registryDotrain.dotrain);
+            const result = await DotrainOrderGui.getOrderDetails(registryDotrain.dotrain);
             if (result.error) {
                 throw new Error(result.error.msg);
             }
@@ -78,212 +78,12 @@ export async function validateStrategies(registryDotrains) {
             };
         }
     });
-    const strategiesResults = await Promise.all(strategiesPromises);
-    const validStrategies = strategiesResults
+    const ordersResults = await Promise.all(ordersPromises);
+    const validOrders = ordersResults
         .filter((result) => result.valid)
         .map((result) => result.data);
-    const invalidStrategies = strategiesResults
+    const invalidOrders = ordersResults
         .filter((result) => !result.valid)
         .map((result) => result.data);
-    return { validStrategies, invalidStrategies };
-}
-if (import.meta.vitest) {
-    const { describe, it, expect, vi } = import.meta.vitest;
-    describe('getFileRegistry', () => {
-        it('should parse registry file content correctly', async () => {
-            const mockResponse = `file1.js https://example.com/file1.js
-file2.js https://example.com/file2.js`;
-            global.fetch = vi.fn().mockResolvedValue({
-                ok: true,
-                text: () => Promise.resolve(mockResponse)
-            });
-            const result = await fetchParseRegistry('https://example.com/registry');
-            expect(result).toEqual([
-                { name: 'file1.js', url: 'https://example.com/file1.js' },
-                { name: 'file2.js', url: 'https://example.com/file2.js' }
-            ]);
-        });
-        it('should handle failed fetch response', async () => {
-            global.fetch = vi.fn().mockResolvedValue({
-                ok: false
-            });
-            await expect(fetchParseRegistry('https://example.com/registry')).rejects.toThrow('Failed to fetch registry');
-        });
-        it('should handle network errors', async () => {
-            global.fetch = vi.fn().mockRejectedValue(new Error('Network error'));
-            await expect(fetchParseRegistry('https://example.com/registry')).rejects.toThrow('Network error');
-        });
-    });
-    describe('fetchRegistryDotrains', () => {
-        it('should fetch and parse dotrains correctly', async () => {
-            const mockRegistry = `file1.rain https://example.com/file1.rain
-file2.rain https://example.com/file2.rain`;
-            const mockDotrain1 = 'content of file1';
-            const mockDotrain2 = 'content of file2';
-            global.fetch = vi
-                .fn()
-                .mockResolvedValueOnce({
-                ok: true,
-                text: () => Promise.resolve(mockRegistry)
-            })
-                .mockResolvedValueOnce({
-                ok: true,
-                text: () => Promise.resolve(mockDotrain1)
-            })
-                .mockResolvedValueOnce({
-                ok: true,
-                text: () => Promise.resolve(mockDotrain2)
-            });
-            const result = await fetchRegistryDotrains('https://example.com/registry');
-            expect(result).toEqual([
-                { name: 'file1.rain', dotrain: mockDotrain1 },
-                { name: 'file2.rain', dotrain: mockDotrain2 }
-            ]);
-        });
-        it('should handle failed dotrain fetch', async () => {
-            const mockRegistry = `file1.rain https://example.com/file1.rain`;
-            global.fetch = vi
-                .fn()
-                .mockResolvedValueOnce({
-                ok: true,
-                text: () => Promise.resolve(mockRegistry)
-            })
-                .mockResolvedValueOnce({
-                ok: false
-            });
-            await expect(fetchRegistryDotrains('https://example.com/registry')).rejects.toThrow('Failed to fetch dotrain for file1.rain');
-        });
-        it('should handle network errors during dotrain fetch', async () => {
-            const mockRegistry = `file1.rain https://example.com/file1.rain`;
-            global.fetch = vi
-                .fn()
-                .mockResolvedValueOnce({
-                ok: true,
-                text: () => Promise.resolve(mockRegistry)
-            })
-                .mockRejectedValueOnce(new Error('Network error'));
-            await expect(fetchRegistryDotrains('https://example.com/registry')).rejects.toThrow('Error fetching dotrain for file1.rain: Network error');
-        });
-    });
-    describe('validateStrategies', async () => {
-        // Mock the DotrainOrderGui dependency
-        vi.mock('@rainlanguage/orderbook/js_api', () => ({
-            DotrainOrderGui: {
-                getStrategyDetails: vi.fn()
-            }
-        }));
-        // Import DotrainOrderGui after mocking
-        const { DotrainOrderGui } = await import('@rainlanguage/orderbook/js_api');
-        beforeEach(() => {
-            vi.resetAllMocks();
-        });
-        it('should validate strategies and categorize them properly', async () => {
-            // Input data
-            const registryDotrains = [
-                { name: 'valid.rain', dotrain: 'valid dotrain content' },
-                { name: 'invalid.rain', dotrain: 'invalid dotrain content' },
-                { name: 'another-valid.rain', dotrain: 'another valid content' }
-            ];
-            // Set up mock responses for the DotrainOrderGui
-            DotrainOrderGui.getStrategyDetails
-                .mockResolvedValueOnce({
-                value: { name: 'Valid Strategy', description: 'A valid strategy' },
-                error: null
-            })
-                .mockResolvedValueOnce({
-                error: { msg: 'Invalid syntax' },
-                value: null
-            })
-                .mockResolvedValueOnce({
-                value: { name: 'Another Valid', description: 'Another valid strategy' },
-                error: null
-            });
-            // Call the function with our test data
-            const result = await validateStrategies(registryDotrains);
-            // Verify DotrainOrderGui was called correctly
-            expect(DotrainOrderGui.getStrategyDetails).toHaveBeenCalledTimes(3);
-            expect(DotrainOrderGui.getStrategyDetails).toHaveBeenCalledWith('valid dotrain content');
-            expect(DotrainOrderGui.getStrategyDetails).toHaveBeenCalledWith('invalid dotrain content');
-            expect(DotrainOrderGui.getStrategyDetails).toHaveBeenCalledWith('another valid content');
-            // Verify the valid strategies are processed correctly
-            expect(result.validStrategies).toHaveLength(2);
-            expect(result.validStrategies[0].name).toBe('valid.rain');
-            expect(result.validStrategies[0].dotrain).toBe('valid dotrain content');
-            expect(result.validStrategies[0].details).toEqual({
-                name: 'Valid Strategy',
-                description: 'A valid strategy'
-            });
-            // Verify the invalid strategies are processed correctly
-            expect(result.invalidStrategies).toHaveLength(1);
-            expect(result.invalidStrategies[0].name).toBe('invalid.rain');
-            expect(result.invalidStrategies[0].error).toBe('Invalid syntax');
-        });
-        it('should handle exceptions thrown during strategy validation', async () => {
-            // Input data
-            const registryDotrains = [{ name: 'error.rain', dotrain: 'will throw error' }];
-            // Mock the DotrainOrderGui to throw an exception
-            DotrainOrderGui.getStrategyDetails.mockRejectedValueOnce(new Error('Unexpected parsing error'));
-            // Call the function
-            const result = await validateStrategies(registryDotrains);
-            // Verify results
-            expect(result.validStrategies).toHaveLength(0);
-            expect(result.invalidStrategies).toHaveLength(1);
-            expect(result.invalidStrategies[0].name).toBe('error.rain');
-            expect(result.invalidStrategies[0].error).toBe('Unexpected parsing error');
-        });
-        it('should handle non-Error objects being thrown', async () => {
-            // Input data
-            const registryDotrains = [{ name: 'string-error.rain', dotrain: 'will throw string' }];
-            // Mock the DotrainOrderGui to throw a string instead of an Error
-            DotrainOrderGui.getStrategyDetails.mockRejectedValueOnce('String error message');
-            // Call the function
-            const result = await validateStrategies(registryDotrains);
-            // Verify results
-            expect(result.validStrategies).toHaveLength(0);
-            expect(result.invalidStrategies).toHaveLength(1);
-            expect(result.invalidStrategies[0].name).toBe('string-error.rain');
-            expect(result.invalidStrategies[0].error).toBe('String error message');
-        });
-        it('should process an empty array of strategies', async () => {
-            const result = await validateStrategies([]);
-            expect(result.validStrategies).toEqual([]);
-            expect(result.invalidStrategies).toEqual([]);
-            expect(DotrainOrderGui.getStrategyDetails).not.toHaveBeenCalled();
-        });
-        it('should handle mixed validation results correctly', async () => {
-            // Create a mix of scenarios
-            const registryDotrains = [
-                { name: 'valid1.rain', dotrain: 'valid content 1' },
-                { name: 'error.rain', dotrain: 'will throw error' },
-                { name: 'valid2.rain', dotrain: 'valid content 2' },
-                { name: 'invalid.rain', dotrain: 'invalid content' }
-            ];
-            // Set up mock responses
-            DotrainOrderGui.getStrategyDetails
-                .mockResolvedValueOnce({
-                value: { strategyName: 'Strategy 1', description: 'Description 1' },
-                error: null
-            })
-                .mockRejectedValueOnce(new Error('Processing error'))
-                .mockResolvedValueOnce({
-                value: { strategyName: 'Strategy 2', description: 'Description 2' },
-                error: null
-            })
-                .mockResolvedValueOnce({
-                error: { msg: 'Validation failed' },
-                value: null
-            });
-            // Call the function
-            const result = await validateStrategies(registryDotrains);
-            // Verify results
-            expect(result.validStrategies).toHaveLength(2);
-            expect(result.validStrategies[0].name).toBe('valid1.rain');
-            expect(result.validStrategies[1].name).toBe('valid2.rain');
-            expect(result.invalidStrategies).toHaveLength(2);
-            expect(result.invalidStrategies[0].name).toBe('error.rain');
-            expect(result.invalidStrategies[0].error).toBe('Processing error');
-            expect(result.invalidStrategies[1].name).toBe('invalid.rain');
-            expect(result.invalidStrategies[1].error).toBe('Validation failed');
-        });
-    });
+    return { validOrders, invalidOrders };
 }

package/dist/services/time.d.ts

@@ -1,6 +1,18 @@
+import type { UTCTimestamp } from 'lightweight-charts';
 export declare const TIME_DELTA_24_HOURS: number;
 export declare const TIME_DELTA_48_HOURS: number;
 export declare const TIME_DELTA_7_DAYS: number;
 export declare const TIME_DELTA_30_DAYS: number;
 export declare const TIME_DELTA_1_YEAR: number;
 export declare function dateTimestamp(date: Date): number;
+export declare function formatTimestampSecondsAsLocal(timestampSeconds: bigint): string;
+export declare function timestampSecondsToUTCTimestamp(timestampSeconds: bigint): UTCTimestamp;
+/**
+ * Method to put a timeout on a promise, throws the exception if promise is not settled within the time
+ * @param promise - The original promise
+ * @param time - The time in ms
+ * @param exception - The exception to reject with if time runs out before original promise settlement
+ * @returns A new promise that gets settled with initial promise settlement or rejected with exception value
+ * if the time runs out before the main promise settlement
+ */
+export declare function promiseTimeout<T>(promise: Promise<T>, time: number, exception: unknown): Promise<T>;

package/dist/services/time.js

@@ -1,3 +1,10 @@
+import dayjs from 'dayjs';
+import bigIntSupport from 'dayjs/plugin/bigIntSupport';
+import localizedFormat from 'dayjs/plugin/localizedFormat';
+import utc from 'dayjs/plugin/utc';
+dayjs.extend(bigIntSupport);
+dayjs.extend(localizedFormat);
+dayjs.extend(utc);
 export const TIME_DELTA_24_HOURS = 60 * 60 * 24;
 export const TIME_DELTA_48_HOURS = TIME_DELTA_24_HOURS * 2;
 export const TIME_DELTA_7_DAYS = TIME_DELTA_24_HOURS * 7;
@@ -6,12 +13,87 @@ export const TIME_DELTA_1_YEAR = TIME_DELTA_24_HOURS * 365;
 export function dateTimestamp(date) {
     return Math.floor(date.getTime() / 1000);
 }
+export function formatTimestampSecondsAsLocal(timestampSeconds) {
+    return dayjs(timestampSeconds * BigInt('1000'))
+        .utc()
+        .format('L LT');
+}
+export function timestampSecondsToUTCTimestamp(timestampSeconds) {
+    return dayjs(timestampSeconds * BigInt('1000')).unix();
+}
+/**
+ * Method to put a timeout on a promise, throws the exception if promise is not settled within the time
+ * @param promise - The original promise
+ * @param time - The time in ms
+ * @param exception - The exception to reject with if time runs out before original promise settlement
+ * @returns A new promise that gets settled with initial promise settlement or rejected with exception value
+ * if the time runs out before the main promise settlement
+ */
+export async function promiseTimeout(promise, time, exception) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let timeout;
+    return Promise.race([
+        promise,
+        new Promise((_resolve, reject) => (timeout = setTimeout(reject, time, exception)))
+    ]).finally(() => clearTimeout(timeout));
+}
 if (import.meta.vitest) {
-    const { it, expect } = import.meta.vitest;
-    it('should get date timestamp in seconds', () => {
-        const date = new Date(2022, 1, 16, 17, 32, 11, 168);
-        const result = dateTimestamp(date);
-        const expected = Math.floor(date.getTime() / 1000);
-        expect(result).toEqual(expected);
+    const { describe, it, expect, vi } = import.meta.vitest;
+    describe('Date and timestamp utilities', () => {
+        describe('formatTimestampSecondsAsLocal', () => {
+            it('converts timestamp to local format', () => {
+                const result = formatTimestampSecondsAsLocal(BigInt('1672531200')); // Jan 1, 2023 12:00 AM
+                expect(result).toBe('01/01/2023 12:00 AM');
+            });
+        });
+        describe('timestampSecondsToUTCTimestamp', () => {
+            it('converts bigint timestamp to UTCTimestamp', () => {
+                const result = timestampSecondsToUTCTimestamp(BigInt('1672531200'));
+                expect(result).toBe(1672531200);
+            });
+        });
+    });
+    describe('promiseTimeout', () => {
+        it('resolves when promise resolves before timeout', async () => {
+            const testValue = 'test';
+            const promise = Promise.resolve(testValue);
+            const result = await promiseTimeout(promise, 100, new Error('Timeout'));
+            expect(result).toBe(testValue);
+        });
+        it('rejects when promise times out', async () => {
+            const promise = new Promise((resolve) => setTimeout(resolve, 200));
+            const exception = new Error('Timeout');
+            await expect(promiseTimeout(promise, 100, exception)).rejects.toThrow(exception);
+        });
+        it('rejects when original promise rejects', async () => {
+            const error = new Error('Original rejection');
+            const promise = Promise.reject(error);
+            await expect(promiseTimeout(promise, 100, new Error('Timeout'))).rejects.toThrow(error);
+        });
+        it('clears timeout after promise resolution', async () => {
+            vi.spyOn(global, 'clearTimeout');
+            const promise = Promise.resolve('test');
+            await promiseTimeout(promise, 100, new Error('Timeout'));
+            expect(clearTimeout).toHaveBeenCalled();
+        });
+        it('clears timeout after promise rejection', async () => {
+            vi.spyOn(global, 'clearTimeout');
+            const promise = Promise.reject(new Error('Original rejection'));
+            try {
+                await promiseTimeout(promise, 100, new Error('Timeout'));
+            }
+            catch {
+                // Ignore the error
+            }
+            expect(clearTimeout).toHaveBeenCalled();
+        });
+    });
+    describe('dateTimestamp', () => {
+        it('should get date timestamp in seconds', () => {
+            const date = new Date(2022, 1, 16, 17, 32, 11, 168);
+            const result = dateTimestamp(date);
+            const expected = Math.floor(date.getTime() / 1000);
+            expect(result).toEqual(expected);
+        });
     });
 }