@renegade-fi/core/dist/esm/createConfig.js

VanillaJS library for Renegade

import invariant from 'tiny-invariant';
import { http, createPublicClient, } from 'viem';
import { arbitrumSepolia } from 'viem/chains';
import { persist, subscribeWithSelector } from 'zustand/middleware';
import { createStore } from 'zustand/vanilla';
import { createStorage, noopStorage } from './createStorage.js';
import { AuthType } from './utils/websocket.js';
export function createConfig(parameters) {
    const { relayerUrl, priceReporterUrl, httpPort = 3000, pollingInterval = 5000, ssr, storage = createStorage({
        storage: typeof window !== 'undefined' && window.localStorage
            ? window.localStorage
            : noopStorage,
    }), useInsecureTransport = false, viemClient = createPublicClient({
        chain: arbitrumSepolia,
        transport: http(),
    }), websocketPort = 4000, adminKey, } = parameters;
    invariant(parameters.utils, 'Utils must be provided by the package if not supplied by the user.');
    /////////////////////////////////////////////////////////////////////////////////////////////////
    // Create store
    /////////////////////////////////////////////////////////////////////////////////////////////////
    function getInitialState() {
        return {
            seed: undefined,
            status: 'disconnected',
            id: undefined,
        };
    }
    const store = createStore(subscribeWithSelector(
    // only use persist middleware if storage exists
    storage
        ? persist(getInitialState, {
            name: 'store',
            partialize(state) {
                // Only persist "critical" store properties to preserve storage size.
                return {
                    id: state.id,
                    seed: state.seed,
                    status: state.status,
                };
            },
            skipHydration: ssr,
            storage: storage,
        })
        : getInitialState));
    return {
        utils: parameters.utils,
        renegadeKeyType: 'internal',
        storage,
        relayerUrl,
        priceReporterUrl,
        darkPoolAddress: parameters.darkPoolAddress,
        getBaseUrl: (route = '') => {
            const protocol = useInsecureTransport || parameters.relayerUrl.includes('localhost')
                ? 'http'
                : 'https';
            const baseUrl = parameters.relayerUrl.includes('localhost')
                ? `127.0.0.1:${httpPort}/v0`
                : `${parameters.relayerUrl}:${httpPort}/v0`;
            const formattedRoute = route.startsWith('/') ? route : `/${route}`;
            return `${protocol}://${baseUrl}${formattedRoute}`;
        },
        getPriceReporterBaseUrl: () => {
            const baseUrl = parameters.priceReporterUrl.includes('localhost')
                ? `ws://127.0.0.1:${websocketPort}/`
                : `wss://${parameters.priceReporterUrl}:${websocketPort}/`;
            return baseUrl;
        },
        getPriceReporterHTTPBaseUrl: (route = '') => {
            const baseUrl = parameters.priceReporterUrl.includes('localhost')
                ? `http://127.0.0.1:${httpPort}`
                : `https://${parameters.priceReporterUrl}:${httpPort}`;
            const formattedRoute = route.startsWith('/') ? route : `/${route}`;
            return `${baseUrl}${formattedRoute}`;
        },
        getWebsocketBaseUrl: () => {
            const protocol = useInsecureTransport || parameters.relayerUrl.includes('localhost')
                ? 'ws'
                : 'wss';
            const baseUrl = parameters.relayerUrl.includes('localhost')
                ? `127.0.0.1:${websocketPort}`
                : `${parameters.relayerUrl}:${websocketPort}`;
            return `${protocol}://${baseUrl}`;
        },
        getSymmetricKey(type) {
            invariant(parameters.utils, 'Utils are required');
            if (type === AuthType.Admin) {
                invariant(parameters.adminKey, 'Admin key is required');
                const symmetricKey = parameters.utils.b64_to_hex_hmac_key(parameters.adminKey);
                invariant(symmetricKey, 'Admin key is required');
                return symmetricKey;
            }
            const seed = store.getState().seed;
            invariant(seed, 'Seed is required');
            return parameters.utils.get_symmetric_key(seed);
        },
        pollingInterval,
        get state() {
            return store.getState();
        },
        setState(value) {
            let newState;
            if (typeof value === 'function')
                newState = value(store.getState());
            else
                newState = value;
            // Reset state if it got set to something not matching the base state
            const initialState = getInitialState();
            if (typeof newState !== 'object')
                newState = initialState;
            const isCorrupt = Object.keys(initialState).some((x) => !(x in newState));
            if (isCorrupt)
                newState = initialState;
            store.setState(newState, true);
        },
        subscribe(selector, listener, options) {
            return store.subscribe(selector, listener, options
                ? { ...options, fireImmediately: options.emitImmediately }
                : undefined);
        },
        viemClient,
        adminKey,
        _internal: {
            store,
            ssr: Boolean(ssr),
        },
        chainId: parameters.chainId,
    };
}
// The type of keychain a config is using
export const keyTypes = {
    EXTERNAL: 'external',
    INTERNAL: 'internal',
    NONE: 'none',
};
//# sourceMappingURL=createConfig.js.map