@swapkit/helpers 1.0.0-rc.99 → 1.0.0

package/src/helpers/memo.ts

@@ -1,17 +1,131 @@
+import { SwapKitError } from "../modules/swapKitError";
 import { Chain } from "../types/chains";
 import { MemoType } from "../types/sdk";
 
-export type ThornameRegisterParam = {
-  name: string;
-  chain: string;
-  address: string;
-  owner?: string;
-  preferredAsset?: string;
-  expiryBlock?: string;
-};
-
 type WithChain<T extends {}> = T & { chain: Chain };
 
+type WithAffiliate<T extends {}> = T & { affiliateAddress?: string; affiliateBasisPoints?: number };
+
+function addAffiliate(memo: string, { affiliateAddress, affiliateBasisPoints }: WithAffiliate<{}>) {
+  const affiliatePart = affiliateAddress ? `:${affiliateAddress}:${affiliateBasisPoints || 0}` : "";
+
+  return `${memo}${affiliatePart}`;
+}
+
+function getPoolIdentifier({ chain, symbol }: { chain: Chain; symbol: string }) {
+  switch (chain) {
+    case Chain.Bitcoin:
+    case Chain.Dogecoin:
+    case Chain.Litecoin:
+      return chain.slice(0, 1).toLowerCase();
+    case Chain.BitcoinCash:
+      return "c";
+
+    default:
+      return `${chain}.${symbol}`;
+  }
+}
+
+export function getMemoForLeaveAndBond({
+  type,
+  address,
+}: { type: MemoType.BOND | MemoType.LEAVE; address: string }) {
+  return `${type}:${address}`;
+}
+
+export function getMemoForUnbond({
+  address,
+  unbondAmount,
+}: { address: string; unbondAmount: number }) {
+  return `${MemoType.UNBOND}:${address}:${unbondAmount}`;
+}
+
+export function getMemoForNameRegister({
+  name,
+  chain,
+  address,
+  owner,
+}: { name: string; chain: string; address: string; owner?: string }) {
+  const baseMemo = `${MemoType.NAME_REGISTER}:${name}:${chain}:${address}`;
+  const ownerAssignmentOrChangePart = owner ? `:${owner}` : "";
+
+  return `${baseMemo}${ownerAssignmentOrChangePart}`;
+}
+
+export function getMemoForLoan(
+  memoType: MemoType.OPEN_LOAN | MemoType.CLOSE_LOAN,
+  {
+    asset,
+    address,
+    minAmount,
+    ...affiliate
+  }: WithAffiliate<{
+    address: string;
+    asset: string;
+    minAmount?: string;
+  }>,
+) {
+  const baseMemo = `${memoType}:${asset}:${address}`;
+  const minAmountPart = minAmount ? `:${minAmount}` : "";
+
+  return addAffiliate(`${baseMemo}${minAmountPart}`, affiliate);
+}
+
+export function getMemoForSaverDeposit({
+  chain,
+  symbol,
+  ...affiliate
+}: WithAffiliate<{ chain: Chain; symbol: string }>) {
+  return addAffiliate(`${MemoType.DEPOSIT}:${chain}/${symbol}`, affiliate);
+}
+
+export function getMemoForDeposit({
+  chain,
+  symbol,
+  address,
+}: { chain: Chain; symbol: string; address?: string }) {
+  const poolIdentifier = getPoolIdentifier({ chain, symbol });
+  const addressPart = address ? `:${address}` : "";
+
+  return `${MemoType.DEPOSIT}:${poolIdentifier}${addressPart}`;
+}
+
+export function getMemoForSaverWithdraw({
+  chain,
+  symbol,
+  basisPoints,
+  ...affiliate
+}: WithAffiliate<{ chain: Chain; symbol: string; basisPoints: number }>) {
+  return addAffiliate(`${MemoType.WITHDRAW}:${chain}/${symbol}:${basisPoints}`, affiliate);
+}
+
+export function getMemoForWithdraw({
+  chain,
+  symbol,
+  ticker,
+  basisPoints,
+  targetAsset,
+  ...affiliate
+}: WithAffiliate<{
+  chain: Chain;
+  symbol: string;
+  ticker: string;
+  basisPoints: number;
+  targetAsset?: string;
+}>) {
+  const shortenedSymbol =
+    chain === "ETH" && ticker !== "ETH" ? `${ticker}-${symbol.slice(-3)}` : symbol;
+  const targetPart = targetAsset ? `:${targetAsset}` : "";
+
+  return addAffiliate(
+    `${MemoType.WITHDRAW}:${chain}.${shortenedSymbol}:${basisPoints}${targetPart}`,
+    affiliate,
+  );
+}
+
+/**
+ * @deprecated - Use separate functions per each memo type like getMemoForDeposit, getMemoForWithdraw, etc.
+ */
 export type MemoOptions<T extends MemoType> = {
   [MemoType.BOND]: { address: string };
   [MemoType.LEAVE]: { address: string };
@@ -26,68 +140,65 @@ export type MemoOptions<T extends MemoType> = {
     targetAssetString?: string;
     singleSide?: boolean;
   }>;
-  [MemoType.THORNAME_REGISTER]: Omit<ThornameRegisterParam, "preferredAsset" | "expiryBlock">;
+  [MemoType.NAME_REGISTER]: { name: string; chain: string; address: string };
 }[T];
 
+/**
+ * @deprecated - Use separate functions per each memo type like getMemoForDeposit, getMemoForWithdraw, etc.
+ */
 export const getMemoFor = <T extends MemoType>(memoType: T, options: MemoOptions<T>) => {
   switch (memoType) {
     case MemoType.LEAVE:
     case MemoType.BOND: {
       const { address } = options as MemoOptions<MemoType.BOND>;
-      return `${memoType}:${address}`;
+      return getMemoForLeaveAndBond({ type: memoType, address });
     }
 
     case MemoType.UNBOND: {
       const { address, unbondAmount } = options as MemoOptions<MemoType.UNBOND>;
-      return `${memoType}:${address}:${unbondAmount}`;
+      return getMemoForUnbond({ address, unbondAmount });
     }
 
-    case MemoType.THORNAME_REGISTER: {
-      const { name, chain, address, owner } = options as MemoOptions<MemoType.THORNAME_REGISTER>;
-      return `${memoType}:${name}:${chain}:${address}${owner ? `:${owner}` : ""}`;
+    case MemoType.NAME_REGISTER: {
+      return getMemoForNameRegister(options as MemoOptions<MemoType.NAME_REGISTER>);
+    }
+
+    case MemoType.OPEN_LOAN:
+    case MemoType.CLOSE_LOAN: {
+      return getMemoForLoan(memoType, options as MemoOptions<MemoType.OPEN_LOAN>);
     }
 
     case MemoType.DEPOSIT: {
       const { chain, symbol, address, singleSide } = options as MemoOptions<MemoType.DEPOSIT>;
 
-      const getPoolIdentifier = (chain: Chain, symbol: string): string => {
-        switch (chain) {
-          case Chain.Litecoin:
-            return "l";
-          case Chain.Dogecoin:
-            return "d";
-          case Chain.BitcoinCash:
-            return "c";
-          default:
-            return `${chain}.${symbol}`;
-        }
-      };
-
-      return singleSide
-        ? `${memoType}:${chain}/${symbol}`
-        : `${memoType}:${getPoolIdentifier(chain, symbol)}:${address || ""}`;
+      if (singleSide) {
+        return getMemoForSaverDeposit({ chain, symbol });
+      }
+
+      return getMemoForDeposit({ chain, symbol, address });
     }
 
     case MemoType.WITHDRAW: {
-      const { chain, ticker, symbol, basisPoints, targetAssetString, singleSide } =
-        options as MemoOptions<MemoType.WITHDRAW>;
+      const {
+        chain,
+        ticker,
+        symbol,
+        basisPoints,
+        targetAssetString: targetAsset,
+        singleSide,
+      } = options as MemoOptions<MemoType.WITHDRAW>;
 
-      const shortenedSymbol =
-        chain === "ETH" && ticker !== "ETH" ? `${ticker}-${symbol.slice(-3)}` : symbol;
-      const target = !singleSide && targetAssetString ? `:${targetAssetString}` : "";
-      const assetDivider = singleSide ? "/" : ".";
-
-      return `${memoType}:${chain}${assetDivider}${shortenedSymbol}:${basisPoints}${target}`;
-    }
-
-    case MemoType.OPEN_LOAN:
-    case MemoType.CLOSE_LOAN: {
-      const { asset, address } = options as MemoOptions<MemoType.OPEN_LOAN>;
+      if (singleSide) {
+        return getMemoForSaverWithdraw({ chain, symbol, basisPoints });
+      }
 
-      return `${memoType}:${asset}:${address}`; //:${minAmount ? `${minAmount}` : ''}:t:0`;
+      return getMemoForWithdraw({ chain, ticker, symbol, basisPoints, targetAsset });
     }
 
     default:
-      return "";
+      throw new SwapKitError({
+        errorKey: "helpers_invalid_memo_type",
+        info: { memoType },
+      });
   }
 };

package/src/helpers/others.ts

@@ -1,17 +1,26 @@
 import { type ErrorKeys, SwapKitError } from "../modules/swapKitError";
+import { Chain } from "../types";
 import type { DerivationPathArray } from "../types/derivationPath";
 
 // 10 rune for register, 1 rune per year
 // MINIMUM_REGISTRATION_FEE = 11
 export function getTHORNameCost(numberOfYears: number) {
-  if (numberOfYears < 0) throw new Error("Invalid number of years");
+  if (numberOfYears < 0)
+    throw new SwapKitError({
+      errorKey: "helpers_invalid_number_of_years",
+      info: { numberOfYears },
+    });
   return 10 + numberOfYears;
 }
 
 // 10 CACAO for register
 // 1.0512 CACAO per year
 export function getMAYANameCost(numberOfYears: number) {
-  if (numberOfYears < 0) throw new Error("Invalid number of year");
+  if (numberOfYears < 0)
+    throw new SwapKitError({
+      errorKey: "helpers_invalid_number_of_years",
+      info: { numberOfYears },
+    });
   // round to max 10 decimals
   return Math.round((10 + numberOfYears * 1.0512) * 1e10) / 1e10;
 }
@@ -35,3 +44,19 @@ export function wrapWithThrow<T>(fn: () => T, errorKey?: ErrorKeys) {
     return console.error(error);
   }
 }
+
+export const getChainIdentifier = (chain: Chain) => {
+  switch (chain) {
+    case Chain.THORChain:
+      return `${chain}.RUNE`;
+
+    case Chain.Cosmos:
+      return `${chain}.ATOM`;
+
+    case Chain.BinanceSmartChain:
+      return `${chain}`;
+
+    default:
+      return `${chain}.${chain}`;
+  }
+};

package/src/helpers/validators.ts

@@ -1,3 +1,4 @@
+import { SwapKitError } from "../modules/swapKitError";
 import { Chain } from "../types/chains";
 
 // Backward compatibility
@@ -12,9 +13,13 @@ export function validateIdentifier(identifier = "") {
   const [synthChain] = uppercasedIdentifier.split("/") as [Chain, string];
   if (supportedChains.includes(synthChain)) return true;
 
-  throw new Error(
-    `Invalid identifier: ${identifier}. Expected format: <Chain>.<Ticker> or <Chain>.<Ticker>-<ContractAddress>`,
-  );
+  throw new SwapKitError({
+    errorKey: "helpers_invalid_identifier",
+    info: {
+      message: `Invalid identifier: ${identifier}. Expected format: <Chain>.<Ticker> or <Chain>.<Ticker>-<ContractAddress>`,
+      identifier,
+    },
+  });
 }
 
 export function validateTNS(name: string) {

package/src/helpers/web3wallets.ts

@@ -1,5 +1,11 @@
 import type { BrowserProvider } from "ethers";
-import { ChainId, WalletOption } from "../types";
+import { SwapKitError } from "../modules/swapKitError";
+import {
+  ChainId,
+  type EIP6963AnnounceProviderEvent,
+  type EIP6963Provider,
+  WalletOption,
+} from "../types";
 
 export type EthereumWindowProvider = BrowserProvider & {
   __XDEFI?: boolean;
@@ -8,6 +14,7 @@ export type EthereumWindowProvider = BrowserProvider & {
   isMetaMask?: boolean;
   isOkxWallet?: boolean;
   isTrust?: boolean;
+  isTalisman?: boolean;
   on: (event: string, callback?: () => void) => void;
   overrideIsMetaMask?: boolean;
   request: <T = unknown>(args: { method: string; params?: unknown[] }) => Promise<T>;
@@ -79,13 +86,18 @@ export const wrapMethodWithNetworkSwitch = <T extends (...args: Todo[]) => Todo>
     try {
       await switchEVMWalletNetwork(provider, chainId);
     } catch (error) {
-      throw new Error(`Failed to switch network: ${error}`);
+      throw new SwapKitError({
+        errorKey: "helpers_failed_to_switch_network",
+        info: { error },
+      });
     }
     return func(...args);
   }) as unknown as T;
 
 const providerRequest = ({ provider, params, method }: ProviderRequestParams) => {
-  if (!provider?.send) throw new Error("Provider not found");
+  if (!provider?.send) {
+    throw new SwapKitError("helpers_not_found_provider");
+  }
 
   const providerParams = params ? (Array.isArray(params) ? params : [params]) : [];
   return provider.send(method, providerParams);
@@ -142,7 +154,7 @@ export const isDetected = (walletOption: WalletOption) => {
   return listWeb3EVMWallets().includes(walletOption);
 };
 
-const listWeb3EVMWallets = () => {
+export const listWeb3EVMWallets = () => {
   const metamaskEnabled = window?.ethereum && !window.ethereum?.isBraveWallet;
   // @ts-ignore that should be implemented in xdefi and hooked up via swapkit core
   const xdefiEnabled = window?.xfi || window?.ethereum?.__XDEFI;
@@ -164,6 +176,24 @@ const listWeb3EVMWallets = () => {
   return wallets;
 };
 
+export function getEIP6963Wallets() {
+  const providers: EIP6963Provider[] = [];
+
+  function onAnnouncement(event: EIP6963AnnounceProviderEvent) {
+    if (providers.map((p) => p.info.uuid).includes(event.detail.info.uuid)) return;
+    providers.push(event.detail);
+  }
+
+  window.addEventListener("eip6963:announceProvider", onAnnouncement);
+  window.dispatchEvent(new Event("eip6963:requestProvider"));
+
+  function removeEIP6963EventListener() {
+    window.removeEventListener("eip6963:announceProvider", onAnnouncement);
+  }
+
+  return { providers, removeEIP6963EventListener };
+}
+
 export const okxMobileEnabled = () => {
   const ua = navigator.userAgent;
   const isIOS = /iphone|ipad|ipod|ios/i.test(ua);