@pioneer-platform/helpers 4.2.0 → 4.3.0

package/.turbo/turbo-build.log

@@ -0,0 +1,2 @@
+
+$ tsc -p .

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @pioneer-platform/helpers
 
+## 4.3.0
+
+### Minor Changes
+
+- Automated minor version bump for all packages
+
+### Patch Changes
+
+- Updated dependencies
+  - @pioneer-platform/loggerdog@8.6.0
+
 ## 4.2.0
 
 ### Minor Changes

package/build.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+# Fast Bun build (replaces slow tsc)
+
+OUTDIR="${1:-lib}"
+ENTRY="${2:-src/index.ts}"
+
+# Clean output
+rm -rf "$OUTDIR"
+mkdir -p "$OUTDIR"
+
+# Build with Bun (10x faster than tsc)
+bun build "$ENTRY" \
+  --outdir "$OUTDIR" \
+  --target node \
+  --format cjs \
+  --sourcemap \
+  --minify
+
+# Generate TypeScript declarations
+bunx tsc --emitDeclarationOnly --outDir "$OUTDIR" --project .
+
+echo "✅ Built $OUTDIR"

package/lib/helpers/asset.d.ts

@@ -0,0 +1,36 @@
+import { Chain, FeeOption } from '@coinmasters/types';
+export type CommonAssetString = 'MAYA.MAYA' | 'ETH.THOR' | 'ETH.vTHOR' | Chain;
+export declare const getDecimal: ({ chain, symbol }: {
+    chain: Chain;
+    symbol: string;
+}) => Promise<number>;
+export declare const gasFeeMultiplier: Record<FeeOption, number>;
+export declare const isGasAsset: ({ chain, symbol }: {
+    chain: Chain;
+    symbol: string;
+}) => boolean | undefined;
+export declare const getCommonAssetInfo: (assetString: CommonAssetString) => {
+    identifier: string;
+    decimal: number;
+};
+export declare const getAssetType: ({ chain, symbol }: {
+    chain: Chain;
+    symbol: string;
+}) => Chain.Avalanche | Chain.Cosmos | Chain.Kujira | "Synth" | "Native" | "ERC20" | "POLYGON" | "ARBITRUM" | "OPTIMISM" | undefined;
+export declare const assetFromString: (assetString: string) => {
+    chain: Chain;
+    symbol: string;
+    ticker: string;
+    synth: boolean;
+};
+export declare const filterAssets: (tokens: {
+    value: string;
+    decimal: number;
+    chain: Chain;
+    symbol: string;
+}[]) => {
+    value: string;
+    decimal: number;
+    chain: Chain;
+    symbol: string;
+}[];

package/lib/helpers/asset.js

@@ -0,0 +1,208 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterAssets = exports.assetFromString = exports.getAssetType = exports.getCommonAssetInfo = exports.isGasAsset = exports.gasFeeMultiplier = exports.getDecimal = void 0;
+const types_1 = require("@coinmasters/types");
+const index_1 = require("../index");
+const getDecimalMethodHex = '0x313ce567';
+const getContractDecimals = (_a) => __awaiter(void 0, [_a], void 0, function* ({ chain, to }) {
+    try {
+        const { result } = yield index_1.RequestClient.post(types_1.ChainToRPC[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 parseInt(BigInt(result).toString());
+    }
+    catch (error) {
+        console.error(error);
+        // @ts-ignore
+        return types_1.BaseDecimal[chain];
+    }
+});
+const getETHAssetDecimal = (symbol) => __awaiter(void 0, void 0, void 0, function* () {
+    if (symbol === types_1.Chain.Ethereum)
+        return types_1.BaseDecimal.ETH;
+    const [, address] = symbol.split('-');
+    return (address === null || address === void 0 ? void 0 : address.startsWith('0x'))
+        ? getContractDecimals({ chain: types_1.Chain.Ethereum, to: address })
+        : types_1.BaseDecimal.ETH;
+});
+const getAVAXAssetDecimal = (symbol) => __awaiter(void 0, void 0, void 0, function* () {
+    const [, address] = symbol.split('-');
+    return (address === null || address === void 0 ? void 0 : address.startsWith('0x'))
+        ? getContractDecimals({ chain: types_1.Chain.Avalanche, to: address.toLowerCase() })
+        : types_1.BaseDecimal.AVAX;
+});
+const getBSCAssetDecimal = (symbol) => __awaiter(void 0, void 0, void 0, function* () {
+    if (symbol === types_1.Chain.BinanceSmartChain)
+        return types_1.BaseDecimal.BSC;
+    return types_1.BaseDecimal.BSC;
+});
+const getDecimal = (_a) => __awaiter(void 0, [_a], void 0, function* ({ chain, symbol }) {
+    switch (chain) {
+        case types_1.Chain.Ethereum:
+            return getETHAssetDecimal(symbol);
+        case types_1.Chain.Avalanche:
+            return getAVAXAssetDecimal(symbol);
+        case types_1.Chain.BinanceSmartChain:
+            return getBSCAssetDecimal(symbol);
+        default:
+            // @ts-ignore
+            return types_1.BaseDecimal[chain];
+    }
+});
+exports.getDecimal = getDecimal;
+exports.gasFeeMultiplier = {
+    [types_1.FeeOption.Average]: 1.2,
+    [types_1.FeeOption.Fast]: 1.5,
+    [types_1.FeeOption.Fastest]: 2,
+};
+const isGasAsset = ({ chain, symbol }) => {
+    switch (chain) {
+        case types_1.Chain.Bitcoin:
+        case types_1.Chain.BitcoinCash:
+        case types_1.Chain.Dash:
+        case types_1.Chain.Digibyte:
+        case types_1.Chain.Zcash:
+        case types_1.Chain.Ripple:
+        case types_1.Chain.Litecoin:
+        case types_1.Chain.Dogecoin:
+        case types_1.Chain.Ethereum:
+        case types_1.Chain.Avalanche:
+            return symbol === chain;
+        case types_1.Chain.Arbitrum:
+        case types_1.Chain.Optimism:
+        case types_1.Chain.Base:
+            return 'ETH' === symbol;
+        // @ts-ignore
+        case types_1.Chain.Mayachain:
+            return symbol === 'CACAO';
+        case types_1.Chain.Kujira:
+            return symbol === 'KUJI';
+        case types_1.Chain.Cosmos:
+            return symbol === 'ATOM';
+        case types_1.Chain.Polygon:
+            return symbol === 'MATIC';
+        case types_1.Chain.BinanceSmartChain:
+            return symbol === 'BNB';
+        case types_1.Chain.THORChain:
+            return symbol === 'RUNE';
+    }
+};
+exports.isGasAsset = isGasAsset;
+const getCommonAssetInfo = (assetString) => {
+    switch (assetString) {
+        case 'ETH.THOR':
+            return { identifier: 'ETH.THOR-0xa5f2211b9b8170f694421f2046281775e8468044', decimal: 18 };
+        case 'ETH.vTHOR':
+            return { identifier: 'ETH.vTHOR-0x815c23eca83261b6ec689b60cc4a58b54bc24d8d', decimal: 18 };
+        case types_1.Chain.Cosmos:
+            return { identifier: 'GAIA.ATOM', decimal: types_1.BaseDecimal[assetString] };
+        case types_1.Chain.THORChain:
+            return { identifier: 'THOR.RUNE', decimal: types_1.BaseDecimal[assetString] };
+        case types_1.Chain.BinanceSmartChain:
+            return { identifier: 'BSC.BNB', decimal: types_1.BaseDecimal[assetString] };
+        // @ts-ignore
+        case types_1.Chain.Mayachain:
+            return { identifier: 'MAYA.CACAO', decimal: types_1.BaseDecimal.MAYA };
+        case 'MAYA.MAYA':
+            return { identifier: 'MAYA.MAYA', decimal: 4 };
+        case types_1.Chain.Arbitrum:
+            return { identifier: 'ARB.ETH', decimal: 18 };
+        case types_1.Chain.Base:
+            return { identifier: 'BASE.ETH', decimal: 18 };
+        case types_1.Chain.Optimism:
+            return { identifier: 'OP.ETH', decimal: 18 };
+        case types_1.Chain.Avalanche:
+            return { identifier: 'AVAX.ETH', decimal: 18 };
+        case types_1.Chain.Ripple:
+        case types_1.Chain.Kujira:
+        case types_1.Chain.BitcoinCash:
+        case types_1.Chain.Zcash:
+        case types_1.Chain.Dash:
+        case types_1.Chain.Litecoin:
+        case types_1.Chain.Dogecoin:
+        case types_1.Chain.Polygon:
+        case types_1.Chain.Bitcoin:
+        case types_1.Chain.Ethereum:
+            return { identifier: `${assetString}.${assetString}`, decimal: types_1.BaseDecimal[assetString] };
+    }
+};
+exports.getCommonAssetInfo = getCommonAssetInfo;
+const getAssetType = ({ chain, symbol }) => {
+    if (symbol.includes('/'))
+        return 'Synth';
+    switch (chain) {
+        case types_1.Chain.Bitcoin:
+        case types_1.Chain.BitcoinCash:
+        case types_1.Chain.Dogecoin:
+        case types_1.Chain.Dash:
+        case types_1.Chain.Zcash:
+        case types_1.Chain.Litecoin:
+        // @ts-ignore
+        case types_1.Chain.Mayachain:
+        case types_1.Chain.THORChain:
+            return 'Native';
+        case types_1.Chain.Osmosis:
+            return 'Native';
+        case types_1.Chain.Cosmos:
+            return symbol === 'ATOM' ? 'Native' : types_1.Chain.Cosmos;
+        case types_1.Chain.Kujira:
+            return symbol === types_1.Chain.Kujira ? 'Native' : types_1.Chain.Kujira;
+        case types_1.Chain.BinanceSmartChain:
+        case types_1.Chain.Ethereum:
+            return symbol === types_1.Chain.Ethereum ? 'Native' : 'ERC20';
+        case types_1.Chain.Avalanche:
+            return symbol === types_1.Chain.Avalanche ? 'Native' : types_1.Chain.Avalanche;
+        case types_1.Chain.Polygon:
+            return symbol === types_1.Chain.Polygon ? 'Native' : 'POLYGON';
+        case types_1.Chain.Base:
+            return symbol === types_1.Chain.Ethereum ? 'Native' : 'ERC20';
+        case types_1.Chain.Arbitrum:
+            return [types_1.Chain.Ethereum, types_1.Chain.Arbitrum].includes(symbol) ? 'Native' : 'ARBITRUM';
+        case types_1.Chain.Optimism:
+            return [types_1.Chain.Ethereum, types_1.Chain.Optimism].includes(symbol) ? 'Native' : 'OPTIMISM';
+    }
+};
+exports.getAssetType = getAssetType;
+const assetFromString = (assetString) => {
+    var _a;
+    const [chain, ...symbolArray] = assetString.split('.');
+    const synth = assetString.includes('/');
+    const symbol = symbolArray.join('.');
+    const ticker = (_a = symbol === null || symbol === void 0 ? void 0 : symbol.split('-')) === null || _a === void 0 ? void 0 : _a[0];
+    return { chain, symbol, ticker, synth };
+};
+exports.assetFromString = assetFromString;
+const potentialScamRegex = new RegExp(/(.)\1{6}|\.ORG|\.NET|\.FINANCE|\.COM|WWW|HTTP|\\\\|\/\/|[\s$%:[\]]/, 'gmi');
+const evmAssetHasAddress = (assetString) => {
+    const [chain, symbol] = assetString.split('.');
+    if (!types_1.EVMChainList.includes(chain))
+        return true;
+    const [, address] = symbol.split('-');
+    return (0, exports.isGasAsset)({ chain: chain, symbol }) || !!address;
+};
+const filterAssets = (tokens) => tokens.filter((token) => {
+    const assetString = `${token.chain}.${token.symbol}`;
+    return (!potentialScamRegex.test(assetString) &&
+        evmAssetHasAddress(assetString) &&
+        token.value !== '0');
+});
+exports.filterAssets = filterAssets;

package/lib/helpers/liquidity.d.ts

@@ -0,0 +1,58 @@
+import { SwapKitNumber } from '../index';
+type ShareParams<T = {}> = T & {
+    liquidityUnits: string;
+    poolUnits: string;
+};
+type PoolParams<T = {}> = T & {
+    runeAmount: string;
+    assetAmount: string;
+    runeDepth: string;
+    assetDepth: string;
+};
+/**
+ *  Ref: https://gitlab.com/thorchain/thornode/-/issues/657
+ *  share = (s * A * (2 * T^2 - 2 * T * s + s^2))/T^3
+ *  s = stakeUnits for member (after factoring in withdrawBasisPoints)
+ *  T = totalPoolUnits for pool
+ *  A = assetDepth to be withdrawn
+ *
+ *  Formula:
+ *  share = (s * A * (2 * T^2 - 2 * T * s + s^2))/T^3
+ *  (part1 * (part2 - part3 + part4)) / part5
+ */
+export declare const getAsymmetricRuneShare: ({ liquidityUnits, poolUnits, runeDepth, }: ShareParams<{
+    runeDepth: string;
+}>) => SwapKitNumber;
+export declare const getAsymmetricAssetShare: ({ liquidityUnits, poolUnits, assetDepth, }: ShareParams<{
+    assetDepth: string;
+}>) => SwapKitNumber;
+export declare const getAsymmetricRuneWithdrawAmount: ({ percent, runeDepth, liquidityUnits, poolUnits, }: ShareParams<{
+    percent: number;
+    runeDepth: string;
+}>) => SwapKitNumber;
+export declare const getAsymmetricAssetWithdrawAmount: ({ percent, assetDepth, liquidityUnits, poolUnits, }: ShareParams<{
+    percent: number;
+    assetDepth: string;
+}>) => SwapKitNumber;
+export declare const getSymmetricPoolShare: ({ liquidityUnits, poolUnits, runeDepth, assetDepth, }: ShareParams<{
+    runeDepth: string;
+    assetDepth: string;
+}>) => {
+    assetAmount: SwapKitNumber;
+    runeAmount: SwapKitNumber;
+};
+export declare const getSymmetricWithdraw: ({ liquidityUnits, poolUnits, runeDepth, assetDepth, percent, }: ShareParams<{
+    runeDepth: string;
+    assetDepth: string;
+    percent: number;
+}>) => {
+    [k: string]: SwapKitNumber;
+};
+export declare const getEstimatedPoolShare: ({ runeDepth, poolUnits, assetDepth, liquidityUnits, runeAmount, assetAmount, }: ShareParams<{
+    runeAmount: string;
+    assetAmount: string;
+    runeDepth: string;
+    assetDepth: string;
+}>) => number;
+export declare const getLiquiditySlippage: ({ runeAmount, assetAmount, runeDepth, assetDepth, }: PoolParams) => number;
+export {};

package/lib/helpers/liquidity.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLiquiditySlippage = exports.getEstimatedPoolShare = exports.getSymmetricWithdraw = exports.getSymmetricPoolShare = exports.getAsymmetricAssetWithdrawAmount = exports.getAsymmetricRuneWithdrawAmount = exports.getAsymmetricAssetShare = exports.getAsymmetricRuneShare = void 0;
+const types_1 = require("@coinmasters/types");
+const index_1 = require("../index");
+/**
+ *  Ref: https://gitlab.com/thorchain/thornode/-/issues/657
+ *  share = (s * A * (2 * T^2 - 2 * T * s + s^2))/T^3
+ *  s = stakeUnits for member (after factoring in withdrawBasisPoints)
+ *  T = totalPoolUnits for pool
+ *  A = assetDepth to be withdrawn
+ *
+ *  Formula:
+ *  share = (s * A * (2 * T^2 - 2 * T * s + s^2))/T^3
+ *  (part1 * (part2 - part3 + part4)) / part5
+ */
+const getAsymmetricRuneShare = ({ liquidityUnits, poolUnits, runeDepth, }) => {
+    const s = toTCSwapKitNumber(liquidityUnits);
+    const T = toTCSwapKitNumber(poolUnits);
+    const A = toTCSwapKitNumber(runeDepth);
+    const part1 = s.mul(A);
+    const part2 = T.mul(T).mul(2);
+    const part3 = T.mul(s).mul(2);
+    const part4 = s.mul(s);
+    const part5 = T.mul(T).mul(T);
+    const numerator = part1.mul(part2.sub(part3).add(part4));
+    return numerator.div(part5);
+};
+exports.getAsymmetricRuneShare = getAsymmetricRuneShare;
+const getAsymmetricAssetShare = ({ liquidityUnits, poolUnits, assetDepth, }) => {
+    const s = toTCSwapKitNumber(liquidityUnits);
+    const T = toTCSwapKitNumber(poolUnits);
+    const A = toTCSwapKitNumber(assetDepth);
+    const part1 = s.mul(A);
+    const part2 = T.mul(T).mul(2);
+    const part3 = T.mul(s).mul(2);
+    const part4 = s.mul(s);
+    const numerator = part1.mul(part2.sub(part3).add(part4));
+    const part5 = T.mul(T).mul(T);
+    return numerator.div(part5);
+};
+exports.getAsymmetricAssetShare = getAsymmetricAssetShare;
+const getAsymmetricRuneWithdrawAmount = ({ percent, runeDepth, liquidityUnits, poolUnits, }) => (0, exports.getAsymmetricRuneShare)({ runeDepth, liquidityUnits, poolUnits }).mul(percent);
+exports.getAsymmetricRuneWithdrawAmount = getAsymmetricRuneWithdrawAmount;
+const getAsymmetricAssetWithdrawAmount = ({ percent, assetDepth, liquidityUnits, poolUnits, }) => (0, exports.getAsymmetricAssetShare)({ assetDepth, liquidityUnits, poolUnits }).mul(percent);
+exports.getAsymmetricAssetWithdrawAmount = getAsymmetricAssetWithdrawAmount;
+const toTCSwapKitNumber = (value) => index_1.SwapKitNumber.fromBigInt(BigInt(value), types_1.BaseDecimal.THOR);
+const getSymmetricPoolShare = ({ liquidityUnits, poolUnits, runeDepth, assetDepth, }) => ({
+    assetAmount: toTCSwapKitNumber(assetDepth).mul(liquidityUnits).div(poolUnits),
+    runeAmount: toTCSwapKitNumber(runeDepth).mul(liquidityUnits).div(poolUnits),
+});
+exports.getSymmetricPoolShare = getSymmetricPoolShare;
+const getSymmetricWithdraw = ({ liquidityUnits, poolUnits, runeDepth, assetDepth, percent, }) => Object.fromEntries(Object.entries((0, exports.getSymmetricPoolShare)({ liquidityUnits, poolUnits, runeDepth, assetDepth })).map(([name, value]) => [name, value.mul(percent)]));
+exports.getSymmetricWithdraw = getSymmetricWithdraw;
+const getEstimatedPoolShare = ({ runeDepth, poolUnits, assetDepth, liquidityUnits, runeAmount, assetAmount, }) => {
+    const R = new index_1.SwapKitNumber({ value: runeDepth, decimal: 8 });
+    const A = new index_1.SwapKitNumber({ value: assetDepth, decimal: 8 });
+    const P = new index_1.SwapKitNumber({ value: poolUnits, decimal: 8 });
+    const runeAddAmount = new index_1.SwapKitNumber({ value: runeAmount, decimal: 8 });
+    const assetAddAmount = new index_1.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);
+    const aR = assetAddAmount.mul(R);
+    const ra = runeAddAmount.mul(assetAddAmount);
+    const RA = R.mul(A);
+    const numerator = P.mul(rA.add(aR.add(ra.mul(2))));
+    const denominator = rA.add(aR.add(RA.mul(2)));
+    const liquidityUnitsAfterAdd = numerator.div(denominator);
+    const estimatedLiquidityUnits = toTCSwapKitNumber(liquidityUnits).add(liquidityUnitsAfterAdd);
+    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).getBaseValue('number');
+};
+exports.getEstimatedPoolShare = getEstimatedPoolShare;
+const getLiquiditySlippage = ({ runeAmount, assetAmount, runeDepth, assetDepth, }) => {
+    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);
+    const assetAddAmount = toTCSwapKitNumber(assetAmount);
+    const runeAddAmount = toTCSwapKitNumber(runeAmount);
+    const numerator = assetAddAmount.mul(R).sub(T.mul(runeAddAmount));
+    const denominator = T.mul(runeAddAmount).add(R.mul(T));
+    // set absolute value of percent, no negative allowed
+    return Math.abs(numerator.div(denominator).getBaseValue('number'));
+};
+exports.getLiquiditySlippage = getLiquiditySlippage;

package/lib/helpers/memo.d.ts

@@ -0,0 +1,46 @@
+import type { Chain } from '@coinmasters/types';
+import { MemoType } from '@coinmasters/types';
+export type ThornameRegisterParam = {
+    name: string;
+    chain: string;
+    address: string;
+    owner?: string;
+    preferredAsset?: string;
+    expiryBlock?: string;
+};
+type WithAddress<T = {}> = T & {
+    address: string;
+};
+type WithChain<T = {}> = 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.DEPOSIT]: WithChain<{
+        symbol: string;
+        address?: string;
+        singleSide?: boolean;
+    }>;
+    [MemoType.WITHDRAW]: WithChain<{
+        ticker: string;
+        symbol: string;
+        basisPoints: number;
+        targetAssetString?: string;
+        singleSide?: boolean;
+    }>;
+    [MemoType.THORNAME_REGISTER]: Omit<ThornameRegisterParam, 'preferredAsset' | 'expiryBlock'>;
+}[T];
+export declare const getMemoFor: <T extends MemoType>(memoType: T, options: MemoOptions<T>) => string;
+export {};

package/lib/helpers/memo.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMemoFor = void 0;
+const types_1 = require("@coinmasters/types");
+const getShortenedSymbol = ({ symbol, ticker, chain, }) => (chain === 'ETH' && ticker !== 'ETH' ? `${ticker}-${symbol.slice(-3)}` : symbol);
+const getMemoFor = (memoType, options) => {
+    switch (memoType) {
+        case types_1.MemoType.LEAVE:
+        case types_1.MemoType.BOND: {
+            const { address } = options;
+            return `${memoType}:${address}`;
+        }
+        case types_1.MemoType.UNBOND: {
+            const { address, unbondAmount } = options;
+            return `${memoType}:${address}:${unbondAmount * Math.pow(10, 8)}`;
+        }
+        case types_1.MemoType.THORNAME_REGISTER: {
+            const { name, chain, address, owner } = options;
+            return `${memoType}:${name}:${chain}:${address}${owner ? `:${owner}` : ''}`;
+        }
+        case types_1.MemoType.DEPOSIT: {
+            const { chain, symbol, address, singleSide } = options;
+            return singleSide
+                ? `${memoType}:${chain}/${symbol}::t:0`
+                : `${memoType}:${chain}.${symbol}:${address || ''}:t:0`;
+        }
+        case types_1.MemoType.WITHDRAW: {
+            const { chain, ticker, symbol, basisPoints, targetAssetString, singleSide } = options;
+            const target = !singleSide && targetAssetString ? `:${targetAssetString}` : '';
+            const shortenedSymbol = getShortenedSymbol({ chain, symbol, ticker });
+            const assetDivider = singleSide ? '/' : '.';
+            return `${memoType}:${chain}${assetDivider}${shortenedSymbol}:${basisPoints}${target}`;
+        }
+        case types_1.MemoType.OPEN_LOAN:
+        case types_1.MemoType.CLOSE_LOAN: {
+            const { asset, address } = options;
+            return `${memoType}:${asset}:${address}`; //:${minAmount ? `${minAmount}` : ''}:t:0`;
+        }
+        default:
+            return '';
+    }
+};
+exports.getMemoFor = getMemoFor;

package/lib/helpers/others.d.ts

@@ -0,0 +1,3 @@
+export declare const getTHORNameCost: (year: number) => number;
+export declare const validateTHORName: (name: string) => boolean;
+export declare const derivationPathToString: ([network, chainId, account, change, index]: number[]) => string;

package/lib/helpers/others.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.derivationPathToString = exports.validateTHORName = exports.getTHORNameCost = void 0;
+// 10 rune for register, 1 rune per year
+// MINIMUM_REGISTRATION_FEE = 11
+const getTHORNameCost = (year) => {
+    if (year < 0)
+        throw new Error('Invalid number of year');
+    return 10 + year;
+};
+exports.getTHORNameCost = getTHORNameCost;
+const validateTHORName = (name) => {
+    if (name.length > 30)
+        return false;
+    const regex = /^[a-zA-Z0-9+_-]+$/g;
+    return !!name.match(regex);
+};
+exports.validateTHORName = validateTHORName;
+const derivationPathToString = ([network, chainId, account, change, index]) => {
+    const shortPath = typeof index !== 'number';
+    return `${network}'/${chainId}'/${account}'/${change}${shortPath ? '' : `/${index}`}`;
+};
+exports.derivationPathToString = derivationPathToString;

package/lib/helpers/request.d.ts

@@ -0,0 +1,5 @@
+import { type Options } from 'ky';
+export declare const RequestClient: {
+    get: <T>(url: string | URL | Request, options?: Options) => Promise<T>;
+    post: <T>(url: string | URL | Request, options?: Options) => Promise<T>;
+};

package/lib/helpers/request.js

@@ -0,0 +1,79 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestClient = void 0;
+const headers = typeof window !== 'undefined'
+    ? {}
+    : {
+        Referrer: 'https://sk.thorswap.net',
+        Referer: 'https://sk.thorswap.net',
+    };
+// Define default options for the new ky instance
+const defaultOptions = {
+    headers: headers,
+    timeout: 30000, // Example: 10000 milliseconds = 10 seconds
+    retry: {
+        limit: 2, // Maximum number of retry attempts
+        methods: ['get', 'post', 'put', 'patch', 'head', 'delete'], // HTTP methods to retry
+        statusCodes: [408, 500, 502, 503, 504], // HTTP status codes to retry
+    },
+};
+// Function to dynamically import ky and create an instance
+function getKyInstance() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const ky = (yield Promise.resolve().then(() => __importStar(require('ky')))).default;
+        return ky.create(defaultOptions);
+    });
+}
+exports.RequestClient = {
+    get: (url, options) => __awaiter(void 0, void 0, void 0, function* () {
+        const kyInstance = yield getKyInstance();
+        return kyInstance.get(url, options).json();
+    }),
+    post: (url, options) => __awaiter(void 0, void 0, void 0, function* () {
+        const kyInstance = yield getKyInstance();
+        return kyInstance.post(url, options).json();
+    }),
+    // Implement other methods (put, delete, patch, head) as needed
+};

package/lib/helpers/validators.d.ts

@@ -0,0 +1 @@
+export declare const validateIdentifier: (identifier?: string) => boolean;

package/lib/helpers/validators.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateIdentifier = void 0;
+const types_1 = require("@coinmasters/types");
+const supportedChains = Object.values(types_1.Chain);
+const validateIdentifier = (identifier = '') => {
+    const uppercasedIdentifier = identifier.toUpperCase();
+    const [chain] = uppercasedIdentifier.split('.');
+    if (supportedChains.includes(chain))
+        return true;
+    const [synthChain] = uppercasedIdentifier.split('/');
+    if (supportedChains.includes(synthChain))
+        return true;
+    throw new Error(`Invalid identifier: ${identifier}. Expected format: <Chain>.<Ticker> or <Chain>.<Ticker>-<ContractAddress>`);
+};
+exports.validateIdentifier = validateIdentifier;