@swapkit/helpers 1.0.0-rc.99 → 1.0.0

package/src/modules/assetValue.ts

@@ -1,18 +1,40 @@
-import type { CommonAssetString } from "../helpers/asset.ts";
-import { getAssetType, getCommonAssetInfo, getDecimal, isGasAsset } from "../helpers/asset.ts";
+import {
+  type CommonAssetString,
+  CommonAssetStrings,
+  getAssetType,
+  getCommonAssetInfo,
+  getDecimal,
+  isGasAsset,
+} from "../helpers/asset.ts";
 import { validateIdentifier } from "../helpers/validators.ts";
 import { BaseDecimal, Chain, type ChainId, ChainToChainId } from "../types/chains.ts";
 import type { TokenNames, TokenTax } from "../types/tokens.ts";
 
 import type { NumberPrimitives } from "./bigIntArithmetics.ts";
 import { BigIntArithmetics, formatBigIntToSafeValue } from "./bigIntArithmetics.ts";
-import { SwapKitNumber, type SwapKitValueType } from "./swapKitNumber.ts";
+import { SwapKitError } from "./swapKitError.ts";
+import type { SwapKitValueType } from "./swapKitNumber.ts";
 
 const staticTokensMap = new Map<
   TokenNames,
   { tax?: TokenTax; decimal: number; identifier: string }
 >();
 
+type ConditionalAssetValueReturn<T extends { asyncTokenLookup?: boolean }> =
+  T["asyncTokenLookup"] extends true ? Promise<AssetValue> : AssetValue;
+
+type AssetIdentifier =
+  | { asset: CommonAssetString }
+  | { asset: TokenNames }
+  | { asset: string }
+  | { chain: Chain };
+
+type AssetValueFromParams = AssetIdentifier & {
+  value?: NumberPrimitives | SwapKitValueType;
+  fromBaseDecimal?: number;
+  asyncTokenLookup?: boolean;
+};
+
 export class AssetValue extends BigIntArithmetics {
   address?: string;
   chain: Chain;
@@ -58,122 +80,71 @@ export class AssetValue extends BigIntArithmetics {
     return this.isSynthetic ? `${this.chain}.${this.symbol.replace("/", ".")}` : this.toString();
   }
 
-  eq({ chain, symbol }: { chain: Chain; symbol: string }) {
+  eqAsset({ chain, symbol }: { chain: Chain; symbol: string }) {
     return this.chain === chain && this.symbol === symbol;
   }
 
+  eq(assetValue: AssetValue) {
+    return this.eqAsset(assetValue) && this.eqValue(assetValue);
+  }
+
   // THOR.RUNE
   // THOR.ETH.ETH
   // ETH.THOR-0x1234567890
   static fromUrl(urlAsset: string, value: NumberPrimitives = 0) {
     const [chain, ticker, symbol] = urlAsset.split(".");
-    if (!(chain && ticker)) throw new Error("Invalid asset url");
+    if (!(chain && ticker)) {
+      throw new SwapKitError({
+        errorKey: "helpers_invalid_asset_url",
+        info: { urlAsset },
+      });
+    }
 
-    const assetString =
-      chain === Chain.THORChain && symbol ? `${chain}.${ticker}/${symbol}` : urlAsset;
+    const asset = chain === Chain.THORChain && symbol ? `${chain}.${ticker}/${symbol}` : urlAsset;
 
-    return createAssetValue(assetString, value);
+    return AssetValue.from({ asset, value });
   }
 
-  static fromString(assetString: string, value: NumberPrimitives = 0) {
-    return createAssetValue(assetString, value);
-  }
-  static fromIdentifier(
-    assetString:
-      | `${Chain}.${string}`
-      | `${Chain}/${string}`
-      | `${Chain}.${string}-${string}`
-      | TokenNames,
-    value: NumberPrimitives = 0,
-  ) {
-    return createAssetValue(assetString, value);
-  }
+  static from<T extends {}>({
+    value = 0,
+    fromBaseDecimal,
+    asyncTokenLookup,
+    ...fromAssetOrChain
+  }: T & AssetValueFromParams): ConditionalAssetValueReturn<T> {
+    const parsedValue = value instanceof BigIntArithmetics ? value.getValue("string") : value;
 
-  static fromStringSync(assetString: string, value: NumberPrimitives = 0) {
-    const { chain, isSynthetic } = getAssetInfo(assetString);
-    const tokenInfo = staticTokensMap.get(assetString.toUpperCase() as TokenNames);
-
-    if (isSynthetic) return createSyntheticAssetValue(assetString, value);
-    // TODO: write logger that will only run in dev mode with some flag
-    // if (!tokenInfo) {
-    //   console.error(
-    //     `Asset ${assetString} is not loaded. Use AssetValue.loadStaticAssets() to load it`,
-    //   );
-    // }
-
-    const { tax, decimal, identifier } = tokenInfo || {
-      decimal: BaseDecimal[chain],
-      identifier: assetString,
-    };
+    const isFromChain = "chain" in fromAssetOrChain;
 
-    return new AssetValue({
-      tax,
-      value: safeValue(value, decimal),
-      identifier: isSynthetic ? assetString : identifier,
-      decimal: isSynthetic ? 8 : decimal,
-    });
-  }
+    const assetOrChain = isFromChain ? fromAssetOrChain.chain : fromAssetOrChain.asset;
 
-  static async fromStringWithBase(
-    assetString: string,
-    value: NumberPrimitives = 0,
-    baseDecimal: number = BaseDecimal.THOR,
-  ) {
-    const shiftedAmount = BigIntArithmetics.shiftDecimals({
-      value: SwapKitNumber.fromBigInt(BigInt(value)),
-      from: 0,
-      to: baseDecimal,
-    }).getBaseValue("string");
-    const assetValue = await AssetValue.fromString(assetString, value);
-
-    return assetValue.set(shiftedAmount);
-  }
+    const isFromCommonAssetOrChain =
+      isFromChain ||
+      CommonAssetStrings.includes(assetOrChain as (typeof CommonAssetStrings)[number]);
 
-  static fromStringWithBaseSync(
-    assetString: string,
-    value: NumberPrimitives = 0,
-    baseDecimal: number = BaseDecimal.THOR,
-  ) {
-    const { chain, isSynthetic } = getAssetInfo(assetString);
-    const tokenInfo = staticTokensMap.get(assetString.toUpperCase() as TokenNames);
+    const { identifier: unsafeIdentifier, decimal: commonAssetDecimal } = isFromCommonAssetOrChain
+      ? getCommonAssetInfo(assetOrChain as CommonAssetString)
+      : { identifier: assetOrChain, decimal: undefined };
 
-    if (isSynthetic) return createSyntheticAssetValue(assetString, value);
+    const { chain, isSynthetic } = getAssetInfo(unsafeIdentifier);
 
-    const { tax, decimal, identifier } = tokenInfo || {
-      decimal: BaseDecimal[chain],
-      identifier: assetString,
+    const { tax, decimal, identifier } = staticTokensMap.get(
+      unsafeIdentifier.toUpperCase() as TokenNames,
+    ) || {
+      decimal: commonAssetDecimal || BaseDecimal[chain],
+      identifier: unsafeIdentifier,
     };
 
-    return new AssetValue({
-      tax,
-      value: safeValue(BigInt(value), baseDecimal),
-      identifier,
-      decimal,
-    });
-  }
+    const adjustedValue = fromBaseDecimal
+      ? safeValue(BigInt(parsedValue), fromBaseDecimal)
+      : safeValue(parsedValue, decimal);
 
-  static fromIdentifierSync(assetString: TokenNames, value: NumberPrimitives = 0) {
-    const { chain, isSynthetic } = getAssetInfo(assetString);
-    const tokenInfo = staticTokensMap.get(assetString);
-
-    if (isSynthetic) return createSyntheticAssetValue(assetString, value);
-    // TODO: write logger that will only run in dev mode with some flag
-    // if (!tokenInfo) {
-    //   console.error(
-    //     `Asset ${assetString} is not loaded. - Loading with base Chain. Use AssetValue.loadStaticAssets() to load it`,
-    //   );
-    // }
-
-    const { tax, decimal, identifier } = tokenInfo || {
-      decimal: BaseDecimal[chain],
-      identifier: assetString,
-    };
-    return new AssetValue({ tax, decimal, identifier, value: safeValue(value, decimal) });
-  }
+    const assetValue = asyncTokenLookup
+      ? createAssetValue(identifier, fromBaseDecimal ? adjustedValue : parsedValue)
+      : isSynthetic
+        ? createSyntheticAssetValue(identifier, parsedValue)
+        : new AssetValue({ tax, decimal, identifier, value: adjustedValue });
 
-  static fromChainOrSignature(assetString: CommonAssetString, value: NumberPrimitives = 0) {
-    const { decimal, identifier } = getCommonAssetInfo(assetString);
-    return new AssetValue({ value: safeValue(value, decimal), decimal, identifier });
+    return assetValue as ConditionalAssetValueReturn<T>;
   }
 
   static loadStaticAssets() {
@@ -204,15 +175,73 @@ export class AssetValue extends BigIntArithmetics {
       },
     );
   }
+
+  /**
+   * @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 (assetOrChain in Chain) {
+      return AssetValue.from({ chain: assetOrChain as Chain, value });
+    }
+    return AssetValue.from({ asset: assetOrChain, value });
+  }
 }
 
 export function getMinAmountByChain(chain: Chain) {
-  const asset = AssetValue.fromChainOrSignature(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:
@@ -220,6 +249,8 @@ export function getMinAmountByChain(chain: Chain) {
 
     case Chain.Avalanche:
     case Chain.Ethereum:
+    case Chain.Arbitrum:
+    case Chain.BinanceSmartChain:
       return asset.set(0.00000001);
 
     case Chain.THORChain:
@@ -227,6 +258,7 @@ export function getMinAmountByChain(chain: Chain) {
       return asset.set(0);
 
     case Chain.Cosmos:
+    case Chain.Kujira:
       return asset.set(0.000001);
 
     default:
@@ -252,7 +284,12 @@ function createSyntheticAssetValue(identifier: string, value: NumberPrimitives =
       ? identifier.split(".").slice(1).join().split("/")
       : identifier.split("/");
 
-  if (!(synthChain && symbol)) throw new Error("Invalid asset identifier");
+  if (!(synthChain && symbol)) {
+    throw new SwapKitError({
+      errorKey: "helpers_invalid_asset_identifier",
+      info: { identifier },
+    });
+  }
 
   return new AssetValue({
     decimal: 8,
@@ -279,7 +316,12 @@ function getAssetInfo(identifier: string) {
       ? identifier.split(".").slice(1).join().split("/")
       : identifier.split("/");
 
-  if (isSynthetic && !(synthChain && synthSymbol)) throw new Error("Invalid asset identifier");
+  if (isSynthetic && !(synthChain && synthSymbol)) {
+    throw new SwapKitError({
+      errorKey: "helpers_invalid_asset_identifier",
+      info: { identifier },
+    });
+  }
 
   const adjustedIdentifier =
     identifier.includes(".") && !isSynthetic
@@ -300,9 +342,9 @@ function getAssetInfo(identifier: string) {
     chain,
     isGasAsset: isGasAsset({ chain, symbol }),
     isSynthetic,
+    ticker,
     symbol:
       (isSynthetic ? `${synthChain}/` : "") +
       (address ? `${ticker}-${address?.toLowerCase() ?? ""}` : symbol),
-    ticker,
   };
 }

package/src/modules/bigIntArithmetics.ts

@@ -42,9 +42,7 @@ export function formatBigIntToSafeValue({
   // Check if we need to round up
   if (Number.parseInt(decimalString[bigIntDecimal] || "0") >= 5) {
     // Increment the last decimal place and slice off the rest
-    decimalString = `${decimalString.substring(0, bigIntDecimal - 1)}${(
-      Number.parseInt(decimalString[bigIntDecimal - 1] || "0") + 1
-    ).toString()}`;
+    decimalString = `${decimalString.substring(0, bigIntDecimal - 1)}${(Number.parseInt(decimalString[bigIntDecimal - 1] || "0") + 1).toString()}`;
   } else {
     // Just slice off the extra digits
     decimalString = decimalString.substring(0, bigIntDecimal);
@@ -277,9 +275,7 @@ export class BigIntArithmetics {
     // Check if we need to round up
     if (Number.parseInt(decimalString[bigIntDecimal] || "0") >= 5) {
       // Increment the last decimal place and slice off the rest
-      decimalString = `${decimalString.substring(0, bigIntDecimal - 1)}${(
-        Number.parseInt(decimalString[bigIntDecimal - 1] || "0") + 1
-      ).toString()}`;
+      decimalString = `${decimalString.substring(0, bigIntDecimal - 1)}${(Number.parseInt(decimalString[bigIntDecimal - 1] || "0") + 1).toString()}`;
     } else {
       // Just slice off the extra digits
       decimalString = decimalString.substring(0, bigIntDecimal);

package/src/modules/requestClient.ts

@@ -1,7 +1,7 @@
-import type { Options } from "ky";
+import type { KyInstance, Options } from "ky";
 import ky from "ky";
 
-let kyClient: typeof ky;
+let kyClientConfig: Options & { apiKey?: string } = {};
 
 export const defaultRequestHeaders =
   typeof window !== "undefined"
@@ -9,21 +9,31 @@ export const defaultRequestHeaders =
     : { referrer: "https://sk.thorswap.net", referer: "https://sk.thorswap.net" };
 
 export function setRequestClientConfig({ apiKey, ...config }: Options & { apiKey?: string }) {
-  kyClient = ky.create({
+  kyClientConfig = { ...config, apiKey };
+}
+
+function getKyClient() {
+  const { apiKey, ...config } = kyClientConfig;
+  return ky.create({
     ...config,
     headers: { ...defaultRequestHeaders, ...config.headers, "x-api-key": apiKey },
   });
 }
 
-function getKyClient() {
-  if (kyClient) return kyClient;
-  kyClient = ky.create({ headers: defaultRequestHeaders });
-  return kyClient;
-}
+const getTypedBaseRequestClient = (ky: KyInstance) => ({
+  get: async <T>(url: string | URL | Request, options?: Options) =>
+    (await ky.get(url, options)).json<T>(),
+  post: async <T>(url: string | URL | Request, options?: Options) =>
+    (await ky.post(url, options)).json<T>(),
+});
 
 export const RequestClient = {
-  get: <T>(url: string | URL | Request, options?: Options) =>
-    getKyClient().get(url, options).json<T>(),
-  post: <T>(url: string | URL | Request, options?: Options) =>
-    getKyClient().post(url, options).json<T>(),
+  ...getTypedBaseRequestClient(getKyClient()),
+  extend: (options: Options) => {
+    const extendedClient = getKyClient().extend(options);
+    return {
+      ...getTypedBaseRequestClient(extendedClient),
+      extend: RequestClient.extend,
+    };
+  },
 };

package/src/modules/swapKitError.ts

@@ -1,8 +1,7 @@
-const errorMessages = {
+const errorCodes = {
   /**
    * Core
    */
-  core_wallet_connection_not_found: 10001,
   core_estimated_max_spendable_chain_not_supported: 10002,
   core_extend_error: 10003,
   core_inbound_data_not_found: 10004,
@@ -10,11 +9,10 @@ const errorMessages = {
   core_plugin_not_found: 10006,
   core_plugin_swap_not_found: 10007,
   core_approve_asset_target_invalid: 10008,
+  core_explorer_unsupported_chain: 10009,
   core_chain_halted: 10099,
 
-  /**
-   * Core - Wallet Connection
-   */
+  core_wallet_connection_not_found: 10100,
   core_wallet_xdefi_not_installed: 10101,
   core_wallet_evmwallet_not_installed: 10102,
   core_wallet_walletconnect_not_installed: 10103,
@@ -39,12 +37,12 @@ const errorMessages = {
    * Core - Transaction
    */
   core_transaction_deposit_error: 10301,
-  core_transaction_create_liquidity_rune_error: 10302,
+  core_transaction_create_liquidity_base_error: 10302,
   core_transaction_create_liquidity_asset_error: 10303,
   core_transaction_create_liquidity_invalid_params: 10304,
   core_transaction_add_liquidity_invalid_params: 10305,
-  core_transaction_add_liquidity_no_rune_address: 10306,
-  core_transaction_add_liquidity_rune_error: 10307,
+  core_transaction_add_liquidity_base_address: 10306,
+  core_transaction_add_liquidity_base_error: 10307,
   core_transaction_add_liquidity_asset_error: 10308,
   core_transaction_withdraw_error: 10309,
   core_transaction_deposit_to_pool_error: 10310,
@@ -53,36 +51,90 @@ const errorMessages = {
   core_transaction_invalid_sender_address: 10313,
   core_transaction_deposit_server_error: 10314,
   core_transaction_user_rejected: 10315,
-
   /**
    * Wallets
    */
-  wallet_ledger_connection_error: 20001,
-  wallet_ledger_connection_claimed: 20002,
-  wallet_ledger_get_address_error: 20003,
-  wallet_ledger_device_not_found: 20004,
-  wallet_ledger_device_locked: 20005,
-
+  wallet_connection_rejected_by_user: 20000,
+  wallet_missing_api_key: 20001,
+  wallet_chain_not_supported: 20002,
+  wallet_missing_params: 20003,
+  wallet_provider_not_found: 20004,
+  wallet_failed_to_add_or_switch_network: 20005,
+  wallet_ledger_connection_error: 20101,
+  wallet_ledger_connection_claimed: 20102,
+  wallet_ledger_get_address_error: 20103,
+  wallet_ledger_device_not_found: 20104,
+  wallet_ledger_device_locked: 20105,
+  wallet_phantom_not_found: 20201,
+  wallet_xdefi_not_found: 20301,
+  wallet_xdefi_send_transaction_no_address: 20302,
+  wallet_xdefi_contract_address_not_provided: 20303,
+  wallet_xdefi_asset_not_defined: 20304,
+  wallet_walletconnect_project_id_not_specified: 20401,
+  wallet_walletconnect_connection_not_established: 20402,
+  wallet_walletconnect_namespace_not_supported: 20403,
+  wallet_trezor_failed_to_sign_transaction: 20501,
+  wallet_trezor_derivation_path_not_supported: 20502,
+  wallet_trezor_failed_to_get_address: 20503,
+  wallet_talisman_not_enabled: 20601,
+  wallet_talisman_not_found: 20602,
   /**
    * Chainflip
    */
   chainflip_channel_error: 30001,
-  chainflip_broker_recipient_error: 30002,
-
+  chainflip_unknown_asset: 30002,
+  chainflip_broker_invalid_params: 30100,
+  chainflip_broker_recipient_error: 30101,
+  chainflip_broker_register: 30102,
+  chainflip_broker_tx_error: 30103,
+  chainflip_broker_withdraw: 30104,
+  chainflip_broker_fund_only_flip_supported: 30105,
+  chainflip_broker_fund_invalid_address: 30106,
   /**
    * THORChain
    */
+  thorchain_chain_halted: 40001,
+  thorchain_trading_halted: 40002,
+  thorchain_swapin_router_required: 40100,
+  thorchain_swapin_vault_required: 40101,
+  thorchain_swapin_memo_required: 40102,
+  thorchain_swapin_token_required: 40103,
+  /**
+   * SwapKit API
+   */
+  api_v2_invalid_response: 50001,
 
+  /**
+   * Toolboxes
+   */
+  toolbox_cosmos_signer_not_defined: 90101,
+  toolbox_cosmos_no_accounts_found: 90102,
   /**
    * Helpers
    */
-  helpers_number_different_decimals: 99101,
+  helpers_invalid_number_different_decimals: 99000,
+  helpers_invalid_number_of_years: 99001,
+  helpers_invalid_identifier: 99002,
+  helpers_invalid_asset_url: 99003,
+  helpers_invalid_asset_identifier: 99004,
+  helpers_invalid_memo_type: 99005,
+  helpers_failed_to_switch_network: 99103,
+  helpers_not_found_provider: 99200,
 } as const;
 
-export type ErrorKeys = keyof typeof errorMessages;
+export type ErrorKeys = keyof typeof errorCodes;
 
 export class SwapKitError extends Error {
-  constructor(errorKey: ErrorKeys, sourceError?: NotWorth) {
+  static ErrorCode = errorCodes;
+
+  constructor(
+    errorOrErrorKey: ErrorKeys | { errorKey: ErrorKeys; info?: Record<string, NotWorth> },
+    sourceError?: NotWorth,
+  ) {
+    const isErrorString = typeof errorOrErrorKey === "string";
+
+    const errorKey = isErrorString ? errorOrErrorKey : errorOrErrorKey.errorKey;
+
     if (sourceError) {
       console.error(sourceError, {
         stack: sourceError?.stack,
@@ -91,8 +143,12 @@ export class SwapKitError extends Error {
     }
 
     super(errorKey, {
-      cause: { code: errorMessages[errorKey], message: errorKey },
+      cause: {
+        code: SwapKitError.ErrorCode[errorKey],
+        message: `${errorKey}${isErrorString ? "" : `: ${JSON.stringify(errorOrErrorKey.info)}`}`,
+      },
     });
+
     Object.setPrototypeOf(this, SwapKitError.prototype);
   }
 }

package/src/types/chains.ts

@@ -3,7 +3,6 @@ import { ExplorerUrl, RPCUrl } from "./network";
 export enum Chain {
   Arbitrum = "ARB",
   Avalanche = "AVAX",
-  Binance = "BNB",
   BinanceSmartChain = "BSC",
   Bitcoin = "BTC",
   BitcoinCash = "BCH",
@@ -18,15 +17,18 @@ export enum Chain {
   Polkadot = "DOT",
   Chainflip = "FLIP",
   Polygon = "MATIC",
+  Radix = "XRD",
   THORChain = "THOR",
+  Solana = "SOL",
 }
 
+export type WalletChain = Exclude<Chain, Chain.Chainflip | Chain.Radix>;
+
 export enum ChainId {
   Arbitrum = "42161",
   ArbitrumHex = "0xa4b1",
   Avalanche = "43114",
   AvalancheHex = "0xa86a",
-  Binance = "Binance-Chain-Tigris",
   BinanceSmartChain = "56",
   BinanceSmartChainHex = "0x38",
   Bitcoin = "bitcoin",
@@ -46,8 +48,10 @@ export enum ChainId {
   Polkadot = "polkadot",
   Polygon = "137",
   PolygonHex = "0x89",
+  Radix = "radix-mainnet",
   THORChain = "thorchain-mainnet-v1",
   THORChainStagenet = "thorchain-stagenet-v2",
+  Solana = "solana",
 }
 
 export const ChainIdToChain: Record<ChainId, Chain> = {
@@ -57,7 +61,6 @@ export const ChainIdToChain: Record<ChainId, Chain> = {
   [ChainId.Avalanche]: Chain.Avalanche,
   [ChainId.BinanceSmartChainHex]: Chain.BinanceSmartChain,
   [ChainId.BinanceSmartChain]: Chain.BinanceSmartChain,
-  [ChainId.Binance]: Chain.Binance,
   [ChainId.BitcoinCash]: Chain.BitcoinCash,
   [ChainId.Bitcoin]: Chain.Bitcoin,
   [ChainId.Chainflip]: Chain.Chainflip,
@@ -75,8 +78,10 @@ export const ChainIdToChain: Record<ChainId, Chain> = {
   [ChainId.Polkadot]: Chain.Polkadot,
   [ChainId.PolygonHex]: Chain.Polygon,
   [ChainId.Polygon]: Chain.Polygon,
+  [ChainId.Radix]: Chain.Radix,
   [ChainId.THORChainStagenet]: Chain.THORChain,
   [ChainId.THORChain]: Chain.THORChain,
+  [ChainId.Solana]: Chain.Solana,
 };
 
 type ChainNameType = keyof typeof Chain;
@@ -87,7 +92,6 @@ export enum BaseDecimal {
   ARB = 18,
   AVAX = 18,
   BCH = 8,
-  BNB = 8,
   BSC = 18,
   BTC = 8,
   DASH = 8,
@@ -101,7 +105,9 @@ export enum BaseDecimal {
   MATIC = 18,
   MAYA = 10,
   OP = 18,
+  SOL = 9,
   THOR = 8,
+  XRD = 18,
   ZEC = 8,
 }
 
@@ -138,23 +144,11 @@ export const UTXOChains = [
   Chain.Litecoin,
 ] as const;
 
-export type CosmosChain =
-  | Chain.Cosmos
-  | Chain.THORChain
-  | Chain.Binance
-  | Chain.Maya
-  | Chain.Kujira;
-export const CosmosChains = [
-  Chain.Cosmos,
-  Chain.THORChain,
-  Chain.Binance,
-  Chain.Maya,
-  Chain.Kujira,
-] as const;
+export type CosmosChain = Chain.Cosmos | Chain.THORChain | Chain.Maya | Chain.Kujira;
+export const CosmosChains = [Chain.Cosmos, Chain.THORChain, Chain.Maya, Chain.Kujira] as const;
 
 export const TCSupportedChains = [
   Chain.Avalanche,
-  Chain.Binance,
   Chain.BinanceSmartChain,
   Chain.Bitcoin,
   Chain.BitcoinCash,

package/src/types/commonTypes.ts

@@ -43,6 +43,10 @@ export type ConnectConfig = {
       url: string;
     };
   };
+  /**
+   * @optional for setting the chainflip broker url
+   */
+  chainflipBrokerUrl?: string;
 };
 
 export type AddChainWalletParams<T extends Chain> = {