@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,
            chainId: 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,
                    chainId: state.chainId,
                    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