@swapkit/helpers 3.0.0-beta.2 → 3.0.0-beta.20

package/src/modules/assetValue.ts

@@ -1,4 +1,14 @@
-import { BaseDecimal, Chain, type ChainId, ChainToChainId } from "../types/chains";
+import { getAddress } from "ethers";
+import { match } from "ts-pattern";
+
+import {
+  BaseDecimal,
+  Chain,
+  type ChainId,
+  ChainToChainId,
+  type EVMChain,
+  EVMChains,
+} from "../types/chains";
 import type { TokenNames, TokenTax } from "../types/tokens";
 import {
   type CommonAssetString,
@@ -17,8 +27,10 @@ import { BigIntArithmetics, formatBigIntToSafeValue } from "./bigIntArithmetics"
 import { SwapKitError } from "./swapKitError";
 import type { SwapKitValueType } from "./swapKitNumber";
 
+const CASE_SENSITIVE_CHAINS = [Chain.Solana, Chain.Tron];
+
 const staticTokensMap = new Map<
-  TokenNames,
+  TokenNames | string,
   { tax?: TokenTax; decimal: number; identifier: string }
 >();
 
@@ -169,7 +181,9 @@ or by passing asyncTokenLookup: true to the from() function, which will make it
 
     for (const { tokens } of Object.values(lists)) {
       for (const { identifier, chain, ...rest } of tokens) {
-        const tokenKey = (chain === "SOL" ? identifier : identifier.toUpperCase()) as TokenNames;
+        const tokenKey = (
+          chain === Chain.Solana ? identifier : identifier.toUpperCase()
+        ) as TokenNames;
         const tokenDecimal = "decimals" in rest ? rest.decimals : BaseDecimal[chain as Chain];
 
         staticTokensMap.set(tokenKey, { identifier, decimal: tokenDecimal });
@@ -178,38 +192,40 @@ or by passing asyncTokenLookup: true to the from() function, which will make it
 
     return true;
   }
+
+  static setStaticAssets(
+    tokenMap: Map<
+      string,
+      { tax?: TokenTax; identifier: string; chain: Chain } & (
+        | { decimal: number }
+        | { decimals: number }
+      )
+    >,
+  ) {
+    staticTokensMap.clear();
+    for (const [key, value] of tokenMap.entries()) {
+      const tokenKey = (
+        value.chain === Chain.Solana ? value.identifier : value.identifier.toUpperCase()
+      ) as TokenNames;
+      const tokenDecimal = "decimals" in value ? value.decimals : value.decimal;
+      staticTokensMap.set(key, { ...value, decimal: tokenDecimal, identifier: tokenKey });
+    }
+    return true;
+  }
 }
 
 export function getMinAmountByChain(chain: Chain) {
   const asset = AssetValue.from({ chain });
 
-  switch (chain) {
-    case Chain.Bitcoin:
-    case Chain.Litecoin:
-    case Chain.BitcoinCash:
-    case Chain.Dash:
-      return asset.set(0.00010001);
-
-    case Chain.Dogecoin:
-      return asset.set(1.00000001);
-
-    case Chain.Avalanche:
-    case Chain.Ethereum:
-    case Chain.Arbitrum:
-    case Chain.BinanceSmartChain:
-      return asset.set(0.00000001);
-
-    case Chain.THORChain:
-    case Chain.Maya:
-      return asset.set(0);
-
-    case Chain.Cosmos:
-    case Chain.Kujira:
-      return asset.set(0.000001);
-
-    default:
-      return asset.set(0.00000001);
-  }
+  return match(chain)
+    .with(Chain.Bitcoin, Chain.Litecoin, Chain.BitcoinCash, Chain.Dash, () => asset.set(0.00010001))
+    .with(Chain.Dogecoin, () => asset.set(1.00000001))
+    .with(Chain.Avalanche, Chain.Ethereum, Chain.Arbitrum, Chain.BinanceSmartChain, () =>
+      asset.set(0.00000001),
+    )
+    .with(Chain.THORChain, Chain.Maya, () => asset.set(0))
+    .with(Chain.Cosmos, Chain.Kujira, () => asset.set(0.000001))
+    .otherwise(() => asset.set(0.00000001));
 }
 
 async function createAssetValue(identifier: string, value: NumberPrimitives = 0) {
@@ -266,7 +282,29 @@ function safeValue(value: NumberPrimitives, decimal: number) {
     : value;
 }
 
+function validateAssetChain(assetOrChain: AssetIdentifier) {
+  const chain = match(assetOrChain)
+    .when(
+      (x): x is { chain: Chain } => "chain" in x && x.chain !== undefined,
+      ({ chain }) => chain,
+    )
+    .otherwise((x) => {
+      const assetInfo = assetFromString((x as { asset: string }).asset);
+      return assetInfo.synth ? Chain.THORChain : assetInfo.chain;
+    });
+
+  // TODO: move to SKConfig chains once we support it throughout sdk
+  if (!Object.values(Chain).includes(chain.toUpperCase() as Chain)) {
+    throw new SwapKitError({
+      errorKey: "helpers_invalid_asset_identifier",
+      info: { message: "Please use the AssetValue constructor for unsupported chains" },
+    });
+  }
+}
+
 function getAssetString(assetOrChain: AssetIdentifier) {
+  validateAssetChain(assetOrChain);
+
   if ("chain" in assetOrChain) return assetOrChain.chain;
 
   const { chain, symbol } = assetFromString(assetOrChain.asset);
@@ -304,12 +342,23 @@ function getAssetInfo(identifier: string) {
   const assetSymbol = isSynthOrTrade ? synthSymbol : rest.join(".");
 
   const { address, ticker } = getAssetBaseInfo({ symbol: assetSymbol, chain });
+
+  let formattedAddress: string | undefined;
+  try {
+    formattedAddress =
+      address && EVMChains.includes(chain as EVMChain) && getAddress(address)
+        ? getAddress(address)
+        : address;
+  } catch (_error) {
+    formattedAddress = address;
+  }
+
   const symbol =
     (isSynthOrTrade ? `${synthChain}${assetSeparator}` : "") +
-    (address ? `${ticker}-${address ?? ""}` : assetSymbol);
+    (formattedAddress ? `${ticker}-${formattedAddress ?? ""}` : assetSymbol);
 
   return {
-    address,
+    address: formattedAddress,
     chain,
     isSynthOrTrade,
     isSynthetic,
@@ -325,7 +374,9 @@ function getAssetBaseInfo({ symbol, chain }: { symbol: string; chain: Chain }) {
   const unformattedAddress =
     splitSymbol.length === 1 ? undefined : splitSymbol[splitSymbol.length - 1];
 
-  const address = chain === Chain.Solana ? unformattedAddress : unformattedAddress?.toLowerCase();
+  const address = CASE_SENSITIVE_CHAINS.includes(chain)
+    ? unformattedAddress
+    : unformattedAddress?.toLowerCase();
   const ticker = (
     splitSymbol.length === 1 ? splitSymbol[0] : splitSymbol.slice(0, -1).join("-")
   ) as string;

package/src/modules/bigIntArithmetics.ts

@@ -54,6 +54,17 @@ export function formatBigIntToSafeValue({
   );
 }
 
+function divideBigIntWithRounding(n: bigint, d: bigint) {
+  if (d === 0n) {
+    throw new Error("Cannot divide by zero");
+  }
+  const half = d / 2n;
+  if ((n >= 0n && d >= 0n) || (n < 0n && d < 0n)) {
+    return (n + half) / d;
+  }
+  return (n - half) / d;
+}
+
 export class BigIntArithmetics {
   decimalMultiplier: bigint = 10n ** 8n;
   bigIntValue = 0n;
@@ -153,7 +164,7 @@ export class BigIntArithmetics {
   getBaseValue<T extends AllowedNumberTypes>(type: T, decimal?: number): NumberPrimitivesType[T] {
     const divisor =
       this.decimalMultiplier / toMultiplier(decimal || this.decimal || BaseDecimal.THOR);
-    const baseValue = this.bigIntValue / divisor;
+    const baseValue = divideBigIntWithRounding(this.bigIntValue, divisor);
 
     switch (type) {
       case "number":

package/src/modules/feeMultiplier.ts

@@ -0,0 +1,87 @@
+import { FeeOption } from "../types";
+import { SKConfig } from "./swapKitConfig";
+
+export interface FeeMultiplierConfig {
+  [FeeOption.Average]: number;
+  [FeeOption.Fast]: number;
+  [FeeOption.Fastest]: number;
+}
+
+const DEFAULT_FEE_MULTIPLIERS: FeeMultiplierConfig = {
+  [FeeOption.Average]: 1.0,
+  [FeeOption.Fast]: 1.5,
+  [FeeOption.Fastest]: 2.0,
+};
+
+/**
+ * Get fee multiplier for the given fee option.
+ * Checks SKConfig for custom multipliers first, then falls back to defaults.
+ *
+ * @param feeOption - The fee option (Average, Fast, Fastest)
+ * @returns The fee multiplier as a number
+ */
+export function getFeeMultiplier(feeOption: FeeOption = FeeOption.Average): number {
+  const customMultipliers = SKConfig.get("feeMultipliers");
+
+  if (customMultipliers && customMultipliers[feeOption] !== undefined) {
+    return customMultipliers[feeOption];
+  }
+
+  return DEFAULT_FEE_MULTIPLIERS[feeOption];
+}
+
+/**
+ * Get fee multiplier as BigInt for EVM calculations.
+ * Returns numerator and denominator for precise BigInt arithmetic.
+ *
+ * @param feeOption - The fee option (Average, Fast, Fastest)
+ * @returns Object with numerator and denominator for BigInt calculations
+ */
+export function getFeeMultiplierAsBigInt(feeOption: FeeOption = FeeOption.Average): {
+  numerator: bigint;
+  denominator: bigint;
+} {
+  const multiplier = getFeeMultiplier(feeOption);
+
+  // Convert decimal multiplier to fraction for precise BigInt arithmetic
+  // e.g., 1.5 -> 15/10, 2.0 -> 20/10
+  const denominator = 10n;
+  const numerator = BigInt(Math.round(multiplier * 10));
+
+  return { numerator, denominator };
+}
+
+/**
+ * Apply fee multiplier to a BigInt value (for EVM chains).
+ *
+ * @param value - The base fee value as BigInt
+ * @param feeOption - The fee option (Average, Fast, Fastest)
+ * @returns The multiplied fee value as BigInt
+ */
+export function applyFeeMultiplierToBigInt(
+  value: bigint,
+  feeOption: FeeOption = FeeOption.Average,
+): bigint {
+  const { numerator, denominator } = getFeeMultiplierAsBigInt(feeOption);
+  return (value * numerator) / denominator;
+}
+
+/**
+ * Apply fee multiplier to a number value (for non-EVM chains).
+ *
+ * @param value - The base fee value as number
+ * @param feeOption - The fee option (Average, Fast, Fastest)
+ * @param floor - Whether to floor the result (default: false)
+ * @returns The multiplied fee value as number
+ */
+export function applyFeeMultiplier(
+  value: number,
+  feeOption: FeeOption = FeeOption.Average,
+  floor = false,
+): number {
+  const multiplier = getFeeMultiplier(feeOption);
+  const result = value * multiplier;
+  return floor ? Math.floor(result) : result;
+}
+
+export { DEFAULT_FEE_MULTIPLIERS };

package/src/modules/requestClient.ts

@@ -1,14 +1,15 @@
-import { SKConfig } from "./swapKitConfig";
+import { SwapKitError } from "./swapKitError";
 
 type Options = RequestInit & {
   /**
-   * @deprecated Use onSuccess instead
+   * @deprecated Use onSuccess instead - will be removed in next major @MarkedV4
    */
   responseHandler?: (response: any) => any;
   json?: unknown;
   onError?: (error: any) => any;
   onSuccess?: (response: any) => any;
   searchParams?: Record<string, string>;
+  getDynamicHeader?: () => Record<string, string> | {};
 };
 
 export const RequestClient = {
@@ -24,40 +25,50 @@ export const RequestClient = {
 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 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,
-      });
+      const requestUrl = buildUrl(url, searchParams);
+      const headers = buildHeaders(isJson, { ...headersOptions, ...options.getDynamicHeader?.() });
+
+      const response = await fetch(requestUrl, { ...options, method, body: bodyToSend, headers });
 
       if (!response.ok) {
         const message = await response.text();
-        throw new Error(`${response.statusText}(${response.status}): ${message}`);
+        throw new SwapKitError("helpers_invalid_response", {
+          status: response.status,
+          statusText: response.statusText,
+          message,
+        });
       }
 
       const body = await response.json();
 
       return options.onSuccess?.(body) || options.responseHandler?.(body) || body;
     } catch (error) {
-      return options.onError?.(error) || console.error(error);
+      if (options.onError) {
+        return options.onError(error);
+      }
+      throw error;
     }
   };
 }
+
+function buildHeaders(isJson: boolean, headersOptions?: HeadersInit) {
+  return {
+    ...headersOptions,
+    ...(isJson ? { "Content-Type": "application/json" } : {}),
+  };
+}
+
+function buildUrl(url: string, searchParams?: Record<string, string>) {
+  const urlInstance = new URL(url);
+
+  if (searchParams) {
+    urlInstance.search = new URLSearchParams(searchParams).toString();
+  }
+
+  return urlInstance.toString();
+}

package/src/modules/swapKitConfig.ts

@@ -1,5 +1,6 @@
 import { createStore } from "zustand/vanilla";
 import { Chain, EXPLORER_URLS, NODE_URLS, RPC_URLS, WalletOption } from "../types";
+import type { FeeMultiplierConfig } from "./feeMultiplier";
 
 export type SKConfigIntegrations = {
   chainflip?: { useSDKBroker?: boolean; brokerUrl: string };
@@ -36,7 +37,6 @@ const initialState = {
 
   apiKeys: {
     blockchair: "",
-    kado: "",
     keepKey: "",
     swapKit: "",
     walletConnectProjectId: "",
@@ -61,6 +61,8 @@ const initialState = {
       },
     },
   } as SKConfigIntegrations,
+
+  feeMultipliers: undefined as FeeMultiplierConfig | undefined,
 };
 type SKState = typeof initialState;
 
@@ -73,6 +75,7 @@ export type SKConfigState = {
   nodeUrls?: Partial<SKState["nodeUrls"]>;
   rpcUrls?: Partial<SKState["rpcUrls"]>;
   wallets?: SKState["wallets"];
+  feeMultipliers?: FeeMultiplierConfig;
 };
 
 type SwapKitConfigStore = SKState & {
@@ -86,6 +89,7 @@ type SwapKitConfigStore = SKState & {
     integration: keyof SKState["integrations"],
     config: SKConfigIntegrations[keyof SKConfigIntegrations],
   ) => void;
+  setFeeMultipliers: (multipliers: FeeMultiplierConfig) => void;
 };
 
 const swapKitState = createStore<SwapKitConfigStore>((set) => ({
@@ -99,6 +103,7 @@ const swapKitState = createStore<SwapKitConfigStore>((set) => ({
   setRpcUrl: (chain, url) => set((s) => ({ rpcUrls: { ...s.rpcUrls, [chain]: url } })),
   setIntegrationConfig: (integration, config) =>
     set((s) => ({ integrations: { ...s.integrations, [integration]: config } })),
+  setFeeMultipliers: (multipliers) => set(() => ({ feeMultipliers: multipliers })),
   setConfig: (config) =>
     set((s) => ({
       apiKeys: { ...s.apiKeys, ...config.apiKeys },
@@ -107,6 +112,7 @@ const swapKitState = createStore<SwapKitConfigStore>((set) => ({
       integrations: { ...s.integrations, ...config.integrations },
       nodeUrls: { ...s.nodeUrls, ...config.nodeUrls },
       rpcUrls: { ...s.rpcUrls, ...config.rpcUrls },
+      feeMultipliers: config.feeMultipliers || s.feeMultipliers,
       chains: s.chains.concat(config.chains || []),
       wallets: s.wallets.concat(config.wallets || []),
     })),
@@ -131,4 +137,6 @@ export const SKConfig = {
     integration: T,
     config: SKConfigIntegrations[T],
   ) => swapKitState.getState().setIntegrationConfig(integration, config),
+  setFeeMultipliers: (multipliers: FeeMultiplierConfig) =>
+    swapKitState.getState().setFeeMultipliers(multipliers),
 };