@swapkit/helpers 2.6.0 → 3.0.0-beta.1

package/src/types/wallet.ts

@@ -1,14 +1,16 @@
-import type { CosmosWallets, ThorchainWallets } from "@swapkit/toolbox-cosmos";
-import type { EVMWallets } from "@swapkit/toolbox-evm";
-import type { RadixWallets } from "@swapkit/toolbox-radix";
-import type { SolanaWallets } from "@swapkit/toolbox-solana";
-import type { SubstrateWallets } from "@swapkit/toolbox-substrate";
-import type { UTXOWallets } from "@swapkit/toolbox-utxo";
+import type { CosmosWallets, ThorchainWallets } from "@swapkit/toolboxes/cosmos";
+import type { EVMToolboxes } from "@swapkit/toolboxes/evm";
+import type { RadixWallet } from "@swapkit/toolboxes/radix";
+import type { RippleWallet } from "@swapkit/toolboxes/ripple";
+import type { SolanaWallet } from "@swapkit/toolboxes/solana";
+import type { SubstrateToolboxes } from "@swapkit/toolboxes/substrate";
+import type { UTXOToolboxes } from "@swapkit/toolboxes/utxo";
+import type { BrowserProvider } from "ethers";
 import type { Eip1193Provider } from "ethers";
 
 import type { AssetValue } from "../modules/assetValue";
-import type { Chain } from "./chains";
-import type { ConnectWalletParams } from "./commonTypes";
+import { Chain, type ChainId } from "./chains";
+import type { FeeOption } from "./sdk";
 
 declare global {
   interface WindowEventMap {
@@ -16,13 +18,34 @@ declare global {
   }
 }
 
-export type {
-  CosmosWallets,
-  ThorchainWallets,
-  EVMWallets,
-  SubstrateWallets,
-  UTXOWallets,
-  SolanaWallets,
+export type EthereumWindowProvider = BrowserProvider & {
+  __XDEFI?: boolean;
+  isBraveWallet?: boolean;
+  isCoinbaseWallet?: boolean;
+  isMetaMask?: boolean;
+  isOkxWallet?: boolean;
+  isKeepKeyWallet?: boolean;
+  isTrust?: boolean;
+  isTalisman?: boolean;
+  on: (event: string, callback?: () => void) => void;
+  overrideIsMetaMask?: boolean;
+  request: <T = unknown>(args: {
+    method: string;
+    params?: unknown[];
+  }) => Promise<T>;
+  selectedProvider?: EthereumWindowProvider;
+};
+
+export type NetworkParams = {
+  chainId: ChainId;
+  chainName: string;
+  nativeCurrency: {
+    name: string;
+    symbol: string;
+    decimals: number;
+  };
+  rpcUrls: string[];
+  blockExplorerUrls: string[];
 };
 
 export enum WalletOption {
@@ -43,6 +66,7 @@ export enum WalletOption {
   METAMASK = "METAMASK",
   OKX = "OKX",
   OKX_MOBILE = "OKX_MOBILE",
+  ONEKEY = "ONEKEY",
   PHANTOM = "PHANTOM",
   POLKADOT_JS = "POLKADOT_JS",
   RADIX_WALLET = "RADIX_WALLET",
@@ -64,7 +88,7 @@ export type ChainWallet<T extends Chain> = {
   chain: T;
   address: string;
   balance: AssetValue[];
-  walletType: WalletOption;
+  walletType: WalletOption | string;
   disconnect?: () => void;
   signMessage?: (message: string) => Promise<string>;
 };
@@ -75,28 +99,19 @@ export type BaseWallet<T extends EmptyWallet | Record<string, unknown>> = {
 };
 
 export type FullWallet = BaseWallet<
-  EVMWallets &
-    UTXOWallets &
+  EVMToolboxes &
+    UTXOToolboxes &
     CosmosWallets &
     ThorchainWallets &
-    SubstrateWallets &
-    SolanaWallets &
-    RadixWallets
+    SubstrateToolboxes & {
+      [Chain.Radix]: RadixWallet;
+      [Chain.Ripple]: RippleWallet;
+      [Chain.Solana]: SolanaWallet;
+    }
 >;
 
-/**
- * @deprecated use FullWallet instead
- */
-export type Wallet = FullWallet;
-
-export type SwapKitWallet<ConnectParams extends any[]> = (
-  params: ConnectWalletParams,
-) => (...connectParams: ConnectParams) => boolean | Promise<boolean>;
-
-export type SwapKitPluginParams<Config = {}> = {
+export type SwapKitPluginParams = {
   getWallet: <T extends CryptoChain>(chain: T) => FullWallet[T];
-  stagenet?: boolean;
-  config: Config;
 };
 
 export type EIP6963ProviderInfo = {
@@ -120,3 +135,25 @@ export type EIP6963Provider = {
 export type EIP6963AnnounceProviderEvent = Event & {
   detail: EIP6963Provider;
 };
+
+export type ChainSigner<T, S> = {
+  signTransaction: (params: T) => Promise<S>;
+  getAddress: () => Promise<string>;
+  sign?: (message: string) => Promise<string>;
+};
+
+export type GenericTransferParams = {
+  recipient: string;
+  assetValue: AssetValue;
+  memo?: string;
+  feeRate?: number;
+  feeOptionKey?: FeeOption;
+};
+
+export type GenericCreateTransactionParams = Omit<
+  GenericTransferParams,
+  "feeOptionKey" & "feeRate"
+> & {
+  sender: string;
+  feeRate: number;
+};

package/src/{helpers → utils}/__tests__/asset.test.ts

@@ -163,7 +163,6 @@ describe("assetFromString", () => {
       symbol: "RUNE",
       ticker: "RUNE",
       synth: false,
-      trade: false,
     });
   });
 
@@ -176,31 +175,6 @@ describe("assetFromString", () => {
       symbol: "PENDLE-LPT-0x1234",
       ticker: "PENDLE-LPT",
       synth: false,
-      trade: false,
-    });
-  });
-
-  test("should return the correct trade asset", () => {
-    const assetString = "ETH~PENDLE-LPT-0x1234";
-    const result = assetFromString(assetString);
-    expect(result).toEqual({
-      chain: Chain.THORChain,
-      symbol: "ETH~PENDLE-LPT-0x1234",
-      ticker: "PENDLE-LPT",
-      synth: false,
-      trade: true,
-    });
-  });
-
-  test("should return the correct synth asset", () => {
-    const assetString = "ETH/PENDLE-LPT-0x1234";
-    const result = assetFromString(assetString);
-    expect(result).toEqual({
-      chain: Chain.THORChain,
-      symbol: "ETH/PENDLE-LPT-0x1234",
-      ticker: "PENDLE-LPT",
-      synth: true,
-      trade: false,
     });
   });
 
@@ -214,7 +188,6 @@ describe("assetFromString", () => {
       symbol: "xwBTC-resource_rdx1t580qxc7upat7lww4l2c4jckacafjeudxj5wpjrrct0p3e82sq4y75",
       ticker: "xwBTC",
       synth: false,
-      trade: false,
     });
   });
 });

package/src/utils/asset.ts

@@ -0,0 +1,235 @@
+import { match } from "ts-pattern";
+import { AssetValue } from "../modules/assetValue";
+import { RequestClient } from "../modules/requestClient";
+import { SKConfig } from "../modules/swapKitConfig";
+import { BaseDecimal, Chain, type EVMChain, EVMChains, UTXOChains } from "../types/chains";
+import type { RadixCoreStateResourceDTO } from "../types/radix";
+import type { TokenNames } from "../types/tokens";
+
+export type CommonAssetString = (typeof CommonAssetStrings)[number] | Chain;
+
+export type ConditionalAssetValueReturn<T extends boolean> = T extends true
+  ? Promise<AssetValue[]>
+  : AssetValue[];
+
+export const CommonAssetStrings = [
+  `${Chain.Maya}.MAYA`,
+  `${Chain.Ethereum}.THOR`,
+  `${Chain.Ethereum}.vTHOR`,
+  `${Chain.Kujira}.USK`,
+  `${Chain.Ethereum}.FLIP`,
+  `${Chain.Radix}.XRD`,
+] as const;
+
+const ethGasChains = [
+  Chain.Arbitrum,
+  Chain.Avalanche,
+  Chain.Base,
+  Chain.Ethereum,
+  Chain.Optimism,
+  Chain.Polygon,
+] as const;
+
+async function getContractDecimals({ chain, to }: { chain: EVMChain; to: string }) {
+  const getDecimalMethodHex = "0x313ce567";
+
+  try {
+    const { result } = await RequestClient.post<{ result: string }>(
+      SKConfig.get("rpcUrls")[chain],
+      {
+        headers: {
+          accept: "*/*",
+          "content-type": "application/json",
+          "cache-control": "no-cache",
+        },
+        body: JSON.stringify({
+          id: 44,
+          jsonrpc: "2.0",
+          method: "eth_call",
+          params: [{ to: to.toLowerCase(), data: getDecimalMethodHex }, "latest"],
+        }),
+      },
+    );
+
+    return Number.parseInt(BigInt(result || BaseDecimal[chain]).toString());
+  } catch (error) {
+    console.error(error);
+    return BaseDecimal[chain];
+  }
+}
+
+async function getRadixAssetDecimal(symbol: string) {
+  if (symbol === Chain.Radix) return BaseDecimal.XRD;
+
+  try {
+    const resourceAddress = symbol.split("-")[1]?.toLowerCase();
+
+    const { manager } = await RequestClient.post<RadixCoreStateResourceDTO>(
+      `${SKConfig.get("rpcUrls").XRD}/state/resource`,
+      {
+        headers: { Accept: "*/*", "Content-Type": "application/json" },
+        body: JSON.stringify({
+          network: "mainnet",
+          resource_address: resourceAddress,
+        }),
+      },
+    );
+
+    return manager.divisibility.value.divisibility;
+  } catch (error) {
+    console.error(error);
+    return BaseDecimal[Chain.Radix];
+  }
+}
+
+async function getEVMAssetDecimal({ chain, symbol }: { chain: EVMChain; symbol: string }) {
+  if (EVMChains.includes(symbol as EVMChain)) return BaseDecimal[symbol as EVMChain];
+
+  const splitSymbol = symbol.split("-");
+  const address =
+    splitSymbol.length === 1 ? undefined : splitSymbol[splitSymbol.length - 1]?.toLowerCase();
+
+  const decimal = await (address?.startsWith("0x")
+    ? getContractDecimals({ chain, to: address })
+    : BaseDecimal[chain as EVMChain]);
+
+  return decimal;
+}
+
+export function getDecimal({ chain, symbol }: { chain: Chain; symbol: string }) {
+  return match(chain)
+    .with(...EVMChains, (chain) => getEVMAssetDecimal({ chain, symbol }))
+    .with(Chain.Radix, () => getRadixAssetDecimal(symbol))
+    .otherwise(() => BaseDecimal[chain]);
+}
+
+/**
+ * @deprecated Use AssetValue.from({ chain }) instead
+ */
+export function getGasAsset({ chain }: { chain: Chain }) {
+  return AssetValue.from({ chain });
+}
+
+export function isGasAsset({ chain, symbol }: { chain: Chain; symbol: string }) {
+  return match(chain)
+    .with(...ethGasChains, () => symbol === "ETH")
+    .with(Chain.BinanceSmartChain, () => symbol === "BNB")
+    .with(Chain.Maya, () => symbol === "CACAO")
+    .with(Chain.Cosmos, () => symbol === "ATOM")
+    .with(Chain.THORChain, () => symbol === "RUNE")
+    .with(Chain.Radix, () => `${chain}.${symbol}` === getCommonAssetInfo(chain).identifier)
+    .otherwise(() => symbol === chain);
+}
+
+export const getCommonAssetInfo = (assetString: CommonAssetString) => {
+  const decimal = BaseDecimal[assetString as Chain];
+
+  const commonAssetInfo = match(assetString.toUpperCase())
+    .with(...ethGasChains, () => ({
+      identifier: `${assetString.toUpperCase()}.ETH`,
+      decimal,
+    }))
+    .with(Chain.THORChain, () => ({
+      identifier: `${assetString.toUpperCase()}.RUNE`,
+      decimal,
+    }))
+    .with(Chain.Cosmos, () => ({ identifier: `${assetString.toUpperCase()}.ATOM`, decimal }))
+    .with(Chain.Maya, () => ({
+      identifier: `${assetString.toUpperCase()}.CACAO`,
+      decimal: 10,
+    }))
+    .with(Chain.BinanceSmartChain, () => ({
+      identifier: `${assetString.toUpperCase()}.BNB`,
+      decimal,
+    }))
+    .with(
+      ...UTXOChains,
+      Chain.Solana,
+      Chain.Chainflip,
+      Chain.Kujira,
+      Chain.Ripple,
+      Chain.Polkadot,
+      () => ({ identifier: `${assetString.toUpperCase()}.${assetString.toUpperCase()}`, decimal }),
+    )
+    .with(Chain.Radix, "XRD.XRD", () => ({
+      identifier: "XRD.XRD-resource_rdx1tknxxxxxxxxxradxrdxxxxxxxxx009923554798xxxxxxxxxradxrd",
+      decimal,
+    }))
+    .with("KUJI.USK", () => ({ identifier: assetString.toUpperCase(), decimal: 6 }))
+    .with("ETH.FLIP", () => ({
+      identifier: "ETH.FLIP-0x826180541412D574cf1336d22c0C0a287822678A",
+      decimal: BaseDecimal.ETH,
+    }))
+    .with("ETH.THOR", () => ({
+      identifier: "ETH.THOR-0xa5f2211b9b8170f694421f2046281775e8468044",
+      decimal: BaseDecimal.ETH,
+    }))
+    .with("ETH.vTHOR", () => ({
+      identifier: "ETH.vTHOR-0x815c23eca83261b6ec689b60cc4a58b54bc24d8d",
+      decimal: BaseDecimal.ETH,
+    }))
+    .with("MAYA.MAYA", () => ({ identifier: assetString.toUpperCase(), decimal: 4 }))
+    // Just to be sure that we are not missing any chain
+    .otherwise(() => ({ identifier: assetString, decimal }));
+
+  return commonAssetInfo;
+};
+
+export function getAssetType({ chain, symbol }: { chain: Chain; symbol: string }) {
+  if (symbol.includes("/")) return "Synth";
+  if (symbol.includes("~")) return "Trade";
+
+  const isNative = match(chain)
+    .with(
+      Chain.Radix,
+      () => symbol === Chain.Radix || `${chain}.${symbol}` === getCommonAssetInfo(chain).identifier,
+    )
+    .with(Chain.Arbitrum, Chain.Optimism, Chain.Base, () => symbol === Chain.Ethereum)
+    .with(Chain.Cosmos, () => symbol === "ATOM")
+    .with(Chain.BinanceSmartChain, () => symbol === "BNB")
+    .with(Chain.Maya, () => symbol === "CACAO")
+    .with(Chain.THORChain, () => symbol === "RUNE")
+    .otherwise(() => symbol === chain);
+
+  return isNative ? "Native" : chain;
+}
+
+export const assetFromString = (assetString: string) => {
+  const [chain, ...symbolArray] = assetString.split(".") as [Chain, ...(string | undefined)[]];
+  const synth = assetString.includes("/");
+  const symbol = symbolArray.join(".");
+  const splitSymbol = symbol?.split("-");
+  const ticker = splitSymbol?.length
+    ? splitSymbol.length === 1
+      ? splitSymbol[0]
+      : splitSymbol.slice(0, -1).join("-")
+    : undefined;
+
+  return { chain, symbol, ticker, synth };
+};
+
+export async function findAssetBy(
+  params:
+    | { chain: EVMChain | Chain.Radix | Chain.Solana; contract: string }
+    | { identifier: `${Chain}.${string}` },
+) {
+  const { tokenLists } = await import("@swapkit/helpers/tokens");
+
+  for (const tokenList of Object.values(tokenLists)) {
+    for (const { identifier, chain: tokenChain, ...rest } of tokenList.tokens) {
+      if ("identifier" in params && identifier === params.identifier) {
+        return identifier as TokenNames;
+      }
+
+      if (
+        "address" in rest &&
+        "chain" in params &&
+        tokenChain === params.chain &&
+        rest.address.toLowerCase() === params.contract.toLowerCase()
+      )
+        return identifier as TokenNames;
+    }
+  }
+
+  return;
+}

package/src/{helpers → utils}/derivationPath.ts

@@ -13,10 +13,27 @@ type Params = {
   type?: "legacy" | "ledgerLive" | "nativeSegwitMiddleAccount" | "segwit" | "account";
 };
 
-export const updatedLastIndex = (path: DerivationPathArray, index: number) => {
-  const newPath = [...path.slice(0, path.length - 1), index];
-  return newPath as DerivationPathArray;
-};
+export function updateDerivationPath(
+  path: DerivationPathArray,
+  params: { index: number } | { account: number } | { change: number },
+) {
+  if ("index" in params) {
+    const newPath = [...path.slice(0, path.length - 1), params.index];
+    return newPath as DerivationPathArray;
+  }
+
+  if ("change" in params) {
+    const [network, chainId, account, , index] = path;
+    return [network, chainId, account, params.change, index] as DerivationPathArray;
+  }
+
+  if ("account" in params) {
+    const [network, chainId, , change, index] = path;
+    return [network, chainId, params.account, change, index] as DerivationPathArray;
+  }
+
+  return path;
+}
 
 export function derivationPathToString([network, chainId, account, change, index]:
   | [number, number, number, number, number?]
@@ -29,15 +46,20 @@ export function derivationPathToString([network, chainId, account, change, index
 // TODO @towan - sort this out and make it more readable
 export function getDerivationPathFor({ chain, index, addressIndex = 0, type }: Params) {
   if (EVMChains.includes(chain as EVMChain)) {
-    if (type && ["legacy", "account"].includes(type))
+    if (type && ["legacy", "account"].includes(type)) {
       return [44, 60, 0, index] as DerivationPathArray;
-    if (type === "ledgerLive") return [44, 60, index, 0, addressIndex] as DerivationPathArray;
-    return updatedLastIndex(NetworkDerivationPath[chain], index);
+    }
+
+    if (type === "ledgerLive") {
+      return [44, 60, index, 0, addressIndex] as DerivationPathArray;
+    }
+
+    return updateDerivationPath(NetworkDerivationPath[chain], { index });
   }
 
   if (chain === Chain.Solana) {
     if (type === "account") return [44, 501, 0, index] as DerivationPathArray;
-    return updatedLastIndex(NetworkDerivationPath[chain], index);
+    return updateDerivationPath(NetworkDerivationPath[chain], { index });
   }
 
   const chainId = chain === Chain.Litecoin ? 2 : 0;
@@ -50,7 +72,7 @@ export function getDerivationPathFor({ chain, index, addressIndex = 0, type }: P
     case "legacy":
       return [44, chainId, 0, 0, index] as DerivationPathArray;
     default:
-      return updatedLastIndex(NetworkDerivationPath[chain], index);
+      return updateDerivationPath(NetworkDerivationPath[chain], { index });
   }
 }
 

package/src/{helpers → utils}/memo.ts

@@ -1,4 +1,3 @@
-import { SwapKitError } from "../modules/swapKitError";
 import { Chain } from "../types/chains";
 import { MemoType } from "../types/sdk";
 
@@ -108,23 +107,6 @@ export function getMemoForLoan(
   return addAffiliate(`${baseMemo}${minAmountPart}`, affiliate);
 }
 
-export function getMemoForTcyClaim(
-  memoType: MemoType.CLAIM_TCY,
-  { address }: WithAffiliate<{ address: string }>,
-) {
-  return `${memoType}:${address}`;
-}
-
-export function getMemoForTcyStake(
-  memoType: MemoType.STAKE_TCY | MemoType.UNSTAKE_TCY,
-  { unstakeBps, ...affiliate }: WithAffiliate<{ unstakeBps?: number }>,
-) {
-  const bps = unstakeBps ? `:${unstakeBps}` : "";
-  const baseMemo = `${memoType}${bps}`;
-
-  return addAffiliate(`${baseMemo}`, affiliate);
-}
-
 /**
  * Internal helpers
  */
@@ -179,67 +161,3 @@ type WithdrawParams = {
   basisPoints: number;
   targetAsset?: string;
 };
-
-/**
- * @deprecated - Use separate functions per each memo type like getMemoForDeposit, getMemoForWithdraw, etc.
- */
-export const getMemoFor = <T extends MemoType>(memoType: T, options: any) => {
-  switch (memoType) {
-    case MemoType.LEAVE:
-    case MemoType.BOND: {
-      return getMemoForLeaveAndBond({ type: memoType, address: options?.address });
-    }
-
-    case MemoType.UNBOND: {
-      return getMemoForUnbond({ address: options?.address, unbondAmount: options?.unbondAmount });
-    }
-
-    case MemoType.NAME_REGISTER: {
-      return getMemoForNameRegister(options);
-    }
-
-    case MemoType.OPEN_LOAN:
-    case MemoType.CLOSE_LOAN: {
-      return getMemoForLoan(memoType, options);
-    }
-
-    case MemoType.DEPOSIT: {
-      const { chain, symbol, address, singleSide } = options;
-
-      if (singleSide) {
-        return getMemoForSaverDeposit({ chain, symbol });
-      }
-
-      return getMemoForDeposit({ chain, symbol, address });
-    }
-
-    case MemoType.WITHDRAW: {
-      const {
-        chain,
-        ticker,
-        symbol,
-        basisPoints,
-        targetAssetString: targetAsset,
-        singleSide,
-      } = options;
-
-      if (singleSide) {
-        return getMemoForSaverWithdraw({ chain, symbol, basisPoints });
-      }
-
-      return getMemoForWithdraw({
-        chain,
-        ticker,
-        symbol,
-        basisPoints,
-        targetAsset,
-      });
-    }
-
-    default:
-      throw new SwapKitError({
-        errorKey: "helpers_invalid_memo_type",
-        info: { memoType },
-      });
-  }
-};

package/src/{helpers → utils}/others.ts

@@ -1,6 +1,7 @@
 import { RequestClient } from "../modules/requestClient";
+import { SKConfig } from "../modules/swapKitConfig";
 import { type ErrorKeys, SwapKitError } from "../modules/swapKitError";
-import { Chain, ChainId, StagenetChain, getRPCUrl } from "../types";
+import { Chain, ChainId, StagenetChain } from "../types";
 
 // 10 rune for register, 1 rune per year
 // MINIMUM_REGISTRATION_FEE = 11
@@ -53,10 +54,9 @@ export function getChainIdentifier<T extends Chain>(chain: T) {
   }
 }
 
-const skipWarnings = ["production", "test"].includes(process.env.NODE_ENV || "");
 const warnings = new Set();
 export function warnOnce(condition: boolean, warning: string) {
-  if (!skipWarnings && condition) {
+  if (condition) {
     if (warnings.has(warning)) {
       return;
     }
@@ -67,11 +67,18 @@ export function warnOnce(condition: boolean, warning: string) {
 }
 
 export async function getDynamicChainId(chainId: ChainId = ChainId.THORChain) {
-  if (![ChainId.THORChainStagenet, ChainId.THORChain, "thorchain-mainnet-v1"].includes(chainId))
+  if (![ChainId.THORChainStagenet, ChainId.THORChain, "thorchain-mainnet-v1"].includes(chainId)) {
     return chainId;
+  }
+
   try {
+    const rpcUrl =
+      SKConfig.get("rpcUrls")[
+        chainId !== ChainId.THORChain ? StagenetChain.THORChain : Chain.THORChain
+      ];
+
     const response = await RequestClient.get<{ result: { node_info: { network: string } } }>(
-      `${chainId !== ChainId.THORChain ? getRPCUrl(StagenetChain.THORChain) : getRPCUrl(Chain.THORChain)}/status`,
+      `${rpcUrl}/status`,
     );
     return response.result.node_info.network as ChainId;
   } catch (_error) {

package/src/utils/plugin.ts

@@ -0,0 +1,13 @@
+import type { ProviderName, SwapKitPluginParams } from "../types";
+
+export function createPlugin<
+  const Name extends string,
+  T extends (params: SwapKitPluginParams) => Record<string, unknown>,
+  K extends { supportedSwapkitProviders?: (ProviderName | string)[] },
+>({ name, properties, methods }: { name: Name; properties?: K; methods: T }) {
+  function plugin(pluginParams: SwapKitPluginParams) {
+    return { ...methods(pluginParams), ...properties } as K & ReturnType<T>;
+  }
+
+  return { [name]: plugin } as { [key in Name]: typeof plugin };
+}