@swapkit/helpers 2.6.0 → 3.0.0-beta.1

package/src/modules/assetValue.ts

@@ -1,23 +1,22 @@
+import { BaseDecimal, Chain, type ChainId, ChainToChainId } from "../types/chains";
+import type { TokenNames, TokenTax } from "../types/tokens";
 import {
   type CommonAssetString,
-  CommonAssetStrings,
+  assetFromString,
   getAssetType,
   getCommonAssetInfo,
   getDecimal,
   isGasAsset,
-} from "../helpers/asset";
-import { warnOnce } from "../helpers/others";
-import { validateIdentifier } from "../helpers/validators";
-import { BaseDecimal, Chain, type ChainId, ChainToChainId } from "../types/chains";
-import type { TokenNames, TokenTax } from "../types/tokens";
+} from "../utils/asset";
+import { warnOnce } from "../utils/others";
+import { type TokenListName, loadTokenLists } from "../utils/tokens";
+import { validateIdentifier } from "../utils/validators";
 
 import type { NumberPrimitives } from "./bigIntArithmetics";
 import { BigIntArithmetics, formatBigIntToSafeValue } from "./bigIntArithmetics";
 import { SwapKitError } from "./swapKitError";
 import type { SwapKitValueType } from "./swapKitNumber";
 
-export const TRADE_OR_SYNTH_ASSET_SEPERATOR = /~|\//;
-
 const staticTokensMap = new Map<
   TokenNames,
   { tax?: TokenTax; decimal: number; identifier: string }
@@ -27,8 +26,7 @@ type ConditionalAssetValueReturn<T extends { asyncTokenLookup?: boolean }> =
   T["asyncTokenLookup"] extends true ? Promise<AssetValue> : AssetValue;
 
 type AssetIdentifier =
-  | { asset: CommonAssetString }
-  | { asset: TokenNames }
+  | { asset: CommonAssetString | TokenNames }
   | { asset: string }
   | { chain: Chain };
 
@@ -123,16 +121,11 @@ export class AssetValue extends BigIntArithmetics {
     ...fromAssetOrChain
   }: T & AssetValueFromParams): ConditionalAssetValueReturn<T> {
     const parsedValue = value instanceof BigIntArithmetics ? value.getValue("string") : value;
-    const isFromChain = "chain" in fromAssetOrChain;
-    const assetOrChain = isFromChain ? fromAssetOrChain.chain : fromAssetOrChain.asset;
-
-    const isFromCommonAssetOrChain =
-      isFromChain ||
-      CommonAssetStrings.includes(assetOrChain as (typeof CommonAssetStrings)[number]);
+    const assetOrChain = getAssetString(fromAssetOrChain);
 
-    const { identifier: unsafeIdentifier, decimal: commonAssetDecimal } = isFromCommonAssetOrChain
-      ? getCommonAssetInfo(assetOrChain as CommonAssetString)
-      : { identifier: assetOrChain, decimal: undefined };
+    const { identifier: unsafeIdentifier, decimal: commonAssetDecimal } = getCommonAssetInfo(
+      assetOrChain as CommonAssetString,
+    );
 
     const { chain, isSynthetic, isTradeAsset } = getAssetInfo(unsafeIdentifier);
     const token = staticTokensMap.get(
@@ -140,11 +133,12 @@ export class AssetValue extends BigIntArithmetics {
         ? (unsafeIdentifier as TokenNames)
         : (unsafeIdentifier.toUpperCase() as TokenNames),
     );
+
     const tokenDecimal = token?.decimal || commonAssetDecimal;
 
     warnOnce(
       !(asyncTokenLookup || tokenDecimal),
-      `Couldn't find static decimal for a token on chain (Using default ${BaseDecimal[chain]} decimal as fallback).
+      `Couldn't find static decimal for one or more tokens on ${chain} (Using default ${BaseDecimal[chain]} decimal as fallback).
 This can result in incorrect calculations and mess with amount sent on transactions.
 You can load static assets by installing @swapkit/tokens package and calling AssetValue.loadStaticAssets()
 or by passing asyncTokenLookup: true to the from() function, which will make it async and return a promise.`,
@@ -155,106 +149,34 @@ or by passing asyncTokenLookup: true to the from() function, which will make it
       identifier: unsafeIdentifier,
     };
 
+    const isSynthOrTrade = isSynthetic || isTradeAsset;
+
     const adjustedValue = fromBaseDecimal
       ? safeValue(BigInt(parsedValue), fromBaseDecimal)
       : safeValue(parsedValue, decimal);
 
     const assetValue = asyncTokenLookup
       ? createAssetValue(identifier, fromBaseDecimal ? adjustedValue : parsedValue)
-      : isSynthetic || isTradeAsset
+      : isSynthOrTrade
         ? createSyntheticAssetValue(identifier, adjustedValue)
         : new AssetValue({ tax, decimal, identifier, value: adjustedValue });
 
     return assetValue as ConditionalAssetValueReturn<T>;
   }
 
-  static loadStaticAssets() {
-    return new Promise<{ ok: true } | { ok: false; message: string; error: any }>(
-      (resolve, reject) => {
-        try {
-          import("@swapkit/tokens").then((tokenPackage) => {
-            for (const tokenList of Object.values(tokenPackage.tokenLists)) {
-              for (const { identifier, chain, ...rest } of tokenList.tokens) {
-                staticTokensMap.set(
-                  chain === "SOL" ? identifier : (identifier.toUpperCase() as TokenNames),
-                  {
-                    identifier,
-                    decimal: "decimals" in rest ? rest.decimals : BaseDecimal[chain as Chain],
-                  },
-                );
-              }
-            }
-
-            resolve({ ok: true });
-          });
-        } catch (error) {
-          console.error(error);
-          reject({
-            ok: false,
-            error,
-            message:
-              "Couldn't load static assets. Ensure you have installed @swapkit/tokens package",
-          });
-        }
-      },
-    );
-  }
+  static async loadStaticAssets(listNames?: TokenListName[]) {
+    const lists = await loadTokenLists(listNames);
 
-  /**
-   * @deprecated use AssetValue.from({ asset, value, asyncTokenLookup: true })
-   */
-  static fromString(asset: string, value: NumberPrimitives = 0) {
-    return AssetValue.from({ asset, value, asyncTokenLookup: true });
-  }
-  /**
-   * @deprecated use AssetValue.from({ asset, value, asyncTokenLookup: true })
-   */
-  static fromIdentifier(
-    asset: `${Chain}.${string}` | `${Chain}/${string}` | TokenNames,
-    value: NumberPrimitives = 0,
-  ) {
-    return AssetValue.from({ asset: asset as TokenNames, value, asyncTokenLookup: true });
-  }
-  /**
-   * @deprecated use AssetValue.from({ asset, value })
-   */
-  static fromStringSync(asset: string, value: NumberPrimitives = 0) {
-    return AssetValue.from({ asset, value });
-  }
-  /**
-   * @deprecated use AssetValue.from({ asset, value, fromBaseDecimal, asyncTokenLookup: true })
-   */
-  static fromStringWithBase(
-    asset: string,
-    value: string | bigint = 0n,
-    fromBaseDecimal: number = BaseDecimal.THOR,
-  ) {
-    return AssetValue.from({ asyncTokenLookup: true, asset, value, fromBaseDecimal });
-  }
-  /**
-   * @deprecated use AssetValue.from({ asset, value, fromBaseDecimal, asyncTokenLookup: true })
-   */
-  static fromStringWithBaseSync(
-    asset: string,
-    value: string | bigint = 0n,
-    fromBaseDecimal: number = BaseDecimal.THOR,
-  ) {
-    return AssetValue.from({ asset, value, fromBaseDecimal });
-  }
-  /**
-   * @deprecated use AssetValue.from({ asset, value })
-   */
-  static fromIdentifierSync(asset: TokenNames, value: NumberPrimitives = 0) {
-    return AssetValue.from({ asset, value });
-  }
-  /**
-   * @deprecated use AssetValue.from({ asset, value }) or AssetValue.from({ chain, value })
-   */
-  static fromChainOrSignature(assetOrChain: CommonAssetString, value: NumberPrimitives = 0) {
-    if (Object.values(Chain).includes(assetOrChain as Chain)) {
-      return AssetValue.from({ chain: assetOrChain as Chain, value });
+    for (const { tokens } of Object.values(lists)) {
+      for (const { identifier, chain, ...rest } of tokens) {
+        const tokenKey = (chain === "SOL" ? identifier : identifier.toUpperCase()) as TokenNames;
+        const tokenDecimal = "decimals" in rest ? rest.decimals : BaseDecimal[chain as Chain];
+
+        staticTokensMap.set(tokenKey, { identifier, decimal: tokenDecimal });
+      }
     }
-    return AssetValue.from({ asset: assetOrChain, value });
+
+    return true;
   }
 }
 
@@ -305,7 +227,11 @@ async function createAssetValue(identifier: string, value: NumberPrimitives = 0)
     staticTokensMap.set(modifiedIdentifier, { identifier, decimal });
   }
 
-  return new AssetValue({ decimal, value: safeValue(value, decimal), identifier });
+  return new AssetValue({
+    decimal,
+    value: safeValue(value, decimal),
+    identifier,
+  });
 }
 
 function createSyntheticAssetValue(identifier: string, value: NumberPrimitives = 0) {
@@ -314,11 +240,11 @@ function createSyntheticAssetValue(identifier: string, value: NumberPrimitives =
     : undefined;
   const isMayaOrThor = chain ? [Chain.Maya, Chain.THORChain].includes(chain) : false;
 
-  const assetSeperator = identifier.slice(0, 14).includes("~") ? "~" : "/";
+  const assetSeparator = identifier.slice(0, 14).includes("~") ? "~" : "/";
 
   const [synthChain, symbol] = isMayaOrThor
-    ? identifier.split(".").slice(1).join().split(assetSeperator)
-    : identifier.split(assetSeperator);
+    ? identifier.split(".").slice(1).join().split(assetSeparator)
+    : identifier.split(assetSeparator);
 
   if (!(synthChain && symbol)) {
     throw new SwapKitError({
@@ -330,7 +256,7 @@ function createSyntheticAssetValue(identifier: string, value: NumberPrimitives =
   return new AssetValue({
     decimal: 8,
     value: safeValue(value, 8),
-    identifier: `${chain || Chain.THORChain}.${synthChain}${assetSeperator}${symbol}`,
+    identifier: `${chain || Chain.THORChain}.${synthChain}${assetSeparator}${symbol}`,
   });
 }
 
@@ -340,54 +266,69 @@ function safeValue(value: NumberPrimitives, decimal: number) {
     : value;
 }
 
-// TODO refactor & split into smaller functions
+function getAssetString(assetOrChain: AssetIdentifier) {
+  if ("chain" in assetOrChain) return assetOrChain.chain;
+
+  const { chain, symbol } = assetFromString(assetOrChain.asset);
+  const isNativeChain = getAssetType({ chain, symbol }) === "Native";
+
+  return isNativeChain ? chain : assetOrChain.asset;
+}
+
 function getAssetInfo(identifier: string) {
-  const isSynthetic = identifier.slice(0, 14).includes("/");
-  const isTradeAsset = identifier.slice(0, 14).includes("~");
-  const isSynthOrTradeAsset = isSynthetic || isTradeAsset;
-  const assetSeperator = identifier.slice(0, 14).includes("~") ? "~" : "/";
+  const shortIdentifier = identifier.slice(0, 14);
+  const splitIdentifier = identifier.split(".");
+  const identifierChain = splitIdentifier[0]?.toUpperCase() as Chain;
+  const isThorOrMaya = [Chain.THORChain, Chain.Maya].includes(identifierChain);
 
-  const isThorchain = identifier.split(".")?.[0]?.toUpperCase() === Chain.THORChain;
-  const isMaya = identifier.split(".")?.[0]?.toUpperCase() === Chain.Maya;
+  const isSynthetic = shortIdentifier.includes("/");
+  const isTradeAsset = shortIdentifier.includes("~");
+  const isSynthOrTrade = isSynthetic || isTradeAsset;
+  const assetSeparator = isTradeAsset ? "~" : "/";
 
-  const [synthChain, synthSymbol = ""] =
-    isThorchain || isMaya
-      ? identifier.split(".").slice(1).join().split(assetSeperator)
-      : identifier.split(assetSeperator);
+  const [synthChain, synthSymbol = ""] = isThorOrMaya
+    ? splitIdentifier.slice(1).join().split(assetSeparator)
+    : identifier.split(assetSeparator);
 
-  if (isSynthOrTradeAsset && !(synthChain && synthSymbol)) {
+  if (isSynthOrTrade && !(synthChain && synthSymbol)) {
     throw new SwapKitError({
       errorKey: "helpers_invalid_asset_identifier",
       info: { identifier },
     });
   }
 
-  const adjustedIdentifier =
-    identifier.includes(".") && !isSynthOrTradeAsset
-      ? identifier
-      : `${isMaya ? Chain.Maya : Chain.THORChain}.${synthSymbol}`;
-
-  const [chain, ...rest] = adjustedIdentifier.split(".") as [Chain, string];
+  const [chain, ...rest] = (
+    identifier.includes(".") && !isSynthOrTrade ? identifier : `${identifierChain}.${synthSymbol}`
+  ).split(".") as [Chain, string];
 
-  const symbol = isSynthOrTradeAsset ? synthSymbol : rest.join(".");
-  const splitSymbol = symbol.split("-");
-  const ticker = (
-    splitSymbol.length === 1 ? splitSymbol[0] : splitSymbol.slice(0, -1).join("-")
-  ) as string;
-  const unformattedAddress =
-    splitSymbol.length === 1 ? undefined : splitSymbol[splitSymbol.length - 1];
+  const assetSymbol = isSynthOrTrade ? synthSymbol : rest.join(".");
 
-  const address = chain === Chain.Solana ? unformattedAddress : unformattedAddress?.toLowerCase();
+  const { address, ticker } = getAssetBaseInfo({ symbol: assetSymbol, chain });
+  const symbol =
+    (isSynthOrTrade ? `${synthChain}${assetSeparator}` : "") +
+    (address ? `${ticker}-${address ?? ""}` : assetSymbol);
 
   return {
     address,
     chain,
-    isGasAsset: isGasAsset({ chain, symbol }),
+    isSynthOrTrade,
     isSynthetic,
     isTradeAsset,
     ticker,
-    symbol:
-      (isSynthOrTradeAsset ? `${synthChain}${assetSeperator}` : "") +
-      (address ? `${ticker}-${address ?? ""}` : symbol),
+    symbol,
+    isGasAsset: isGasAsset({ chain, symbol: assetSymbol }),
   };
 }
+
+function getAssetBaseInfo({ symbol, chain }: { symbol: string; chain: Chain }) {
+  const splitSymbol = symbol.split("-");
+  const unformattedAddress =
+    splitSymbol.length === 1 ? undefined : splitSymbol[splitSymbol.length - 1];
+
+  const address = chain === Chain.Solana ? unformattedAddress : unformattedAddress?.toLowerCase();
+  const ticker = (
+    splitSymbol.length === 1 ? splitSymbol[0] : splitSymbol.slice(0, -1).join("-")
+  ) as string;
+
+  return { address, ticker };
+}

package/src/modules/bigIntArithmetics.ts

@@ -131,7 +131,6 @@ export class BigIntArithmetics {
     return this.#comparison("eqValue", value);
   }
 
-  // @ts-expect-error False positive
   getValue<T extends AllowedNumberTypes>(type: T, decimal?: number): NumberPrimitivesType[T] {
     const value = this.formatBigIntToSafeValue(
       this.bigIntValue,
@@ -146,10 +145,11 @@ export class BigIntArithmetics {
       case "bigint":
         return ((this.bigIntValue * 10n ** BigInt(this.decimal || 8n)) /
           this.decimalMultiplier) as NumberPrimitivesType[T];
+      default:
+        return value as NumberPrimitivesType[T];
     }
   }
 
-  // @ts-expect-error
   getBaseValue<T extends AllowedNumberTypes>(type: T, decimal?: number): NumberPrimitivesType[T] {
     const divisor =
       this.decimalMultiplier / toMultiplier(decimal || this.decimal || BaseDecimal.THOR);
@@ -162,6 +162,8 @@ export class BigIntArithmetics {
         return baseValue.toString() as NumberPrimitivesType[T];
       case "bigint":
         return baseValue as NumberPrimitivesType[T];
+      default:
+        return baseValue as NumberPrimitivesType[T];
     }
   }
 
@@ -360,6 +362,8 @@ export class BigIntArithmetics {
         return compareToValue <= value;
       case "eqValue":
         return compareToValue === value;
+      default:
+        return false;
     }
   }
 

package/src/modules/requestClient.ts

@@ -1,75 +1,63 @@
-type Options = Parameters<typeof fetch>[1] & {
-  headers?: Record<string, string>;
-  apiKey?: string;
-  method?: "GET" | "POST";
-  onError?: (error: any) => any;
+import { SKConfig } from "./swapKitConfig";
+
+type Options = RequestInit & {
+  /**
+   * @deprecated Use onSuccess instead
+   */
   responseHandler?: (response: any) => any;
-  searchParams?: Record<string, string>;
   json?: unknown;
+  onError?: (error: any) => any;
+  onSuccess?: (response: any) => any;
+  searchParams?: Record<string, string>;
 };
 
-let clientConfig: Options = {};
-
-export const defaultRequestHeaders =
-  typeof window !== "undefined"
-    ? ({} as Record<string, string>)
-    : { referrer: "https://sk.thorswap.net", referer: "https://sk.thorswap.net" };
-
-export function setRequestClientConfig({ apiKey, ...config }: Options) {
-  clientConfig = { ...config, apiKey };
-}
-
-async function fetchWithConfig(url: string, options: Options) {
-  const { apiKey, ...config } = clientConfig;
-  const { searchParams, json, body } = options;
-  const headers = {
-    ...defaultRequestHeaders,
-    ...config.headers,
-    ...options.headers,
-    ...(json ? { "Content-Type": "application/json" } : {}),
-  } as Record<string, string>;
-
-  const bodyToSend = json ? JSON.stringify(json) : body;
-
-  const urlInstance = new URL(url);
-  if (searchParams) {
-    urlInstance.search = new URLSearchParams(searchParams).toString();
-  }
+export const RequestClient = {
+  get: fetchWithConfig("GET"),
+  post: fetchWithConfig("POST"),
+  extend: (extendOptions: Options) => ({
+    get: fetchWithConfig("GET", extendOptions),
+    post: fetchWithConfig("POST", extendOptions),
+    extend: (newOptions: Options) => RequestClient.extend({ ...extendOptions, ...newOptions }),
+  }),
+};
 
-  if (apiKey) headers["x-api-key"] = apiKey;
+function fetchWithConfig(method: "GET" | "POST", extendOptions: Options = {}) {
+  return async <T>(url: string, options: Options = {}): Promise<T> => {
+    const { searchParams, json, body, headers: headersOptions } = { ...extendOptions, ...options };
+    const { swapKit } = SKConfig.get("apiKeys");
 
-  try {
-    const response = await fetch(urlInstance.toString(), {
-      ...config,
-      ...options,
-      body: bodyToSend,
-      headers,
-    });
-    const body = await response.json();
+    const isJson = json || url.endsWith(".json");
+    const bodyToSend = isJson ? JSON.stringify(json) : body;
+    const urlInstance = new URL(url);
 
-    if (options.responseHandler) return options.responseHandler(body);
+    if (searchParams) {
+      urlInstance.search = new URLSearchParams(searchParams).toString();
+    }
 
-    return body;
-  } catch (error) {
-    if (options.onError) return options.onError(error);
+    const headers = {
+      ...headersOptions,
+      ...(isJson ? { "Content-Type": "application/json" } : {}),
+      ...(swapKit ? { "x-api-key": swapKit } : {}),
+    };
 
-    console.error(error);
-  }
+    try {
+      const response = await fetch(urlInstance.toString(), {
+        ...options,
+        method,
+        body: bodyToSend,
+        headers,
+      });
+
+      if (!response.ok) {
+        const message = await response.text();
+        throw new Error(`${response.statusText}(${response.status}): ${message}`);
+      }
+
+      const body = await response.json();
+
+      return options.onSuccess?.(body) || options.responseHandler?.(body) || body;
+    } catch (error) {
+      return options.onError?.(error) || console.error(error);
+    }
+  };
 }
-
-export const RequestClient = {
-  get: async <T>(url: string, options?: Options): Promise<T> =>
-    fetchWithConfig(url, { ...options, method: "GET" }),
-  post: async <T>(url: string, options?: Options): Promise<T> =>
-    fetchWithConfig(url, { ...options, method: "POST" }),
-  extend: (options: Options) => {
-    const extendedConfig = { ...clientConfig, ...options };
-    return {
-      get: async <T>(url: string, options?: Options): Promise<T> =>
-        fetchWithConfig(url, { ...extendedConfig, ...options, method: "GET" }),
-      post: async <T>(url: string, options?: Options): Promise<T> =>
-        fetchWithConfig(url, { ...extendedConfig, ...options, method: "POST" }),
-      extend: (newOptions: Options) => RequestClient.extend({ ...extendedConfig, ...newOptions }),
-    };
-  },
-};

package/src/modules/swapKitConfig.ts

@@ -0,0 +1,134 @@
+import { createStore } from "zustand/vanilla";
+import { Chain, EXPLORER_URLS, NODE_URLS, RPC_URLS, WalletOption } from "../types";
+
+export type SKConfigIntegrations = {
+  chainflip?: { useSDKBroker?: boolean; brokerUrl: string };
+  coinbase?: {
+    appName: string;
+    appLogoUrl?: string | null;
+    darkMode?: boolean;
+    linkAPIUrl?: string;
+    overrideIsMetaMask?: boolean;
+    overrideIsCoinbaseWallet?: boolean;
+    overrideIsCoinbaseBrowser?: boolean;
+    headlessMode?: boolean;
+    reloadOnDisconnect?: boolean;
+  };
+  trezor?: { email: string; appUrl: string };
+  keepKey?: { name: string; imageUrl: string; basePath: string; url: string };
+  radix: {
+    dAppDefinitionAddress: string;
+    applicationName: string;
+    applicationVersion: string;
+    network: { networkId: number; networkName: string; dashboardBase: string };
+  };
+};
+
+const initialState = {
+  // TODO: figure out how to type apis without using toolbox directly
+  // Maybe move rpc/toolbox apis to helpers?
+  apis: {} as { [key in Chain]: any },
+  chains: Object.values(Chain),
+  wallets: Object.values(WalletOption),
+  explorerUrls: EXPLORER_URLS,
+  nodeUrls: NODE_URLS,
+  rpcUrls: RPC_URLS,
+
+  apiKeys: {
+    blockchair: "",
+    kado: "",
+    keepKey: "",
+    swapKit: "",
+    walletConnectProjectId: "",
+  },
+
+  envs: {
+    apiUrl: "https://api.swapkit.dev",
+    devApiUrl: "https://dev-api.swapkit.dev",
+    isDev: false,
+    isStagenet: false,
+  },
+
+  integrations: {
+    radix: {
+      applicationName: "Swapkit Playground",
+      applicationVersion: "0.0.1",
+      dAppDefinitionAddress: "account_rdx128r289p58222hcvev7frs6kue76pl7pdcnw8725aw658v0zggkh9ws",
+      network: {
+        dashboardBase: "https://dashboard.radixdlt.com",
+        networkId: 1,
+        networkName: "mainnet",
+      },
+    },
+  } as SKConfigIntegrations,
+};
+type SKState = typeof initialState;
+
+export type SKConfigState = {
+  apiKeys?: Partial<SKState["apiKeys"]>;
+  chains?: SKState["chains"];
+  envs?: Partial<SKState["envs"]>;
+  explorerUrls?: Partial<SKState["explorerUrls"]>;
+  integrations?: Partial<SKConfigIntegrations>;
+  nodeUrls?: Partial<SKState["nodeUrls"]>;
+  rpcUrls?: Partial<SKState["rpcUrls"]>;
+  wallets?: SKState["wallets"];
+};
+
+type SwapKitConfigStore = SKState & {
+  setApiKey: (key: keyof SKState["apiKeys"], apiKey: string) => void;
+  setConfig: (config: SKConfigState) => void;
+  setEnv: <T extends keyof SKState["envs"]>(key: T, value: SKState["envs"][T]) => void;
+  setExplorerUrl: (chain: keyof SKState["explorerUrls"], url: string) => void;
+  setNodeUrl: (chain: keyof SKState["nodeUrls"], url: string) => void;
+  setRpcUrl: (chain: keyof SKState["rpcUrls"], url: string) => void;
+  setIntegrationConfig: (
+    integration: keyof SKState["integrations"],
+    config: SKConfigIntegrations[keyof SKConfigIntegrations],
+  ) => void;
+};
+
+const swapKitState = createStore<SwapKitConfigStore>((set) => ({
+  ...initialState,
+
+  setApiKey: (key, apiKey) => set((s) => ({ apiKeys: { ...s.apiKeys, [key]: apiKey } })),
+  setEnv: (key, value) => set((s) => ({ envs: { ...s.envs, [key]: value } })),
+  setExplorerUrl: (chain, url) =>
+    set((s) => ({ explorerUrls: { ...s.explorerUrls, [chain]: url } })),
+  setNodeUrl: (chain, url) => set((s) => ({ nodeUrls: { ...s.nodeUrls, [chain]: url } })),
+  setRpcUrl: (chain, url) => set((s) => ({ rpcUrls: { ...s.rpcUrls, [chain]: url } })),
+  setIntegrationConfig: (integration, config) =>
+    set((s) => ({ integrations: { ...s.integrations, [integration]: config } })),
+  setConfig: (config) =>
+    set((s) => ({
+      apiKeys: { ...s.apiKeys, ...config.apiKeys },
+      envs: { ...s.envs, ...config.envs },
+      explorerUrls: { ...s.explorerUrls, ...config.explorerUrls },
+      integrations: { ...s.integrations, ...config.integrations },
+      nodeUrls: { ...s.nodeUrls, ...config.nodeUrls },
+      rpcUrls: { ...s.rpcUrls, ...config.rpcUrls },
+      chains: s.chains.concat(config.chains || []),
+      wallets: s.wallets.concat(config.wallets || []),
+    })),
+}));
+
+export const SKConfig = {
+  getState: swapKitState.getState,
+  get: <T extends keyof SKState>(key: T) => swapKitState.getState()[key],
+  set: <T extends SKConfigState>(config: T) => swapKitState.getState().setConfig(config),
+
+  setApiKey: <T extends keyof SKState["apiKeys"]>(key: T, apiKey: string) =>
+    swapKitState.getState().setApiKey(key, apiKey),
+  setEnv: <T extends keyof SKState["envs"]>(key: T, value: SKState["envs"][T]) =>
+    swapKitState.getState().setEnv(key, value),
+  setExplorerUrl: <T extends keyof SKState["explorerUrls"]>(chain: T, url: string) =>
+    swapKitState.getState().setExplorerUrl(chain, url),
+  setNodeUrl: <T extends keyof SKState["nodeUrls"]>(chain: T, url: string) =>
+    swapKitState.getState().setNodeUrl(chain, url),
+  setRpcUrl: <T extends keyof SKState["rpcUrls"]>(chain: T, url: string) =>
+    swapKitState.getState().setRpcUrl(chain, url),
+  setIntegrationConfig: <T extends keyof SKState["integrations"]>(
+    integration: T,
+    config: SKConfigIntegrations[T],
+  ) => swapKitState.getState().setIntegrationConfig(integration, config),
+};