@swapkit/helpers 1.0.0-rc.9 → 1.0.0-rc.91

package/src/helpers/asset.ts

@@ -1,55 +1,63 @@
-import type { EVMChain } from '@swapkit/types';
-import { BaseDecimal, Chain, ChainToRPC, FeeOption } from '@swapkit/types';
+import { RequestClient } from "../modules/requestClient.ts";
+import { BaseDecimal, Chain, ChainToRPC, type EVMChain, EVMChains } from "../types/chains.ts";
+import type { TokenNames } from "../types/tokens.ts";
 
-import { type AssetValue, RequestClient } from '../index.ts';
+const getDecimalMethodHex = "0x313ce567";
 
-const getDecimalMethodHex = '0x313ce567';
-
-export type CommonAssetString = 'MAYA.MAYA' | 'ETH.THOR' | 'ETH.vTHOR' | Chain;
+export type CommonAssetString =
+  | `${Chain.Maya}.MAYA`
+  | `${Chain.Ethereum}.THOR`
+  | `${Chain.Ethereum}.vTHOR`
+  | `${Chain.Kujira}.USK`
+  | Chain;
 
 const getContractDecimals = async ({ chain, to }: { chain: EVMChain; to: string }) => {
   try {
     const { result } = await RequestClient.post<{ result: string }>(ChainToRPC[chain], {
-      headers: { accept: '*/*', 'cache-control': 'no-cache' },
+      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'],
+        jsonrpc: "2.0",
+        method: "eth_call",
+        params: [{ to: to.toLowerCase(), data: getDecimalMethodHex }, "latest"],
       }),
     });
 
-    return parseInt(BigInt(result).toString());
+    return Number.parseInt(BigInt(result || BaseDecimal[chain]).toString());
   } catch (error) {
     console.error(error);
     return BaseDecimal[chain];
   }
 };
 
-const getETHAssetDecimal = async (symbol: string) => {
+const getETHAssetDecimal = (symbol: string) => {
   if (symbol === Chain.Ethereum) return BaseDecimal.ETH;
-  const [, address] = symbol.split('-');
+  const [, address] = symbol.split("-");
 
-  return address?.startsWith('0x')
+  return address?.startsWith("0x")
     ? getContractDecimals({ chain: Chain.Ethereum, to: address })
     : BaseDecimal.ETH;
 };
 
-const getAVAXAssetDecimal = async (symbol: string) => {
-  const [, address] = symbol.split('-');
+const getAVAXAssetDecimal = (symbol: string) => {
+  const [, address] = symbol.split("-");
 
-  return address?.startsWith('0x')
+  return address?.startsWith("0x")
     ? getContractDecimals({ chain: Chain.Avalanche, to: address.toLowerCase() })
     : BaseDecimal.AVAX;
 };
 
-const getBSCAssetDecimal = async (symbol: string) => {
+const getBSCAssetDecimal = (symbol: string) => {
   if (symbol === Chain.BinanceSmartChain) return BaseDecimal.BSC;
 
   return BaseDecimal.BSC;
 };
 
-export const getDecimal = async ({ chain, symbol }: { chain: Chain; symbol: string }) => {
+export const getDecimal = ({ chain, symbol }: { chain: Chain; symbol: string }) => {
   switch (chain) {
     case Chain.Ethereum:
       return getETHAssetDecimal(symbol);
@@ -62,41 +70,26 @@ export const getDecimal = async ({ chain, symbol }: { chain: Chain; symbol: stri
   }
 };
 
-export const gasFeeMultiplier: Record<FeeOption, number> = {
-  [FeeOption.Average]: 1.2,
-  [FeeOption.Fast]: 1.5,
-  [FeeOption.Fastest]: 2,
-};
-
 export const isGasAsset = ({ chain, symbol }: { chain: Chain; symbol: string }) => {
   switch (chain) {
-    case Chain.Bitcoin:
-    case Chain.BitcoinCash:
-    case Chain.Litecoin:
-    case Chain.Dogecoin:
-    case Chain.Binance:
-    case Chain.Ethereum:
-    case Chain.Avalanche:
-      return symbol === chain;
-
     case Chain.Arbitrum:
     case Chain.Optimism:
-      return 'ETH' === symbol;
-
+      return symbol === "ETH";
     case Chain.Maya:
-      return symbol === 'CACAO';
-
+      return symbol === "CACAO";
     case Chain.Kujira:
-      return symbol === 'KUJI';
-
+      return symbol === "KUJI";
     case Chain.Cosmos:
-      return symbol === 'ATOM';
+      return symbol === "ATOM";
     case Chain.Polygon:
-      return symbol === 'MATIC';
+      return symbol === "MATIC";
     case Chain.BinanceSmartChain:
-      return symbol === 'BNB';
+      return symbol === "BNB";
     case Chain.THORChain:
-      return symbol === 'RUNE';
+      return symbol === "RUNE";
+
+    default:
+      return symbol === chain;
   }
 };
 
@@ -104,86 +97,118 @@ export const getCommonAssetInfo = (
   assetString: CommonAssetString,
 ): { identifier: string; decimal: number } => {
   switch (assetString) {
-    case 'ETH.THOR':
-      return { identifier: 'ETH.THOR-0xa5f2211b9b8170f694421f2046281775e8468044', decimal: 18 };
-    case 'ETH.vTHOR':
-      return { identifier: 'ETH.vTHOR-0x815c23eca83261b6ec689b60cc4a58b54bc24d8d', decimal: 18 };
+    case `${Chain.Ethereum}.THOR`:
+      return { identifier: "ETH.THOR-0xa5f2211b9b8170f694421f2046281775e8468044", decimal: 18 };
+    case `${Chain.Ethereum}.vTHOR`:
+      return { identifier: "ETH.vTHOR-0x815c23eca83261b6ec689b60cc4a58b54bc24d8d", decimal: 18 };
 
     case Chain.Cosmos:
-      return { identifier: 'GAIA.ATOM', decimal: BaseDecimal[assetString] };
+      return { identifier: "GAIA.ATOM", decimal: BaseDecimal[assetString] };
     case Chain.THORChain:
-      return { identifier: 'THOR.RUNE', decimal: BaseDecimal[assetString] };
+      return { identifier: "THOR.RUNE", decimal: BaseDecimal[assetString] };
     case Chain.BinanceSmartChain:
-      return { identifier: 'BSC.BNB', decimal: BaseDecimal[assetString] };
+      return { identifier: "BSC.BNB", decimal: BaseDecimal[assetString] };
     case Chain.Maya:
-      return { identifier: 'MAYA.CACAO', decimal: BaseDecimal.MAYA };
-    case 'MAYA.MAYA':
-      return { identifier: 'MAYA.MAYA', decimal: 4 };
+      return { identifier: "MAYA.CACAO", decimal: BaseDecimal.MAYA };
+    case `${Chain.Maya}.MAYA`:
+      return { identifier: "MAYA.MAYA", decimal: 4 };
 
-    case Chain.Kujira:
-    case Chain.Arbitrum:
-    case Chain.Optimism:
-    case Chain.BitcoinCash:
-    case Chain.Litecoin:
-    case Chain.Dogecoin:
-    case Chain.Binance:
-    case Chain.Avalanche:
-    case Chain.Polygon:
-    case Chain.Bitcoin:
-    case Chain.Ethereum:
+    case `${Chain.Kujira}.USK`:
+      return { identifier: `${Chain.Kujira}.USK`, decimal: 6 };
+
+    default:
       return { identifier: `${assetString}.${assetString}`, decimal: BaseDecimal[assetString] };
   }
 };
 
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: TODO: Refactor
 export const getAssetType = ({ chain, symbol }: { chain: Chain; symbol: string }) => {
-  if (symbol.includes('/')) return 'Synth';
+  if (symbol.includes("/")) return "Synth";
 
   switch (chain) {
-    case Chain.Bitcoin:
-    case Chain.BitcoinCash:
-    case Chain.Dogecoin:
-    case Chain.Litecoin:
-    case Chain.Maya:
-    case Chain.THORChain:
-      return 'Native';
-
     case Chain.Cosmos:
-      return symbol === 'ATOM' ? 'Native' : Chain.Cosmos;
+      return symbol === "ATOM" ? "Native" : Chain.Cosmos;
     case Chain.Kujira:
-      return symbol === Chain.Kujira ? 'Native' : Chain.Kujira;
+      return symbol === Chain.Kujira ? "Native" : Chain.Kujira;
     case Chain.Binance:
-      return symbol === Chain.Binance ? 'Native' : 'BEP2';
+      return symbol === Chain.Binance ? "Native" : "BEP2";
     case Chain.BinanceSmartChain:
-      return symbol === Chain.Binance ? 'Native' : 'BEP20';
+      return symbol === Chain.Binance ? "Native" : "BEP20";
     case Chain.Ethereum:
-      return symbol === Chain.Ethereum ? 'Native' : 'ERC20';
+      return symbol === Chain.Ethereum ? "Native" : "ERC20";
     case Chain.Avalanche:
-      return symbol === Chain.Avalanche ? 'Native' : Chain.Avalanche;
+      return symbol === Chain.Avalanche ? "Native" : Chain.Avalanche;
     case Chain.Polygon:
-      return symbol === Chain.Polygon ? 'Native' : 'POLYGON';
+      return symbol === Chain.Polygon ? "Native" : "POLYGON";
 
     case Chain.Arbitrum:
-      return [Chain.Ethereum, Chain.Arbitrum].includes(symbol as Chain) ? 'Native' : 'ARBITRUM';
+      return [Chain.Ethereum, Chain.Arbitrum].includes(symbol as Chain) ? "Native" : "ARBITRUM";
     case Chain.Optimism:
-      return [Chain.Ethereum, Chain.Optimism].includes(symbol as Chain) ? 'Native' : 'OPTIMISM';
+      return [Chain.Ethereum, Chain.Optimism].includes(symbol as Chain) ? "Native" : "OPTIMISM";
+
+    default:
+      return "Native";
   }
 };
 
 export const assetFromString = (assetString: string) => {
-  const [chain, ...symbolArray] = assetString.split('.') as [Chain, ...(string | undefined)[]];
-  const synth = assetString.includes('/');
-  const symbol = symbolArray.join('.');
-  const ticker = symbol?.split('-')?.[0];
+  const [chain, ...symbolArray] = assetString.split(".") as [Chain, ...(string | undefined)[]];
+  const synth = assetString.includes("/");
+  const symbol = symbolArray.join(".");
+  const ticker = symbol?.split("-")?.[0];
 
   return { chain, symbol, ticker, synth };
 };
 
 const potentialScamRegex = new RegExp(
   /(.)\1{6}|\.ORG|\.NET|\.FINANCE|\.COM|WWW|HTTP|\\\\|\/\/|[\s$%:[\]]/,
-  'gmi',
+  "gmi",
 );
-export const filterAssets = (assets: AssetValue[]) =>
-  assets.filter(
-    (asset) =>
-      !potentialScamRegex.test(asset.toString()) && !asset.toString().includes('undefined'),
-  );
+
+const evmAssetHasAddress = (assetString: string) => {
+  const [chain, symbol] = assetString.split(".") as [EVMChain, string];
+  if (!EVMChains.includes(chain as EVMChain)) return true;
+  const [, address] = symbol.split("-") as [string, string?];
+
+  return isGasAsset({ chain: chain as Chain, symbol }) || !!address;
+};
+
+export const filterAssets = (
+  tokens: {
+    value: string;
+    decimal: number;
+    chain: Chain;
+    symbol: string;
+  }[],
+) =>
+  tokens.filter(({ chain, value, symbol }) => {
+    const assetString = `${chain}.${symbol}`;
+
+    return (
+      !potentialScamRegex.test(assetString) && evmAssetHasAddress(assetString) && value !== "0"
+    );
+  });
+
+export async function findAssetBy(
+  params: { chain: EVMChain; contract: string } | { identifier: `${Chain}.${string}` },
+) {
+  const tokenPackages = await import("@swapkit/tokens");
+
+  for (const tokenList of Object.values(tokenPackages)) {
+    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/derivationPath.ts

@@ -0,0 +1,52 @@
+import {
+  Chain,
+  type DerivationPathArray,
+  type EVMChain,
+  EVMChains,
+  NetworkDerivationPath,
+} from "../types";
+
+type Params = {
+  index: number;
+  chain: Chain;
+  type?: "legacy" | "ledgerLive" | "nativeSegwitMiddleAccount" | "segwit";
+};
+
+const updatedLastIndex = (path: DerivationPathArray, index: number) => [
+  ...path.slice(0, path.length - 1),
+  index,
+];
+
+export function getDerivationPathFor({ chain, index, type }: Params) {
+  if (EVMChains.includes(chain as EVMChain)) {
+    if (type === "legacy") return [44, 60, 0, index];
+    if (type === "ledgerLive") return [44, 60, index, 0, 0];
+    return updatedLastIndex(NetworkDerivationPath[chain], index);
+  }
+
+  if ([Chain.Bitcoin, Chain.Litecoin].includes(chain)) {
+    const chainId = chain === Chain.Bitcoin ? 0 : 2;
+
+    if (type === "nativeSegwitMiddleAccount") return [84, chainId, index, 0, 0];
+    if (type === "segwit") return [49, chainId, 0, 0, index];
+    if (type === "legacy") return [44, chainId, 0, 0, index];
+    return updatedLastIndex(NetworkDerivationPath[chain], index);
+  }
+
+  return updatedLastIndex(NetworkDerivationPath[chain], index);
+}
+
+export function getWalletFormatFor(path: string) {
+  const [_, purpose, chainId] = path.split("/").map((p) => Number.parseInt(p, 10));
+
+  if (chainId === 145) "cashaddr";
+
+  switch (purpose) {
+    case 44:
+      return "legacy";
+    case 49:
+      return "p2sh";
+    default:
+      return "bech32";
+  }
+}

package/src/helpers/liquidity.ts

@@ -1,13 +1,12 @@
-import { BaseDecimal } from '@swapkit/types';
+import { SwapKitNumber } from "../index.ts";
+import { BaseDecimal } from "../types/chains.ts";
 
-import { SwapKitNumber } from '../index.ts';
-
-type ShareParams<T = {}> = T & {
+type ShareParams<T extends {}> = T & {
   liquidityUnits: string;
   poolUnits: string;
 };
 
-type PoolParams<T = {}> = T & {
+type PoolParams = {
   runeAmount: string;
   assetAmount: string;
   runeDepth: string;
@@ -25,11 +24,11 @@ type PoolParams<T = {}> = T & {
  *  share = (s * A * (2 * T^2 - 2 * T * s + s^2))/T^3
  *  (part1 * (part2 - part3 + part4)) / part5
  */
-export const getAsymmetricRuneShare = ({
+export function getAsymmetricRuneShare({
   liquidityUnits,
   poolUnits,
   runeDepth,
-}: ShareParams<{ runeDepth: string }>) => {
+}: ShareParams<{ runeDepth: string }>) {
   const s = toTCSwapKitNumber(liquidityUnits);
   const T = toTCSwapKitNumber(poolUnits);
   const A = toTCSwapKitNumber(runeDepth);
@@ -43,13 +42,13 @@ export const getAsymmetricRuneShare = ({
   const numerator = part1.mul(part2.sub(part3).add(part4));
 
   return numerator.div(part5);
-};
+}
 
-export const getAsymmetricAssetShare = ({
+export function getAsymmetricAssetShare({
   liquidityUnits,
   poolUnits,
   assetDepth,
-}: ShareParams<{ assetDepth: string }>) => {
+}: ShareParams<{ assetDepth: string }>) {
   const s = toTCSwapKitNumber(liquidityUnits);
   const T = toTCSwapKitNumber(poolUnits);
   const A = toTCSwapKitNumber(assetDepth);
@@ -62,28 +61,31 @@ export const getAsymmetricAssetShare = ({
   const part5 = T.mul(T).mul(T);
 
   return numerator.div(part5);
-};
+}
 
-export const getAsymmetricRuneWithdrawAmount = ({
+export function getAsymmetricRuneWithdrawAmount({
   percent,
   runeDepth,
   liquidityUnits,
   poolUnits,
-}: ShareParams<{ percent: number; runeDepth: string }>) =>
-  getAsymmetricRuneShare({ runeDepth, liquidityUnits, poolUnits }).mul(percent);
+}: ShareParams<{ percent: number; runeDepth: string }>) {
+  return getAsymmetricRuneShare({ runeDepth, liquidityUnits, poolUnits }).mul(percent);
+}
 
-export const getAsymmetricAssetWithdrawAmount = ({
+export function getAsymmetricAssetWithdrawAmount({
   percent,
   assetDepth,
   liquidityUnits,
   poolUnits,
-}: ShareParams<{ percent: number; assetDepth: string }>) =>
-  getAsymmetricAssetShare({ assetDepth, liquidityUnits, poolUnits }).mul(percent);
+}: ShareParams<{ percent: number; assetDepth: string }>) {
+  return getAsymmetricAssetShare({ assetDepth, liquidityUnits, poolUnits }).mul(percent);
+}
 
-const toTCSwapKitNumber = (value: string) =>
-  new SwapKitNumber({ value, decimal: BaseDecimal.THOR });
+function toTCSwapKitNumber(value: string) {
+  return SwapKitNumber.fromBigInt(BigInt(value), BaseDecimal.THOR);
+}
 
-export const getSymmetricPoolShare = ({
+export function getSymmetricPoolShare({
   liquidityUnits,
   poolUnits,
   runeDepth,
@@ -91,12 +93,14 @@ export const getSymmetricPoolShare = ({
 }: ShareParams<{
   runeDepth: string;
   assetDepth: string;
-}>) => ({
-  assetAmount: toTCSwapKitNumber(assetDepth).mul(liquidityUnits).div(poolUnits),
-  runeAmount: toTCSwapKitNumber(runeDepth).mul(liquidityUnits).div(poolUnits),
-});
-
-export const getSymmetricWithdraw = ({
+}>) {
+  return {
+    assetAmount: toTCSwapKitNumber(assetDepth).mul(liquidityUnits).div(poolUnits),
+    runeAmount: toTCSwapKitNumber(runeDepth).mul(liquidityUnits).div(poolUnits),
+  };
+}
+
+export function getSymmetricWithdraw({
   liquidityUnits,
   poolUnits,
   runeDepth,
@@ -106,14 +110,15 @@ export const getSymmetricWithdraw = ({
   runeDepth: string;
   assetDepth: string;
   percent: number;
-}>) =>
-  Object.fromEntries(
+}>) {
+  return Object.fromEntries(
     Object.entries(getSymmetricPoolShare({ liquidityUnits, poolUnits, runeDepth, assetDepth })).map(
       ([name, value]) => [name, value.mul(percent)],
     ),
   );
+}
 
-export const getEstimatedPoolShare = ({
+export function getEstimatedPoolShare({
   runeDepth,
   poolUnits,
   assetDepth,
@@ -125,12 +130,12 @@ export const getEstimatedPoolShare = ({
   assetAmount: string;
   runeDepth: string;
   assetDepth: string;
-}>) => {
-  const R = toTCSwapKitNumber(runeDepth);
-  const A = toTCSwapKitNumber(assetDepth);
-  const P = toTCSwapKitNumber(poolUnits);
-  const runeAddAmount = toTCSwapKitNumber(runeAmount);
-  const assetAddAmount = toTCSwapKitNumber(assetAmount);
+}>) {
+  const R = new SwapKitNumber({ value: runeDepth, decimal: 8 });
+  const A = new SwapKitNumber({ value: assetDepth, decimal: 8 });
+  const P = new SwapKitNumber({ value: poolUnits, decimal: 8 });
+  const runeAddAmount = new SwapKitNumber({ value: runeAmount, decimal: 8 });
+  const assetAddAmount = new SwapKitNumber({ value: assetAmount, decimal: 8 });
 
   // liquidityUnits = P * (r*A + a*R + 2*r*a) / (r*A + a*R + 2*R*A)
   const rA = runeAddAmount.mul(A);
@@ -142,22 +147,24 @@ export const getEstimatedPoolShare = ({
   const liquidityUnitsAfterAdd = numerator.div(denominator);
   const estimatedLiquidityUnits = toTCSwapKitNumber(liquidityUnits).add(liquidityUnitsAfterAdd);
 
-  if (liquidityUnitsAfterAdd.baseValueNumber === 0) {
-    return estimatedLiquidityUnits.div(P).baseValueNumber;
+  if (liquidityUnitsAfterAdd.getBaseValue("number") === 0) {
+    return estimatedLiquidityUnits.div(P).getBaseValue("number");
   }
 
   // get pool units after add
   const newPoolUnits = P.add(estimatedLiquidityUnits);
 
-  return estimatedLiquidityUnits.div(newPoolUnits).baseValueNumber;
-};
+  return estimatedLiquidityUnits.div(newPoolUnits).getBaseValue("number");
+}
 
-export const getLiquiditySlippage = ({
+export function getLiquiditySlippage({
   runeAmount,
   assetAmount,
   runeDepth,
   assetDepth,
-}: PoolParams) => {
+}: PoolParams) {
+  if (runeAmount === "0" || assetAmount === "0" || runeDepth === "0" || assetDepth === "0")
+    return 0;
   // formula: (t * R - T * r)/ (T*r + R*T)
   const R = toTCSwapKitNumber(runeDepth);
   const T = toTCSwapKitNumber(assetDepth);
@@ -168,5 +175,5 @@ export const getLiquiditySlippage = ({
   const denominator = T.mul(runeAddAmount).add(R.mul(T));
 
   // set absolute value of percent, no negative allowed
-  return Math.abs(numerator.div(denominator).baseValueNumber);
-};
+  return Math.abs(numerator.div(denominator).getBaseValue("number"));
+}

package/src/helpers/memo.ts

@@ -1,5 +1,5 @@
-import type { Chain } from '@swapkit/types';
-import { MemoType } from '@swapkit/types';
+import { Chain } from "../types/chains";
+import { MemoType } from "../types/sdk";
 
 export type ThornameRegisterParam = {
   name: string;
@@ -10,25 +10,14 @@ export type ThornameRegisterParam = {
   expiryBlock?: string;
 };
 
-const getShortenedSymbol = ({
-  symbol,
-  ticker,
-  chain,
-}: {
-  ticker: string;
-  symbol: string;
-  chain: string | Chain;
-}) => (chain === 'ETH' && ticker !== 'ETH' ? `${ticker}-${symbol.slice(-3)}` : symbol);
-
-type WithAddress<T = {}> = T & { address: string };
-type WithChain<T = {}> = T & { chain: Chain };
+type WithChain<T extends {}> = T & { chain: Chain };
 
 export type MemoOptions<T extends MemoType> = {
-  [MemoType.BOND]: WithAddress;
-  [MemoType.LEAVE]: WithAddress;
-  [MemoType.CLOSE_LOAN]: WithAddress<{ asset: string; minAmount?: string }>;
-  [MemoType.OPEN_LOAN]: WithAddress<{ asset: string; minAmount?: string }>;
-  [MemoType.UNBOND]: WithAddress<{ unbondAmount: number }>;
+  [MemoType.BOND]: { address: string };
+  [MemoType.LEAVE]: { address: string };
+  [MemoType.CLOSE_LOAN]: { address: string; asset: string; minAmount?: string };
+  [MemoType.OPEN_LOAN]: { address: string; asset: string; minAmount?: string };
+  [MemoType.UNBOND]: { address: string; unbondAmount: number };
   [MemoType.DEPOSIT]: WithChain<{ symbol: string; address?: string; singleSide?: boolean }>;
   [MemoType.WITHDRAW]: WithChain<{
     ticker: string;
@@ -37,7 +26,7 @@ export type MemoOptions<T extends MemoType> = {
     targetAssetString?: string;
     singleSide?: boolean;
   }>;
-  [MemoType.THORNAME_REGISTER]: Omit<ThornameRegisterParam, 'preferredAsset' | 'expiryBlock'>;
+  [MemoType.THORNAME_REGISTER]: Omit<ThornameRegisterParam, "preferredAsset" | "expiryBlock">;
 }[T];
 
 export const getMemoFor = <T extends MemoType>(memoType: T, options: MemoOptions<T>) => {
@@ -50,29 +39,43 @@ export const getMemoFor = <T extends MemoType>(memoType: T, options: MemoOptions
 
     case MemoType.UNBOND: {
       const { address, unbondAmount } = options as MemoOptions<MemoType.UNBOND>;
-      return `${memoType}:${address}:${unbondAmount * 10 ** 8}`;
+      return `${memoType}:${address}:${unbondAmount}`;
     }
 
     case MemoType.THORNAME_REGISTER: {
       const { name, chain, address, owner } = options as MemoOptions<MemoType.THORNAME_REGISTER>;
-      return `${memoType}:${name}:${chain}:${address}${owner ? `:${owner}` : ''}`;
+      return `${memoType}:${name}:${chain}:${address}${owner ? `:${owner}` : ""}`;
     }
 
     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}::t:0`
-        : `${memoType}:${chain}.${symbol}:${address || ''}:t:0`;
+        ? `${memoType}:${chain}/${symbol}`
+        : `${memoType}:${getPoolIdentifier(chain, symbol)}:${address || ""}`;
     }
 
     case MemoType.WITHDRAW: {
       const { chain, ticker, symbol, basisPoints, targetAssetString, singleSide } =
         options as MemoOptions<MemoType.WITHDRAW>;
 
-      const target = !singleSide && targetAssetString ? `:${targetAssetString}` : '';
-      const shortenedSymbol = getShortenedSymbol({ chain, symbol, ticker });
-      const assetDivider = singleSide ? '/' : '.';
+      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}`;
     }
@@ -85,6 +88,6 @@ export const getMemoFor = <T extends MemoType>(memoType: T, options: MemoOptions
     }
 
     default:
-      return '';
+      return "";
   }
 };