@swapkit/helpers 2.5.0 → 3.0.0-beta.0

package/src/contracts/routers/woofi.ts

@@ -0,0 +1,171 @@
+export const woofiRouter = [
+  {
+    inputs: [
+      { internalType: "address", name: "_weth", type: "address" },
+      { internalType: "address", name: "_pool", type: "address" },
+    ],
+    stateMutability: "nonpayable",
+    type: "constructor",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "address", name: "previousOwner", type: "address" },
+      { indexed: true, internalType: "address", name: "newOwner", type: "address" },
+    ],
+    name: "OwnershipTransferred",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [{ indexed: false, internalType: "address", name: "newPool", type: "address" }],
+    name: "WooPoolChanged",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "enum IWooRouterV2.SwapType",
+        name: "swapType",
+        type: "uint8",
+      },
+      { indexed: true, internalType: "address", name: "fromToken", type: "address" },
+      { indexed: true, internalType: "address", name: "toToken", type: "address" },
+      { indexed: false, internalType: "uint256", name: "fromAmount", type: "uint256" },
+      { indexed: false, internalType: "uint256", name: "toAmount", type: "uint256" },
+      { indexed: false, internalType: "address", name: "from", type: "address" },
+      { indexed: true, internalType: "address", name: "to", type: "address" },
+      { indexed: false, internalType: "address", name: "rebateTo", type: "address" },
+    ],
+    name: "WooRouterSwap",
+    type: "event",
+  },
+  {
+    inputs: [],
+    name: "WETH",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "approveTarget", type: "address" },
+      { internalType: "address", name: "swapTarget", type: "address" },
+      { internalType: "address", name: "fromToken", type: "address" },
+      { internalType: "address", name: "toToken", type: "address" },
+      { internalType: "uint256", name: "fromAmount", type: "uint256" },
+      { internalType: "uint256", name: "minToAmount", type: "uint256" },
+      { internalType: "address payable", name: "to", type: "address" },
+      { internalType: "bytes", name: "data", type: "bytes" },
+    ],
+    name: "externalSwap",
+    outputs: [{ internalType: "uint256", name: "realToAmount", type: "uint256" }],
+    stateMutability: "payable",
+    type: "function",
+  },
+  {
+    inputs: [{ internalType: "address", name: "stuckToken", type: "address" }],
+    name: "inCaseTokenGotStuck",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [{ internalType: "address", name: "", type: "address" }],
+    name: "isWhitelisted",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "owner",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "fromToken", type: "address" },
+      { internalType: "address", name: "toToken", type: "address" },
+      { internalType: "uint256", name: "fromAmount", type: "uint256" },
+    ],
+    name: "querySwap",
+    outputs: [{ internalType: "uint256", name: "toAmount", type: "uint256" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "quoteToken",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "renounceOwnership",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [{ internalType: "address", name: "newPool", type: "address" }],
+    name: "setPool",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "target", type: "address" },
+      { internalType: "bool", name: "whitelisted", type: "bool" },
+    ],
+    name: "setWhitelisted",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "fromToken", type: "address" },
+      { internalType: "address", name: "toToken", type: "address" },
+      { internalType: "uint256", name: "fromAmount", type: "uint256" },
+      { internalType: "uint256", name: "minToAmount", type: "uint256" },
+      { internalType: "address payable", name: "to", type: "address" },
+      { internalType: "address", name: "rebateTo", type: "address" },
+    ],
+    name: "swap",
+    outputs: [{ internalType: "uint256", name: "realToAmount", type: "uint256" }],
+    stateMutability: "payable",
+    type: "function",
+  },
+  {
+    inputs: [{ internalType: "address", name: "newOwner", type: "address" }],
+    name: "transferOwnership",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "fromToken", type: "address" },
+      { internalType: "address", name: "toToken", type: "address" },
+      { internalType: "uint256", name: "fromAmount", type: "uint256" },
+    ],
+    name: "tryQuerySwap",
+    outputs: [{ internalType: "uint256", name: "toAmount", type: "uint256" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "wooPool",
+    outputs: [{ internalType: "contract IWooPPV2", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  { stateMutability: "payable", type: "receive" },
+];

package/src/index.ts

@@ -1,17 +1,14 @@
-export * from "@swapkit/contracts";
-export * from "./types/index";
-
 /**
  * Helpers
  */
-export * from "./helpers/asset";
-export * from "./helpers/derivationPath";
-export * from "./helpers/liquidity";
-export * from "./helpers/memo";
-export * from "./helpers/others";
-export * from "./helpers/validators";
-export * from "./helpers/web3wallets";
-
+export * from "./utils/asset";
+export * from "./utils/derivationPath";
+export * from "./utils/liquidity";
+export * from "./utils/memo";
+export * from "./utils/others";
+export * from "./utils/plugin";
+export * from "./utils/validators";
+export * from "./utils/wallets";
 /**
  * Modules
  */
@@ -20,4 +17,6 @@ export * from "./modules/bigIntArithmetics";
 export * from "./modules/requestClient";
 export * from "./modules/swapKitError";
 export * from "./modules/swapKitNumber";
-export * from "./modules/walletUtils";
+export * from "./modules/swapKitConfig";
+
+export * from "./types/index";

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

@@ -758,12 +758,10 @@ describe("AssetValue", () => {
       const xrdAsset = AssetValue.from({ chain: Chain.Radix });
       expect(xrdAsset).toEqual(
         expect.objectContaining({
-          address: undefined,
           chain: Chain.Radix,
           decimal: BaseDecimal.XRD,
           isGasAsset: true,
           isSynthetic: false,
-          symbol: "XRD",
           ticker: "XRD",
           type: "Native",
         }),

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

@@ -0,0 +1,37 @@
+import { describe, expect, test } from "bun:test";
+import { Chain } from "../../types";
+import { SKConfig } from "../swapKitConfig";
+
+describe("swapKitConfig", () => {
+  test("properly sets api keys", () => {
+    const initialState = SKConfig.get("apiKeys").swapKit;
+    expect(initialState).toBe("");
+
+    SKConfig.setApiKey("swapKit", "123");
+
+    const changedState = SKConfig.get("apiKeys").swapKit;
+    expect(changedState).toBe("123");
+  });
+
+  test("do not drop if other keys are changed", () => {
+    SKConfig.setApiKey("swapKit", "123");
+    expect(SKConfig.get("apiKeys").swapKit).toBe("123");
+
+    SKConfig.setApiKey("ethplorer", "123");
+    expect(SKConfig.get("apiKeys")).toMatchObject({
+      swapKit: "123",
+      ethplorer: "123",
+    });
+
+    SKConfig.setExplorerUrl(Chain.Ethereum, "https://lul.xyz");
+    expect(SKConfig.getState()).toMatchObject({
+      apiKeys: {
+        swapKit: "123",
+        ethplorer: "123",
+      },
+      explorerUrls: {
+        [Chain.Ethereum]: "https://lul.xyz",
+      },
+    });
+  });
+});

package/src/modules/assetValue.ts

@@ -1,3 +1,5 @@
+import { BaseDecimal, Chain, type ChainId, ChainToChainId } from "../types/chains";
+import type { TokenNames, TokenTax } from "../types/tokens";
 import {
   type CommonAssetString,
   CommonAssetStrings,
@@ -5,11 +7,9 @@ import {
   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 { validateIdentifier } from "../utils/validators";
 
 import type { NumberPrimitives } from "./bigIntArithmetics";
 import { BigIntArithmetics, formatBigIntToSafeValue } from "./bigIntArithmetics";
@@ -114,6 +114,7 @@ export class AssetValue extends BigIntArithmetics {
     return AssetValue.from({ asset, value });
   }
 
+  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: TODO: refactor
   static from<T extends {}>({
     value = 0,
     fromBaseDecimal,
@@ -142,7 +143,7 @@ export class AssetValue extends BigIntArithmetics {
 
     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.`,
@@ -166,93 +167,26 @@ or by passing asyncTokenLookup: true to the from() function, which will make it
     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() {
+    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],
+              },
+            );
+          }
         }
-      },
-    );
-  }
-
-  /**
-   * @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 });
+      });
+      return true;
+    } catch (error) {
+      console.error(error);
+      return false;
     }
-    return AssetValue.from({ asset: assetOrChain, value });
   }
 }
 
@@ -338,7 +272,7 @@ function safeValue(value: NumberPrimitives, decimal: number) {
     : value;
 }
 
-// TODO refactor & split into smaller functions
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: TODO: refactor & split into smaller functions
 function getAssetInfo(identifier: string) {
   const isSynthetic = identifier.slice(0, 14).includes("/");
   const isTradeAsset = identifier.slice(0, 14).includes("~");

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,66 @@
+import { SKConfig } from "./swapKitConfig";
+
 type Options = Parameters<typeof fetch>[1] & {
   headers?: Record<string, string>;
   apiKey?: string;
-  method?: "GET" | "POST";
   onError?: (error: any) => any;
   responseHandler?: (response: any) => any;
   searchParams?: Record<string, string>;
   json?: unknown;
 };
 
-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;
+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,
-    ...config.headers,
     ...options.headers,
-    ...(json ? { "Content-Type": "application/json" } : {}),
+    ...(isJson ? { "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();
   }
-
-  if (apiKey) headers["x-api-key"] = apiKey;
+  if (SKConfig.get("apiKeys").swapKit) {
+    headers["x-api-key"] = SKConfig.get("apiKeys").swapKit;
+  }
 
   try {
     const response = await fetch(urlInstance.toString(), {
-      ...config,
       ...options,
+      method,
       body: bodyToSend,
       headers,
     });
     const body = await response.json();
 
-    if (options.responseHandler) return options.responseHandler(body);
-
-    return body;
+    return options.responseHandler?.(body) || body;
   } catch (error) {
-    if (options.onError) return options.onError(error);
-
-    console.error(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" }),
+    fetchWithConfig({ url, method: "GET" }, options),
   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 }),
-    };
-  },
+    fetchWithConfig({ url, method: "POST" }, options),
+  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 }),
+    extend: (newOptions: Options) => RequestClient.extend({ ...extendOptions, ...newOptions }),
+  }),
 };