@rainlanguage/ui-components 0.0.1-alpha.10

package/dist/services/historicalOrderCharts.js

@@ -0,0 +1,496 @@
+import { timestampSecondsToUTCTimestamp } from '../utils/time';
+import { sortBy } from 'lodash';
+import { formatUnits } from 'viem';
+export function prepareHistoricalOrderChartData(takeOrderEntities, colorTheme) {
+    const transformedData = takeOrderEntities.map((d) => ({
+        value: Math.abs(Number(formatUnits(BigInt(d.inputVaultBalanceChange.amount), Number(d.inputVaultBalanceChange.vault.token.decimals ?? 0))) /
+            Number(formatUnits(BigInt(d.outputVaultBalanceChange.amount), Number(d.outputVaultBalanceChange.vault.token.decimals ?? 0)))),
+        time: timestampSecondsToUTCTimestamp(BigInt(d.timestamp)),
+        color: colorTheme == 'dark' ? '#5178FF' : '#4E4AF6',
+        outputAmount: +d.outputVaultBalanceChange.amount
+    }));
+    // if we have multiple object in the array with the same timestamp, we need to merge them
+    // we do this by taking the weighted average of the ioratio values for objects that share the same timestamp.
+    const uniqueTimestamps = Array.from(new Set(transformedData.map((d) => d.time)));
+    const finalData = [];
+    uniqueTimestamps.forEach((timestamp) => {
+        const objectsWithSameTimestamp = transformedData.filter((d) => d.time === timestamp);
+        if (objectsWithSameTimestamp.length > 1) {
+            // calculate a weighted average of the ioratio values using the amount of the output token as the weight
+            const ioratioSum = objectsWithSameTimestamp.reduce((acc, d) => acc + d.value * d.outputAmount, 0);
+            const outputAmountSum = objectsWithSameTimestamp.reduce((acc, d) => acc + d.outputAmount, 0);
+            const ioratioAverage = ioratioSum / outputAmountSum;
+            finalData.push({
+                value: ioratioAverage,
+                time: timestamp,
+                color: objectsWithSameTimestamp[0].color
+            });
+        }
+        else {
+            finalData.push(objectsWithSameTimestamp[0]);
+        }
+    });
+    return sortBy(finalData, (d) => d.time);
+}
+if (import.meta.vitest) {
+    const { it, expect } = import.meta.vitest;
+    it('transforms and sorts data as expected', () => {
+        const takeOrderEntities = [
+            {
+                id: '1',
+                timestamp: '1632000000',
+                tradeEvent: {
+                    sender: 'sender_address',
+                    transaction: {
+                        id: 'transaction_id',
+                        from: 'sender_address',
+                        timestamp: '1632000000',
+                        blockNumber: '0'
+                    }
+                },
+                outputVaultBalanceChange: {
+                    amount: '100',
+                    vault: {
+                        id: '1',
+                        vaultId: 'vault-id1',
+                        token: {
+                            id: 'output_token',
+                            address: 'output_token',
+                            name: 'output_token',
+                            symbol: 'output_token',
+                            decimals: '1'
+                        }
+                    },
+                    id: '1',
+                    __typename: 'Withdraw',
+                    newVaultBalance: '0',
+                    oldVaultBalance: '0',
+                    timestamp: '0',
+                    transaction: {
+                        id: 'transaction_id',
+                        from: 'sender_address',
+                        timestamp: '1632000000',
+                        blockNumber: '0'
+                    },
+                    orderbook: { id: '1' }
+                },
+                order: {
+                    id: 'order_id',
+                    orderHash: 'orderHash'
+                },
+                inputVaultBalanceChange: {
+                    vault: {
+                        id: '1',
+                        vaultId: 'vault-id1',
+                        token: {
+                            id: 'output_token',
+                            address: 'output_token',
+                            name: 'output_token',
+                            symbol: 'output_token',
+                            decimals: '1'
+                        }
+                    },
+                    amount: '50',
+                    id: '1',
+                    __typename: 'Withdraw',
+                    newVaultBalance: '0',
+                    oldVaultBalance: '0',
+                    timestamp: '0',
+                    transaction: {
+                        id: 'transaction_id',
+                        from: 'sender_address',
+                        timestamp: '1632000000',
+                        blockNumber: '0'
+                    },
+                    orderbook: { id: '1' }
+                },
+                orderbook: {
+                    id: '0x00'
+                }
+            },
+            {
+                id: '2',
+                timestamp: '1631000000',
+                tradeEvent: {
+                    sender: 'sender_address',
+                    transaction: {
+                        id: 'transaction_id',
+                        from: 'sender_address',
+                        timestamp: '1631000000',
+                        blockNumber: '0'
+                    }
+                },
+                outputVaultBalanceChange: {
+                    amount: '100',
+                    vault: {
+                        id: '1',
+                        vaultId: 'vault-id1',
+                        token: {
+                            id: 'output_token',
+                            address: 'output_token',
+                            name: 'output_token',
+                            symbol: 'output_token',
+                            decimals: '1'
+                        }
+                    },
+                    id: '1',
+                    __typename: 'Withdraw',
+                    newVaultBalance: '0',
+                    oldVaultBalance: '0',
+                    timestamp: '0',
+                    transaction: {
+                        id: 'transaction_id',
+                        from: 'sender_address',
+                        timestamp: '1632000000',
+                        blockNumber: '0'
+                    },
+                    orderbook: { id: '1' }
+                },
+                order: {
+                    id: 'order_id',
+                    orderHash: 'orderHash'
+                },
+                inputVaultBalanceChange: {
+                    vault: {
+                        id: '1',
+                        vaultId: 'vault-id1',
+                        token: {
+                            id: 'output_token',
+                            address: 'output_token',
+                            name: 'output_token',
+                            symbol: 'output_token',
+                            decimals: '1'
+                        }
+                    },
+                    amount: '50',
+                    id: '1',
+                    __typename: 'Withdraw',
+                    newVaultBalance: '0',
+                    oldVaultBalance: '0',
+                    timestamp: '0',
+                    transaction: {
+                        id: 'transaction_id',
+                        from: 'sender_address',
+                        timestamp: '1632000000',
+                        blockNumber: '0'
+                    },
+                    orderbook: { id: '1' }
+                },
+                orderbook: {
+                    id: '0x00'
+                }
+            },
+            {
+                id: '3',
+                timestamp: '1630000000',
+                tradeEvent: {
+                    sender: 'sender_address',
+                    transaction: {
+                        id: 'transaction_id',
+                        from: 'sender_address',
+                        timestamp: '1630000000',
+                        blockNumber: '0'
+                    }
+                },
+                outputVaultBalanceChange: {
+                    amount: '100',
+                    vault: {
+                        id: '1',
+                        vaultId: 'vault-id1',
+                        token: {
+                            id: 'output_token',
+                            address: 'output_token',
+                            name: 'output_token',
+                            symbol: 'output_token',
+                            decimals: '1'
+                        }
+                    },
+                    id: '1',
+                    __typename: 'Withdraw',
+                    newVaultBalance: '0',
+                    oldVaultBalance: '0',
+                    timestamp: '0',
+                    transaction: {
+                        id: 'transaction_id',
+                        from: 'sender_address',
+                        timestamp: '1632000000',
+                        blockNumber: '0'
+                    },
+                    orderbook: { id: '1' }
+                },
+                order: {
+                    id: 'order_id',
+                    orderHash: 'orderHash'
+                },
+                inputVaultBalanceChange: {
+                    vault: {
+                        id: '1',
+                        vaultId: 'vault-id1',
+                        token: {
+                            id: 'output_token',
+                            address: 'output_token',
+                            name: 'output_token',
+                            symbol: 'output_token',
+                            decimals: '1'
+                        }
+                    },
+                    amount: '50',
+                    id: '1',
+                    __typename: 'Withdraw',
+                    newVaultBalance: '0',
+                    oldVaultBalance: '0',
+                    timestamp: '0',
+                    transaction: {
+                        id: 'transaction_id',
+                        from: 'sender_address',
+                        timestamp: '1632000000',
+                        blockNumber: '0'
+                    },
+                    orderbook: { id: '1' }
+                },
+                orderbook: {
+                    id: '0x00'
+                }
+            }
+        ];
+        const result = prepareHistoricalOrderChartData(takeOrderEntities, 'dark');
+        expect(result.length).toEqual(3);
+        expect(result[0].value).toEqual(0.5);
+        expect(result[0].time).toEqual(1630000000);
+        expect(result[1].value).toEqual(0.5);
+        expect(result[1].time).toEqual(1631000000);
+        expect(result[2].value).toEqual(0.5);
+        expect(result[2].time).toEqual(1632000000);
+        // check the color
+        expect(result[0].color).toEqual('#5178FF');
+        expect(result[1].color).toEqual('#5178FF');
+        expect(result[2].color).toEqual('#5178FF');
+    });
+    it('handles the case where multiple trades have the same timestamp', () => {
+        const takeOrderEntities = [
+            {
+                id: '1',
+                timestamp: '1632000000',
+                tradeEvent: {
+                    sender: 'sender_address',
+                    transaction: {
+                        id: 'transaction_id',
+                        from: 'sender_address',
+                        timestamp: '1632000000',
+                        blockNumber: '0'
+                    }
+                },
+                outputVaultBalanceChange: {
+                    amount: '100',
+                    vault: {
+                        id: '1',
+                        vaultId: 'vault-id1',
+                        token: {
+                            id: 'output_token',
+                            address: 'output_token',
+                            name: 'output_token',
+                            symbol: 'output_token',
+                            decimals: '1'
+                        }
+                    },
+                    id: '1',
+                    __typename: 'Withdraw',
+                    newVaultBalance: '0',
+                    oldVaultBalance: '0',
+                    timestamp: '0',
+                    transaction: {
+                        id: 'transaction_id',
+                        from: 'sender_address',
+                        timestamp: '1632000000',
+                        blockNumber: '0'
+                    },
+                    orderbook: { id: '1' }
+                },
+                order: {
+                    id: 'order_id',
+                    orderHash: 'orderHash'
+                },
+                inputVaultBalanceChange: {
+                    vault: {
+                        id: '1',
+                        vaultId: 'vault-id1',
+                        token: {
+                            id: 'output_token',
+                            address: 'output_token',
+                            name: 'output_token',
+                            symbol: 'output_token',
+                            decimals: '1'
+                        }
+                    },
+                    amount: '50',
+                    id: '1',
+                    __typename: 'Withdraw',
+                    newVaultBalance: '0',
+                    oldVaultBalance: '0',
+                    timestamp: '0',
+                    transaction: {
+                        id: 'transaction_id',
+                        from: 'sender_address',
+                        timestamp: '1632000000',
+                        blockNumber: '0'
+                    },
+                    orderbook: { id: '1' }
+                },
+                orderbook: {
+                    id: '0x00'
+                }
+            },
+            {
+                id: '2',
+                timestamp: '1632000000',
+                tradeEvent: {
+                    sender: 'sender_address',
+                    transaction: {
+                        id: 'transaction_id',
+                        from: 'sender_address',
+                        timestamp: '1632000000',
+                        blockNumber: '0'
+                    }
+                },
+                outputVaultBalanceChange: {
+                    amount: '200',
+                    vault: {
+                        id: '1',
+                        vaultId: 'vault-id1',
+                        token: {
+                            id: 'output_token',
+                            address: 'output_token',
+                            name: 'output_token',
+                            symbol: 'output_token',
+                            decimals: '1'
+                        }
+                    },
+                    id: '1',
+                    __typename: 'Withdraw',
+                    newVaultBalance: '0',
+                    oldVaultBalance: '0',
+                    timestamp: '0',
+                    transaction: {
+                        id: 'transaction_id',
+                        from: 'sender_address',
+                        timestamp: '1632000000',
+                        blockNumber: '0'
+                    },
+                    orderbook: { id: '1' }
+                },
+                order: {
+                    id: 'order_id',
+                    orderHash: 'orderHash'
+                },
+                inputVaultBalanceChange: {
+                    vault: {
+                        id: '1',
+                        vaultId: 'vault-id1',
+                        token: {
+                            id: 'output_token',
+                            address: 'output_token',
+                            name: 'output_token',
+                            symbol: 'output_token',
+                            decimals: '1'
+                        }
+                    },
+                    amount: '50',
+                    id: '1',
+                    __typename: 'Withdraw',
+                    newVaultBalance: '0',
+                    oldVaultBalance: '0',
+                    timestamp: '0',
+                    transaction: {
+                        id: 'transaction_id',
+                        from: 'sender_address',
+                        timestamp: '1632000000',
+                        blockNumber: '0'
+                    },
+                    orderbook: { id: '1' }
+                },
+                orderbook: {
+                    id: '0x00'
+                }
+            },
+            {
+                id: '3',
+                timestamp: '1632000000',
+                tradeEvent: {
+                    sender: 'sender_address',
+                    transaction: {
+                        id: 'transaction_id',
+                        from: 'sender_address',
+                        timestamp: '1632000000',
+                        blockNumber: '0'
+                    }
+                },
+                outputVaultBalanceChange: {
+                    amount: '400',
+                    vault: {
+                        id: '1',
+                        vaultId: 'vault-id1',
+                        token: {
+                            id: 'output_token',
+                            address: 'output_token',
+                            name: 'output_token',
+                            symbol: 'output_token',
+                            decimals: '1'
+                        }
+                    },
+                    id: '1',
+                    __typename: 'Withdraw',
+                    newVaultBalance: '0',
+                    oldVaultBalance: '0',
+                    timestamp: '0',
+                    transaction: {
+                        id: 'transaction_id',
+                        from: 'sender_address',
+                        timestamp: '1632000000',
+                        blockNumber: '0'
+                    },
+                    orderbook: { id: '1' }
+                },
+                order: {
+                    id: 'order_id',
+                    orderHash: 'orderHash'
+                },
+                inputVaultBalanceChange: {
+                    vault: {
+                        id: '1',
+                        vaultId: 'vault-id1',
+                        token: {
+                            id: 'output_token',
+                            address: 'output_token',
+                            name: 'output_token',
+                            symbol: 'output_token',
+                            decimals: '1'
+                        }
+                    },
+                    amount: '50',
+                    id: '1',
+                    __typename: 'Withdraw',
+                    newVaultBalance: '0',
+                    oldVaultBalance: '0',
+                    timestamp: '0',
+                    transaction: {
+                        id: 'transaction_id',
+                        from: 'sender_address',
+                        timestamp: '1632000000',
+                        blockNumber: '0'
+                    },
+                    orderbook: { id: '1' }
+                },
+                orderbook: {
+                    id: '0x00'
+                }
+            }
+        ];
+        const result = prepareHistoricalOrderChartData(takeOrderEntities, 'dark');
+        // calculate the weighted average of the ioratio values
+        const ioratioSum = 0.5 * 100 + 0.25 * 200 + 0.125 * 400;
+        const outputAmountSum = 100 + 200 + 400;
+        const ioratioAverage = ioratioSum / outputAmountSum;
+        expect(result.length).toEqual(1);
+        expect(result[0].value).toEqual(ioratioAverage);
+    });
+}

package/dist/services/index.d.ts

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

package/dist/services/index.js

@@ -0,0 +1 @@
+export { fetchParseRegistry, fetchRegistryDotrains } from './registry';

package/dist/services/registry.d.ts

@@ -0,0 +1,25 @@
+export type RegistryFile = {
+    name: string;
+    url: string;
+};
+export type RegistryDotrain = {
+    name: string;
+    dotrain: string;
+};
+/**
+ * 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.
+ *
+ * @param url - The URL of the registry file to fetch
+ * @returns A Promise that resolves to an array of objects containing file names and their corresponding URLs
+ * @throws Will throw an error if the fetch fails, if the response is not ok, or if the registry format is invalid
+ *
+ * @example
+ * const files = await fetchParseRegistryFile('https://example.com/registry');
+ * // Returns: [{ name: 'file1', url: 'https://example.com/file1.rain' }, ...]
+ */
+export declare const fetchParseRegistry: (url: string) => Promise<{
+    name: string;
+    url: string;
+}[]>;
+export declare const fetchRegistryDotrains: (url: string) => Promise<RegistryDotrain[]>;

package/dist/services/registry.js

@@ -0,0 +1,133 @@
+/**
+ * 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.
+ *
+ * @param url - The URL of the registry file to fetch
+ * @returns A Promise that resolves to an array of objects containing file names and their corresponding URLs
+ * @throws Will throw an error if the fetch fails, if the response is not ok, or if the registry format is invalid
+ *
+ * @example
+ * const files = await fetchParseRegistryFile('https://example.com/registry');
+ * // Returns: [{ name: 'file1', url: 'https://example.com/file1.rain' }, ...]
+ */
+export const fetchParseRegistry = async (url) => {
+    try {
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error('Failed to fetch registry.');
+        }
+        const filesList = await response.text();
+        const files = filesList
+            .split('\n')
+            .filter((line) => line.trim())
+            .map((line) => {
+            const [name, url] = line.split(' ');
+            return { name, url };
+        });
+        if (!files) {
+            throw new Error('Invalid stategy registry.');
+        }
+        return files;
+    }
+    catch (e) {
+        throw new Error(e instanceof Error ? e.message : 'Unknown error.');
+    }
+};
+export const fetchRegistryDotrains = async (url) => {
+    const files = await fetchParseRegistry(url);
+    const dotrains = await Promise.all(files.map(async (file) => {
+        try {
+            const response = await fetch(file.url);
+            if (!response.ok) {
+                throw new Error(`Failed to fetch dotrain for ${file.name}`);
+            }
+            const dotrain = await response.text();
+            return { name: file.name, dotrain };
+        }
+        catch (e) {
+            throw new Error(e instanceof Error
+                ? `Error fetching dotrain for ${file.name}: ${e.message}`
+                : `Unknown error fetching dotrain for ${file.name}`);
+        }
+    }));
+    return dotrains;
+};
+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');
+        });
+    });
+}

package/dist/services/time.d.ts

@@ -0,0 +1,6 @@
+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;

package/dist/services/time.js

@@ -0,0 +1,17 @@
+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;
+export const TIME_DELTA_30_DAYS = TIME_DELTA_24_HOURS * 30;
+export const TIME_DELTA_1_YEAR = TIME_DELTA_24_HOURS * 365;
+export function dateTimestamp(date) {
+    return Math.floor(date.getTime() / 1000);
+}
+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);
+    });
+}