@swapkit/helpers 3.0.0-beta.0 → 3.0.0-beta.1

package/src/api/thorswapStatic/endpoints.ts

@@ -1,4 +1,10 @@
-import { AssetValue, type ProviderName, RequestClient, getChainIdentifier } from "@swapkit/helpers";
+import {
+  AssetValue,
+  Chain,
+  type ProviderName,
+  RequestClient,
+  getChainIdentifier,
+} from "@swapkit/helpers";
 
 import { getTokenListProviders } from "../swapkitApi/endpoints";
 import type { TokenListProvidersResponse } from "../swapkitApi/types";
@@ -11,7 +17,9 @@ export function getStaticTokenList(tokenListName: string) {
 }
 
 export function getLogoForAsset(assetString: string) {
-  return `${baseUrl}/token-list/images/${assetString.toLowerCase()}.png`;
+  const mappedAssetIcon = getMappedAssetIcon(assetString);
+
+  return `${baseUrl}/token-list/images/${mappedAssetIcon}.png`;
 }
 
 export function getChainLogoForAsset(assetString: string) {
@@ -28,3 +36,11 @@ export async function getProviderLogo(providerName: ProviderName | string) {
 
   return providerData.find((p) => p.name === providerName)?.url;
 }
+
+function getMappedAssetIcon(assetString: string) {
+  const { symbol } = AssetValue.from({ asset: assetString });
+
+  if (symbol === Chain.Ethereum) return "eth.eth";
+
+  return assetString.toLowerCase();
+}

package/src/contracts/index.ts

@@ -20,7 +20,7 @@ import { uniswapV3_100 } from "./abis/uniswapV3_100";
 import { uniswapV3_500 } from "./abis/uniswapV3_500";
 import { uniswapV3_3000 } from "./abis/uniswapV3_3000";
 import { uniswapV3_10000 } from "./abis/uniswapV3_10000";
-import { lowercasedRouterAbiMapping } from "./routers/index";
+import { lowercasedRouterAbiMapping } from "./routers";
 
 type AbiTypes =
   | typeof avaxGeneric

package/src/index.ts

@@ -1,5 +1,15 @@
 /**
- * Helpers
+ * Modules
+ */
+export * from "./modules/assetValue";
+export * from "./modules/bigIntArithmetics";
+export * from "./modules/requestClient";
+export * from "./modules/swapKitError";
+export * from "./modules/swapKitNumber";
+export * from "./modules/swapKitConfig";
+
+/**
+ * Utils
  */
 export * from "./utils/asset";
 export * from "./utils/derivationPath";
@@ -9,14 +19,9 @@ export * from "./utils/others";
 export * from "./utils/plugin";
 export * from "./utils/validators";
 export * from "./utils/wallets";
+export * from "./utils/tokens";
+
 /**
- * Modules
+ * Types
  */
-export * from "./modules/assetValue";
-export * from "./modules/bigIntArithmetics";
-export * from "./modules/requestClient";
-export * from "./modules/swapKitError";
-export * from "./modules/swapKitNumber";
-export * from "./modules/swapKitConfig";
-
-export * from "./types/index";
+export * from "./types";

package/src/modules/__tests__/assetValue.test.ts

@@ -79,13 +79,15 @@ describe("AssetValue", () => {
 
       expect(atomDerived.toString()).toBe("THOR.ATOM");
 
+      const value = 10;
       const mayaCacao = AssetValue.from({
         asset: "MAYA.CACAO",
-        value: 10,
+        value,
       });
 
       expect(mayaCacao.toString()).toBe("MAYA.CACAO");
-      expect(mayaCacao.getBaseValue("string")).toBe("1000000000");
+      const expectedValue = value * 10_000_000_000;
+      expect(mayaCacao.getBaseValue("string")).toBe(expectedValue.toString());
 
       const ethMayaSynth = AssetValue.from({
         asset: "MAYA.ETH/ETH",
@@ -105,29 +107,38 @@ describe("AssetValue", () => {
       expect(ethTCSynthFallback.toString({ includeSynthProtocol: true })).toBe("THOR.ETH/ETH");
       expect(ethTCSynthFallback.getBaseValue("string")).toBe("1000000000");
 
-      // TODO:
-      // const radixXWBTC = new AssetValue({
-      //   identifier:
-      //     "RADIX.XWBTC-resource_rdx1t580qxc7upat7lww4l2c4jckacafjeudxj5wpjrrct0p3e82sq4y75",
-      //   decimal: 8,
-      //   value: 11112222,
-      // });
-
-      // expect(radixXWBTC.toString()).toBe(
-      //   "RADIX.XWBTC-resource_rdx1t580qxc7upat7lww4l2c4jckacafjeudxj5wpjrrct0p3e82sq4y75",
-      // )
+      const solFromString = AssetValue.from({ asset: "SOL.SOL" });
+      expect(solFromString.toString()).toBe("SOL.SOL");
+    });
+
+    test("regres cases", () => {
+      const arbWeth = AssetValue.from({
+        asset: "ARB.WETH-0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
+      });
+      expect(arbWeth.toString()).toBe("ARB.WETH-0x82af49447d8a07e3bd95bd0d56f35241523fbab1");
+
+      const baseAssetFromString = AssetValue.from({
+        asset: "BASE.USDC-0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+      });
+      expect(baseAssetFromString.toString()).toBe(
+        "BASE.USDC-0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+      );
+
+      const avaxSolanaAsset = AssetValue.from({
+        asset: "AVAX.SOL-0XFE6B19286885A4F7F55ADAD09C3CD1F906D2478F",
+      });
+      expect(avaxSolanaAsset.toString()).toBe(
+        "AVAX.SOL-0xfe6b19286885a4f7f55adad09c3cd1f906d2478f",
+      );
     });
   });
 
   describe("set", () => {
     test("get a copy of an assetValue with a new value", () => {
-      const btc = AssetValue.from({
-        asset: "BTC.BTC",
-      });
+      const btc = AssetValue.from({ asset: "BTC.BTC" });
 
       const btc2 = btc.set(10);
 
-      expect(btc2).toBeDefined();
       expect(btc2).toEqual(
         expect.objectContaining({
           chain: Chain.Bitcoin,
@@ -293,8 +304,21 @@ describe("AssetValue", () => {
       const thor = AssetValue.from({ asset: "ETH.THOR" });
       expect(thor.toString()).toBe("ETH.THOR-0xa5f2211b9b8170f694421f2046281775e8468044");
 
-      const ethSynth = await AssetValue.from({ asset: "ETH/ETH", asyncTokenLookup: true });
+      const ethSynth = await AssetValue.from({
+        asset: "ETH/ETH",
+        asyncTokenLookup: true,
+      });
       expect(ethSynth.toString()).toBe("ETH/ETH");
+
+      const eth = await AssetValue.from({
+        asset: "eth.eth",
+      });
+      expect(eth.toString()).toBe("ETH.ETH");
+
+      const ethFromChain = await AssetValue.from({
+        chain: Chain.Ethereum,
+      });
+      expect(ethFromChain.toString()).toBe("ETH.ETH");
     });
   });
 
@@ -509,7 +533,9 @@ describe("AssetValue", () => {
     test("returns safe decimals if string is not in `@swapkit/tokens` lists", async () => {
       await AssetValue.loadStaticAssets();
       const fakeAvaxUSDCAssetString = "AVAX.USDC-1234";
-      const fakeAvaxUSDCAsset = AssetValue.from({ asset: fakeAvaxUSDCAssetString });
+      const fakeAvaxUSDCAsset = AssetValue.from({
+        asset: fakeAvaxUSDCAssetString,
+      });
 
       expect(fakeAvaxUSDCAsset).toBeDefined();
       expect(fakeAvaxUSDCAsset).toEqual(
@@ -528,7 +554,9 @@ describe("AssetValue", () => {
     test("returns safe decimals if string is not in `@swapkit/tokens` lists with multiple dashes", async () => {
       await AssetValue.loadStaticAssets();
       const fakeAvaxUSDCAssetString = "AVAX.USDC-LPT-1234";
-      const fakeAvaxUSDCAsset2 = AssetValue.from({ asset: fakeAvaxUSDCAssetString });
+      const fakeAvaxUSDCAsset2 = AssetValue.from({
+        asset: fakeAvaxUSDCAssetString,
+      });
 
       expect(fakeAvaxUSDCAsset2).toBeDefined();
       expect(fakeAvaxUSDCAsset2).toEqual(
@@ -557,8 +585,8 @@ describe("AssetValue", () => {
           decimal: 8,
           isGasAsset: false,
           isSynthetic: false,
-          symbol: "BTC.b-0x152b9d0fdc40c096757f570a51e494bd4b943e50",
-          ticker: "BTC.b",
+          symbol: "BTC.B-0x152b9d0fdc40c096757f570a51e494bd4b943e50",
+          ticker: "BTC.B",
         }),
       );
     });

package/src/modules/__tests__/swapKitConfig.test.ts

@@ -17,17 +17,17 @@ describe("swapKitConfig", () => {
     SKConfig.setApiKey("swapKit", "123");
     expect(SKConfig.get("apiKeys").swapKit).toBe("123");
 
-    SKConfig.setApiKey("ethplorer", "123");
+    SKConfig.setApiKey("walletConnectProjectId", "123");
     expect(SKConfig.get("apiKeys")).toMatchObject({
       swapKit: "123",
-      ethplorer: "123",
+      walletConnectProjectId: "123",
     });
 
     SKConfig.setExplorerUrl(Chain.Ethereum, "https://lul.xyz");
     expect(SKConfig.getState()).toMatchObject({
       apiKeys: {
         swapKit: "123",
-        ethplorer: "123",
+        walletConnectProjectId: "123",
       },
       explorerUrls: {
         [Chain.Ethereum]: "https://lul.xyz",

package/src/modules/assetValue.ts

@@ -2,13 +2,14 @@ import { BaseDecimal, Chain, type ChainId, ChainToChainId } from "../types/chain
 import type { TokenNames, TokenTax } from "../types/tokens";
 import {
   type CommonAssetString,
-  CommonAssetStrings,
+  assetFromString,
   getAssetType,
   getCommonAssetInfo,
   getDecimal,
   isGasAsset,
 } 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";
@@ -25,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 };
 
@@ -114,7 +114,6 @@ export class AssetValue extends BigIntArithmetics {
     return AssetValue.from({ asset, value });
   }
 
-  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: TODO: refactor
   static from<T extends {}>({
     value = 0,
     fromBaseDecimal,
@@ -122,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 assetOrChain = getAssetString(fromAssetOrChain);
 
-    const isFromCommonAssetOrChain =
-      isFromChain ||
-      CommonAssetStrings.includes(assetOrChain as (typeof CommonAssetStrings)[number]);
-
-    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(
@@ -139,6 +133,7 @@ export class AssetValue extends BigIntArithmetics {
         ? (unsafeIdentifier as TokenNames)
         : (unsafeIdentifier.toUpperCase() as TokenNames),
     );
+
     const tokenDecimal = token?.decimal || commonAssetDecimal;
 
     warnOnce(
@@ -154,39 +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 async loadStaticAssets() {
-    try {
-      await import("@swapkit/helpers/tokens").then(({ tokenLists }) => {
-        for (const { tokens } of Object.values(tokenLists)) {
-          for (const { identifier, chain, ...rest } of tokens) {
-            staticTokensMap.set(
-              chain === "SOL" ? identifier : (identifier.toUpperCase() as TokenNames),
-              {
-                identifier,
-                decimal: "decimals" in rest ? rest.decimals : BaseDecimal[chain as Chain],
-              },
-            );
-          }
-        }
-      });
-      return true;
-    } catch (error) {
-      console.error(error);
-      return false;
+  static async loadStaticAssets(listNames?: TokenListName[]) {
+    const lists = await loadTokenLists(listNames);
+
+    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 true;
   }
 }
 
@@ -237,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) {
@@ -246,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({
@@ -262,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}`,
   });
 }
 
@@ -272,53 +266,69 @@ function safeValue(value: NumberPrimitives, decimal: number) {
     : value;
 }
 
-// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: 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 assetSeperator = isTradeAsset ? "~" : "/";
+  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 ((isSynthetic || isTradeAsset) && !(synthChain && synthSymbol)) {
+  if (isSynthOrTrade && !(synthChain && synthSymbol)) {
     throw new SwapKitError({
       errorKey: "helpers_invalid_asset_identifier",
       info: { identifier },
     });
   }
 
-  const adjustedIdentifier =
-    identifier.includes(".") && !isSynthetic && !isTradeAsset
-      ? identifier
-      : `${isMaya ? Chain.Maya : Chain.THORChain}.${synthSymbol}`;
+  const [chain, ...rest] = (
+    identifier.includes(".") && !isSynthOrTrade ? identifier : `${identifierChain}.${synthSymbol}`
+  ).split(".") as [Chain, string];
 
-  const [chain, ...rest] = adjustedIdentifier.split(".") as [Chain, string];
-
-  const symbol = isSynthetic || isTradeAsset ? 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:
-      (isSynthetic || isTradeAsset ? `${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/requestClient.ts

@@ -1,66 +1,63 @@
 import { SKConfig } from "./swapKitConfig";
 
-type Options = Parameters<typeof fetch>[1] & {
-  headers?: Record<string, string>;
-  apiKey?: string;
-  onError?: (error: any) => any;
+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>;
 };
 
-export const defaultRequestHeaders =
-  typeof window !== "undefined"
-    ? ({} as Record<string, string>)
-    : { referrer: "https://sk.thorswap.net", referer: "https://sk.thorswap.net" };
-
-async function fetchWithConfig(
-  { url, method }: { url: string; method: "GET" | "POST" },
-  options: Options = {},
-) {
-  const { searchParams, json, body } = options;
-  const urlInstance = new URL(url);
-  const isJson = json || url.endsWith(".json");
-  const bodyToSend = isJson ? JSON.stringify(json) : body;
-
-  const headers = {
-    ...defaultRequestHeaders,
-    ...options.headers,
-    ...(isJson ? { "Content-Type": "application/json" } : {}),
-  } as Record<string, string>;
-
-  if (searchParams) {
-    urlInstance.search = new URLSearchParams(searchParams).toString();
-  }
-  if (SKConfig.get("apiKeys").swapKit) {
-    headers["x-api-key"] = SKConfig.get("apiKeys").swapKit;
-  }
-
-  try {
-    const response = await fetch(urlInstance.toString(), {
-      ...options,
-      method,
-      body: bodyToSend,
-      headers,
-    });
-    const body = await response.json();
-
-    return 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, method: "GET" }, options),
-  post: async <T>(url: string, options?: Options): Promise<T> =>
-    fetchWithConfig({ url, method: "POST" }, options),
+  get: fetchWithConfig("GET"),
+  post: fetchWithConfig("POST"),
   extend: (extendOptions: Options) => ({
-    get: async <T>(url: string, options?: Options): Promise<T> =>
-      fetchWithConfig({ url, method: "GET" }, { ...extendOptions, ...options }),
-    post: async <T>(url: string, options?: Options): Promise<T> =>
-      fetchWithConfig({ url, method: "POST" }, { ...extendOptions, ...options }),
+    get: fetchWithConfig("GET", extendOptions),
+    post: fetchWithConfig("POST", extendOptions),
     extend: (newOptions: Options) => RequestClient.extend({ ...extendOptions, ...newOptions }),
   }),
 };
+
+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");
+
+    const isJson = json || url.endsWith(".json");
+    const bodyToSend = isJson ? JSON.stringify(json) : body;
+    const urlInstance = new URL(url);
+
+    if (searchParams) {
+      urlInstance.search = new URLSearchParams(searchParams).toString();
+    }
+
+    const headers = {
+      ...headersOptions,
+      ...(isJson ? { "Content-Type": "application/json" } : {}),
+      ...(swapKit ? { "x-api-key": swapKit } : {}),
+    };
+
+    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);
+    }
+  };
+}

package/src/modules/swapKitConfig.ts

@@ -1,5 +1,5 @@
 import { createStore } from "zustand/vanilla";
-import { type Chain, EXPLORER_URLS, NODE_URLS, RPC_URLS } from "../types";
+import { Chain, EXPLORER_URLS, NODE_URLS, RPC_URLS, WalletOption } from "../types";
 
 export type SKConfigIntegrations = {
   chainflip?: { useSDKBroker?: boolean; brokerUrl: string };
@@ -28,14 +28,14 @@ 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: "",
-    covalent: "",
-    ethplorer: "freekey",
     kado: "",
     keepKey: "",
     swapKit: "",
@@ -47,7 +47,6 @@ const initialState = {
     devApiUrl: "https://dev-api.swapkit.dev",
     isDev: false,
     isStagenet: false,
-    referer: "https://swapkit.dev",
   },
 
   integrations: {
@@ -67,11 +66,13 @@ 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 & {
@@ -103,9 +104,11 @@ const swapKitState = createStore<SwapKitConfigStore>((set) => ({
       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 },
-      integrations: { ...s.integrations, ...config.integrations },
+      chains: s.chains.concat(config.chains || []),
+      wallets: s.wallets.concat(config.wallets || []),
     })),
 }));