@pioneer-platform/helpers 0.0.0 → 0.0.2

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<any>;
+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" | "BEP2" | "BEP20" | "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,270 @@
+"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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterAssets = exports.assetFromString = exports.getAssetType = exports.getCommonAssetInfo = exports.isGasAsset = exports.gasFeeMultiplier = exports.getDecimal = void 0;
+var types_1 = require("@coinmasters/types");
+var index_1 = require("../index");
+var getDecimalMethodHex = '0x313ce567';
+var getContractDecimals = function (_a) {
+    var chain = _a.chain, to = _a.to;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var result, error_1;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 2, , 3]);
+                    return [4 /*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'],
+                            }),
+                        })];
+                case 1:
+                    result = (_b.sent()).result;
+                    return [2 /*return*/, parseInt(BigInt(result).toString())];
+                case 2:
+                    error_1 = _b.sent();
+                    console.error(error_1);
+                    // @ts-ignore
+                    return [2 /*return*/, types_1.BaseDecimal[chain]];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+};
+var getETHAssetDecimal = function (symbol) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, address;
+    return __generator(this, function (_b) {
+        if (symbol === types_1.Chain.Ethereum)
+            return [2 /*return*/, types_1.BaseDecimal.ETH];
+        _a = symbol.split('-'), address = _a[1];
+        return [2 /*return*/, (address === null || address === void 0 ? void 0 : address.startsWith('0x'))
+                ? getContractDecimals({ chain: types_1.Chain.Ethereum, to: address })
+                : types_1.BaseDecimal.ETH];
+    });
+}); };
+var getAVAXAssetDecimal = function (symbol) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, address;
+    return __generator(this, function (_b) {
+        _a = symbol.split('-'), address = _a[1];
+        return [2 /*return*/, (address === null || address === void 0 ? void 0 : address.startsWith('0x'))
+                ? getContractDecimals({ chain: types_1.Chain.Avalanche, to: address.toLowerCase() })
+                : types_1.BaseDecimal.AVAX];
+    });
+}); };
+var getBSCAssetDecimal = function (symbol) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        if (symbol === types_1.Chain.BinanceSmartChain)
+            return [2 /*return*/, types_1.BaseDecimal.BSC];
+        return [2 /*return*/, types_1.BaseDecimal.BSC];
+    });
+}); };
+var getDecimal = function (_a) {
+    var chain = _a.chain, symbol = _a.symbol;
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_b) {
+            switch (chain) {
+                case types_1.Chain.Ethereum:
+                    return [2 /*return*/, getETHAssetDecimal(symbol)];
+                case types_1.Chain.Avalanche:
+                    return [2 /*return*/, getAVAXAssetDecimal(symbol)];
+                case types_1.Chain.BinanceSmartChain:
+                    return [2 /*return*/, getBSCAssetDecimal(symbol)];
+                default:
+                    // @ts-ignore
+                    return [2 /*return*/, types_1.BaseDecimal[chain]];
+            }
+            return [2 /*return*/];
+        });
+    });
+};
+exports.getDecimal = getDecimal;
+exports.gasFeeMultiplier = (_a = {},
+    _a[types_1.FeeOption.Average] = 1.2,
+    _a[types_1.FeeOption.Fast] = 1.5,
+    _a[types_1.FeeOption.Fastest] = 2,
+    _a);
+var isGasAsset = function (_a) {
+    var chain = _a.chain, symbol = _a.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.Binance:
+        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;
+var getCommonAssetInfo = function (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.Binance:
+        case types_1.Chain.Polygon:
+        case types_1.Chain.Bitcoin:
+        case types_1.Chain.Ethereum:
+            return { identifier: "".concat(assetString, ".").concat(assetString), decimal: types_1.BaseDecimal[assetString] };
+    }
+};
+exports.getCommonAssetInfo = getCommonAssetInfo;
+var getAssetType = function (_a) {
+    var chain = _a.chain, symbol = _a.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.Binance:
+            return symbol === types_1.Chain.Binance ? 'Native' : 'BEP2';
+        case types_1.Chain.BinanceSmartChain:
+            return symbol === types_1.Chain.Binance ? 'Native' : 'BEP20';
+        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;
+var assetFromString = function (assetString) {
+    var _a;
+    var _b = assetString.split('.'), chain = _b[0], symbolArray = _b.slice(1);
+    var synth = assetString.includes('/');
+    var symbol = symbolArray.join('.');
+    var ticker = (_a = symbol === null || symbol === void 0 ? void 0 : symbol.split('-')) === null || _a === void 0 ? void 0 : _a[0];
+    return { chain: chain, symbol: symbol, ticker: ticker, synth: synth };
+};
+exports.assetFromString = assetFromString;
+var potentialScamRegex = new RegExp(/(.)\1{6}|\.ORG|\.NET|\.FINANCE|\.COM|WWW|HTTP|\\\\|\/\/|[\s$%:[\]]/, 'gmi');
+var evmAssetHasAddress = function (assetString) {
+    var _a = assetString.split('.'), chain = _a[0], symbol = _a[1];
+    if (!types_1.EVMChainList.includes(chain))
+        return true;
+    var _b = symbol.split('-'), address = _b[1];
+    return (0, exports.isGasAsset)({ chain: chain, symbol: symbol }) || !!address;
+};
+var filterAssets = function (tokens) {
+    return tokens.filter(function (token) {
+        var assetString = "".concat(token.chain, ".").concat(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,112 @@
+"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;
+var types_1 = require("@coinmasters/types");
+var 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
+ */
+var getAsymmetricRuneShare = function (_a) {
+    var liquidityUnits = _a.liquidityUnits, poolUnits = _a.poolUnits, runeDepth = _a.runeDepth;
+    var s = toTCSwapKitNumber(liquidityUnits);
+    var T = toTCSwapKitNumber(poolUnits);
+    var A = toTCSwapKitNumber(runeDepth);
+    var part1 = s.mul(A);
+    var part2 = T.mul(T).mul(2);
+    var part3 = T.mul(s).mul(2);
+    var part4 = s.mul(s);
+    var part5 = T.mul(T).mul(T);
+    var numerator = part1.mul(part2.sub(part3).add(part4));
+    return numerator.div(part5);
+};
+exports.getAsymmetricRuneShare = getAsymmetricRuneShare;
+var getAsymmetricAssetShare = function (_a) {
+    var liquidityUnits = _a.liquidityUnits, poolUnits = _a.poolUnits, assetDepth = _a.assetDepth;
+    var s = toTCSwapKitNumber(liquidityUnits);
+    var T = toTCSwapKitNumber(poolUnits);
+    var A = toTCSwapKitNumber(assetDepth);
+    var part1 = s.mul(A);
+    var part2 = T.mul(T).mul(2);
+    var part3 = T.mul(s).mul(2);
+    var part4 = s.mul(s);
+    var numerator = part1.mul(part2.sub(part3).add(part4));
+    var part5 = T.mul(T).mul(T);
+    return numerator.div(part5);
+};
+exports.getAsymmetricAssetShare = getAsymmetricAssetShare;
+var getAsymmetricRuneWithdrawAmount = function (_a) {
+    var percent = _a.percent, runeDepth = _a.runeDepth, liquidityUnits = _a.liquidityUnits, poolUnits = _a.poolUnits;
+    return (0, exports.getAsymmetricRuneShare)({ runeDepth: runeDepth, liquidityUnits: liquidityUnits, poolUnits: poolUnits }).mul(percent);
+};
+exports.getAsymmetricRuneWithdrawAmount = getAsymmetricRuneWithdrawAmount;
+var getAsymmetricAssetWithdrawAmount = function (_a) {
+    var percent = _a.percent, assetDepth = _a.assetDepth, liquidityUnits = _a.liquidityUnits, poolUnits = _a.poolUnits;
+    return (0, exports.getAsymmetricAssetShare)({ assetDepth: assetDepth, liquidityUnits: liquidityUnits, poolUnits: poolUnits }).mul(percent);
+};
+exports.getAsymmetricAssetWithdrawAmount = getAsymmetricAssetWithdrawAmount;
+var toTCSwapKitNumber = function (value) {
+    return index_1.SwapKitNumber.fromBigInt(BigInt(value), types_1.BaseDecimal.THOR);
+};
+var getSymmetricPoolShare = function (_a) {
+    var liquidityUnits = _a.liquidityUnits, poolUnits = _a.poolUnits, runeDepth = _a.runeDepth, assetDepth = _a.assetDepth;
+    return ({
+        assetAmount: toTCSwapKitNumber(assetDepth).mul(liquidityUnits).div(poolUnits),
+        runeAmount: toTCSwapKitNumber(runeDepth).mul(liquidityUnits).div(poolUnits),
+    });
+};
+exports.getSymmetricPoolShare = getSymmetricPoolShare;
+var getSymmetricWithdraw = function (_a) {
+    var liquidityUnits = _a.liquidityUnits, poolUnits = _a.poolUnits, runeDepth = _a.runeDepth, assetDepth = _a.assetDepth, percent = _a.percent;
+    return Object.fromEntries(Object.entries((0, exports.getSymmetricPoolShare)({ liquidityUnits: liquidityUnits, poolUnits: poolUnits, runeDepth: runeDepth, assetDepth: assetDepth })).map(function (_a) {
+        var name = _a[0], value = _a[1];
+        return [name, value.mul(percent)];
+    }));
+};
+exports.getSymmetricWithdraw = getSymmetricWithdraw;
+var getEstimatedPoolShare = function (_a) {
+    var runeDepth = _a.runeDepth, poolUnits = _a.poolUnits, assetDepth = _a.assetDepth, liquidityUnits = _a.liquidityUnits, runeAmount = _a.runeAmount, assetAmount = _a.assetAmount;
+    var R = new index_1.SwapKitNumber({ value: runeDepth, decimal: 8 });
+    var A = new index_1.SwapKitNumber({ value: assetDepth, decimal: 8 });
+    var P = new index_1.SwapKitNumber({ value: poolUnits, decimal: 8 });
+    var runeAddAmount = new index_1.SwapKitNumber({ value: runeAmount, decimal: 8 });
+    var 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)
+    var rA = runeAddAmount.mul(A);
+    var aR = assetAddAmount.mul(R);
+    var ra = runeAddAmount.mul(assetAddAmount);
+    var RA = R.mul(A);
+    var numerator = P.mul(rA.add(aR.add(ra.mul(2))));
+    var denominator = rA.add(aR.add(RA.mul(2)));
+    var liquidityUnitsAfterAdd = numerator.div(denominator);
+    var estimatedLiquidityUnits = toTCSwapKitNumber(liquidityUnits).add(liquidityUnitsAfterAdd);
+    if (liquidityUnitsAfterAdd.getBaseValue('number') === 0) {
+        return estimatedLiquidityUnits.div(P).getBaseValue('number');
+    }
+    // get pool units after add
+    var newPoolUnits = P.add(estimatedLiquidityUnits);
+    return estimatedLiquidityUnits.div(newPoolUnits).getBaseValue('number');
+};
+exports.getEstimatedPoolShare = getEstimatedPoolShare;
+var getLiquiditySlippage = function (_a) {
+    var runeAmount = _a.runeAmount, assetAmount = _a.assetAmount, runeDepth = _a.runeDepth, assetDepth = _a.assetDepth;
+    if (runeAmount === '0' || assetAmount === '0' || runeDepth === '0' || assetDepth === '0')
+        return 0;
+    // formula: (t * R - T * r)/ (T*r + R*T)
+    var R = toTCSwapKitNumber(runeDepth);
+    var T = toTCSwapKitNumber(assetDepth);
+    var assetAddAmount = toTCSwapKitNumber(assetAmount);
+    var runeAddAmount = toTCSwapKitNumber(runeAmount);
+    var numerator = assetAddAmount.mul(R).sub(T.mul(runeAddAmount));
+    var 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,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMemoFor = void 0;
+var types_1 = require("@coinmasters/types");
+var getShortenedSymbol = function (_a) {
+    var symbol = _a.symbol, ticker = _a.ticker, chain = _a.chain;
+    return (chain === 'ETH' && ticker !== 'ETH' ? "".concat(ticker, "-").concat(symbol.slice(-3)) : symbol);
+};
+var getMemoFor = function (memoType, options) {
+    switch (memoType) {
+        case types_1.MemoType.LEAVE:
+        case types_1.MemoType.BOND: {
+            var address = options.address;
+            return "".concat(memoType, ":").concat(address);
+        }
+        case types_1.MemoType.UNBOND: {
+            var _a = options, address = _a.address, unbondAmount = _a.unbondAmount;
+            return "".concat(memoType, ":").concat(address, ":").concat(unbondAmount * Math.pow(10, 8));
+        }
+        case types_1.MemoType.THORNAME_REGISTER: {
+            var _b = options, name_1 = _b.name, chain = _b.chain, address = _b.address, owner = _b.owner;
+            return "".concat(memoType, ":").concat(name_1, ":").concat(chain, ":").concat(address).concat(owner ? ":".concat(owner) : '');
+        }
+        case types_1.MemoType.DEPOSIT: {
+            var _c = options, chain = _c.chain, symbol = _c.symbol, address = _c.address, singleSide = _c.singleSide;
+            return singleSide
+                ? "".concat(memoType, ":").concat(chain, "/").concat(symbol, "::t:0")
+                : "".concat(memoType, ":").concat(chain, ".").concat(symbol, ":").concat(address || '', ":t:0");
+        }
+        case types_1.MemoType.WITHDRAW: {
+            var _d = options, chain = _d.chain, ticker = _d.ticker, symbol = _d.symbol, basisPoints = _d.basisPoints, targetAssetString = _d.targetAssetString, singleSide = _d.singleSide;
+            var target = !singleSide && targetAssetString ? ":".concat(targetAssetString) : '';
+            var shortenedSymbol = getShortenedSymbol({ chain: chain, symbol: symbol, ticker: ticker });
+            var assetDivider = singleSide ? '/' : '.';
+            return "".concat(memoType, ":").concat(chain).concat(assetDivider).concat(shortenedSymbol, ":").concat(basisPoints).concat(target);
+        }
+        case types_1.MemoType.OPEN_LOAN:
+        case types_1.MemoType.CLOSE_LOAN: {
+            var _e = options, asset = _e.asset, address = _e.address;
+            return "".concat(memoType, ":").concat(asset, ":").concat(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,24 @@
+"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
+var getTHORNameCost = function (year) {
+    if (year < 0)
+        throw new Error('Invalid number of year');
+    return 10 + year;
+};
+exports.getTHORNameCost = getTHORNameCost;
+var validateTHORName = function (name) {
+    if (name.length > 30)
+        return false;
+    var regex = /^[a-zA-Z0-9+_-]+$/g;
+    return !!name.match(regex);
+};
+exports.validateTHORName = validateTHORName;
+var derivationPathToString = function (_a) {
+    var network = _a[0], chainId = _a[1], account = _a[2], change = _a[3], index = _a[4];
+    var shortPath = typeof index !== 'number';
+    return "".concat(network, "'/").concat(chainId, "'/").concat(account, "'/").concat(change).concat(shortPath ? '' : "/".concat(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_1>(url: string | URL | Request, options?: Options) => Promise<T_1>;
+};