@shapeshiftoss/utils 1.0.3 → 1.0.5

package/dist/cjs/assetData/decodeAssetData.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeAssetData = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const lodash_1 = require("lodash");
+const assertUnreachable_1 = require("../assertUnreachable");
+const constants_1 = require("./constants");
+const getBaseAsset_1 = require("./getBaseAsset");
+const decodeAssetId = (encodedAssetId, assetIdPrefixes) => {
+    // Performance sensitive. `lastIndexOf` + `substring` faster than `split`
+    const colonIndex = encodedAssetId.lastIndexOf(':');
+    const prefixIdx = Number(encodedAssetId.substring(0, colonIndex));
+    const assetReference = encodedAssetId.substring(colonIndex + 1);
+    // Performance sensitive. String concatenation faster than template literal
+    return assetIdPrefixes[prefixIdx] + ':' + assetReference;
+};
+const decodeAssetData = (encodedAssetData, shouldAddNetworkName = false) => {
+    const { assetIdPrefixes, encodedAssetIds, encodedAssets } = encodedAssetData;
+    const sortedAssetIds = encodedAssetIds.map(encodedAssetId => decodeAssetId(encodedAssetId, assetIdPrefixes));
+    const assetData = encodedAssets.reduce((acc, encodedAsset, idx) => {
+        const assetId = sortedAssetIds[idx];
+        const { chainId } = (0, caip_1.fromAssetId)(assetId);
+        const baseAsset = (0, getBaseAsset_1.getBaseAsset)(chainId);
+        // Initialize with default values for the chain
+        const asset = Object.assign({
+            assetId,
+            chainId,
+            symbol: '',
+            name: '',
+            precision: 0,
+            color: '',
+            icon: undefined,
+            explorer: '',
+            explorerAddressLink: '',
+            explorerTxLink: '',
+            relatedAssetKey: null,
+        }, (0, lodash_1.pick)(baseAsset, ['explorer', 'explorerAddressLink', 'explorerTxLink']));
+        if (assetId === baseAsset?.assetId) {
+            asset.networkName = baseAsset.networkName;
+            asset.networkIcon = baseAsset.networkIcon;
+            asset.networkColor = baseAsset.networkColor;
+        }
+        // Apply each field's decoded value to the asset
+        constants_1.FIELDS.forEach((field, fieldIdx) => {
+            const value = encodedAsset[fieldIdx];
+            switch (field) {
+                case 'icon': {
+                    const iconOrIcons = value;
+                    if (iconOrIcons.length === 1) {
+                        asset.icon = iconOrIcons[0];
+                    }
+                    else if (iconOrIcons.length > 1) {
+                        asset.icons = iconOrIcons;
+                    }
+                    break;
+                }
+                case 'relatedAssetKey': {
+                    const assetIdx = value;
+                    const relatedAssetId = assetIdx === null ? null : sortedAssetIds[assetIdx];
+                    // if (relatedAssetId === undefined) throw Error()
+                    if (relatedAssetId &&
+                        relatedAssetId !== asset.assetId &&
+                        baseAsset.networkName &&
+                        shouldAddNetworkName) {
+                        asset.name = `${asset.name} on ${baseAsset.networkName}`;
+                    }
+                    asset.relatedAssetKey = relatedAssetId;
+                    asset.isPrimary = relatedAssetId === null || relatedAssetId === asset.assetId;
+                    asset.isChainSpecific = relatedAssetId === null;
+                    break;
+                }
+                case 'name':
+                    asset.name = value;
+                    break;
+                case 'precision':
+                    asset.precision = value;
+                    break;
+                case 'color':
+                    asset.color = value;
+                    break;
+                case 'symbol':
+                    asset.symbol = value;
+                    break;
+                case 'isPool': {
+                    const isPool = value;
+                    if (isPool) {
+                        asset.isPool = true;
+                    }
+                    break;
+                }
+                case 'assetIdx':
+                    // Skip assetIdx as we already have assetId
+                    break;
+                default:
+                    (0, assertUnreachable_1.assertUnreachable)(field);
+            }
+        });
+        acc[assetId] = asset;
+        return acc;
+    }, {});
+    return {
+        assetData,
+        sortedAssetIds,
+    };
+};
+exports.decodeAssetData = decodeAssetData;

package/dist/cjs/assetData/decodeRelatedAssetIndex.d.ts

@@ -0,0 +1,3 @@
+import type { AssetId } from '@shapeshiftoss/caip';
+import type { EncodedRelatedAssetIndex } from './types';
+export declare const decodeRelatedAssetIndex: (encodedRelatedAssetIndex: EncodedRelatedAssetIndex, sortedAssetIds: AssetId[]) => Record<AssetId, AssetId[]>;

package/dist/cjs/assetData/decodeRelatedAssetIndex.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeRelatedAssetIndex = void 0;
+const decodeRelatedAssetIndex = (encodedRelatedAssetIndex, sortedAssetIds) => {
+    const result = {};
+    for (let assetIdx = 0; assetIdx < sortedAssetIds.length; assetIdx++) {
+        const assetId = sortedAssetIds[assetIdx];
+        if (!encodedRelatedAssetIndex[assetIdx])
+            continue;
+        result[assetId] = encodedRelatedAssetIndex[assetIdx].map(innerAssetIdx => sortedAssetIds[innerAssetIdx]);
+    }
+    return result;
+};
+exports.decodeRelatedAssetIndex = decodeRelatedAssetIndex;

package/dist/cjs/assetData/encodeAssetData.d.ts

@@ -0,0 +1,4 @@
+import type { AssetId } from '@shapeshiftoss/caip';
+import type { AssetsById } from '@shapeshiftoss/types';
+import type { EncodedAssetData } from './types';
+export declare const encodeAssetData: (sortedAssetIds: AssetId[], assetsById: AssetsById) => EncodedAssetData;

package/dist/cjs/assetData/encodeAssetData.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeAssetData = void 0;
+const assertUnreachable_1 = require("../assertUnreachable");
+const constants_1 = require("./constants");
+const encodeAssetIds = (sortedAssetIds) => {
+    const assetIdPrefixes = [];
+    const encodedAssetIds = [];
+    for (const assetId of sortedAssetIds) {
+        // `indexOf` + `substring` faster than `split`
+        const colonIndex = assetId.lastIndexOf(':');
+        const prefix = assetId.substring(0, colonIndex);
+        const assetReference = assetId.substring(colonIndex + 1);
+        const prefixIdx = (() => {
+            const prefixIdx = assetIdPrefixes.indexOf(prefix);
+            if (prefixIdx !== -1) {
+                return prefixIdx;
+            }
+            else {
+                assetIdPrefixes.push(prefix);
+                return assetIdPrefixes.length - 1;
+            }
+        })();
+        encodedAssetIds.push(`${prefixIdx}:${assetReference}`);
+    }
+    return {
+        assetIdPrefixes,
+        encodedAssetIds,
+    };
+};
+const encodeField = (field, assetIdToAssetIdx, asset) => {
+    switch (field) {
+        case 'assetIdx':
+            return assetIdToAssetIdx[asset.assetId];
+        case 'name':
+            return asset.name;
+        case 'precision':
+            return asset.precision;
+        case 'color':
+            return asset.color;
+        case 'icon':
+            return (asset.icon ? [asset.icon] : asset.icons ?? []);
+        case 'symbol':
+            return asset.symbol;
+        case 'relatedAssetKey':
+            return (!asset.relatedAssetKey ? null : assetIdToAssetIdx[asset.relatedAssetKey]);
+        case 'isPool':
+            return (asset.isPool ? 1 : 0);
+        default:
+            return (0, assertUnreachable_1.assertUnreachable)(field);
+    }
+};
+const encodeAssetData = (sortedAssetIds, assetsById) => {
+    const { assetIdPrefixes, encodedAssetIds } = encodeAssetIds(sortedAssetIds);
+    const assetIdToAssetIdx = sortedAssetIds.reduce((acc, val, idx) => {
+        acc[val] = idx;
+        return acc;
+    }, {});
+    const encodedAssets = [];
+    for (let i = 0; i < encodedAssetIds.length; i++) {
+        const assetId = sortedAssetIds[i];
+        const asset = assetsById[assetId];
+        const record = constants_1.FIELDS.map(field => encodeField(field, assetIdToAssetIdx, asset));
+        encodedAssets.push(record);
+    }
+    return {
+        assetIdPrefixes,
+        encodedAssetIds,
+        encodedAssets,
+    };
+};
+exports.encodeAssetData = encodeAssetData;

package/dist/cjs/assetData/encodeRelatedAssetIndex.d.ts

@@ -0,0 +1,3 @@
+import type { AssetId } from '@shapeshiftoss/caip';
+import type { EncodedRelatedAssetIndex } from './types';
+export declare const encodeRelatedAssetIndex: (relatedAssetIndex: Record<AssetId, AssetId[]>, sortedAssetIds: AssetId[]) => EncodedRelatedAssetIndex;

package/dist/cjs/assetData/encodeRelatedAssetIndex.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeRelatedAssetIndex = void 0;
+const encodeRelatedAssetIndex = (relatedAssetIndex, sortedAssetIds) => {
+    const assetIdToAssetIdx = sortedAssetIds.reduce((acc, val, idx) => {
+        acc[val] = idx;
+        return acc;
+    }, {});
+    const result = {};
+    for (const [assetId, relatedAssets] of Object.entries(relatedAssetIndex)) {
+        if (!relatedAssets.length)
+            continue;
+        const assetIdx = assetIdToAssetIdx[assetId];
+        result[assetIdx] = relatedAssets.map(assetId => {
+            return assetIdToAssetIdx[assetId];
+        });
+    }
+    return result;
+};
+exports.encodeRelatedAssetIndex = encodeRelatedAssetIndex;

package/dist/cjs/assetData/getBaseAsset.d.ts

@@ -0,0 +1,3 @@
+import type { ChainId } from '@shapeshiftoss/caip';
+import type { Asset } from '@shapeshiftoss/types';
+export declare const getBaseAsset: (chainId: ChainId) => Readonly<Asset>;

package/dist/cjs/assetData/getBaseAsset.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBaseAsset = void 0;
+const types_1 = require("@shapeshiftoss/types");
+const assertUnreachable_1 = require("../assertUnreachable");
+const baseAssets_1 = require("./baseAssets");
+const getBaseAsset = (chainId) => {
+    const knownChainId = chainId;
+    switch (knownChainId) {
+        case types_1.KnownChainIds.EthereumMainnet:
+            return baseAssets_1.ethereum;
+        case types_1.KnownChainIds.AvalancheMainnet:
+            return baseAssets_1.avax;
+        case types_1.KnownChainIds.OptimismMainnet:
+            return baseAssets_1.optimism;
+        case types_1.KnownChainIds.BnbSmartChainMainnet:
+            return baseAssets_1.bnbsmartchain;
+        case types_1.KnownChainIds.PolygonMainnet:
+            return baseAssets_1.polygon;
+        case types_1.KnownChainIds.GnosisMainnet:
+            return baseAssets_1.gnosis;
+        case types_1.KnownChainIds.ArbitrumMainnet:
+            return baseAssets_1.arbitrum;
+        case types_1.KnownChainIds.ArbitrumNovaMainnet:
+            return baseAssets_1.arbitrumNova;
+        case types_1.KnownChainIds.BaseMainnet:
+            return baseAssets_1.base;
+        case types_1.KnownChainIds.SolanaMainnet:
+            return baseAssets_1.solana;
+        case types_1.KnownChainIds.SuiMainnet:
+            return baseAssets_1.sui;
+        case types_1.KnownChainIds.StarknetMainnet:
+            return baseAssets_1.starknet;
+        case types_1.KnownChainIds.BitcoinMainnet:
+            return baseAssets_1.bitcoin;
+        case types_1.KnownChainIds.BitcoinCashMainnet:
+            return baseAssets_1.bitcoincash;
+        case types_1.KnownChainIds.DogecoinMainnet:
+            return baseAssets_1.dogecoin;
+        case types_1.KnownChainIds.LitecoinMainnet:
+            return baseAssets_1.litecoin;
+        case types_1.KnownChainIds.CosmosMainnet:
+            return baseAssets_1.atom;
+        case types_1.KnownChainIds.ThorchainMainnet:
+            return baseAssets_1.thorchain;
+        case types_1.KnownChainIds.MayachainMainnet:
+            return baseAssets_1.mayachain;
+        case types_1.KnownChainIds.TronMainnet:
+            return baseAssets_1.tron;
+        case types_1.KnownChainIds.MonadMainnet:
+            return baseAssets_1.monad;
+        case types_1.KnownChainIds.HyperEvmMainnet:
+            return baseAssets_1.hyperevm;
+        case types_1.KnownChainIds.PlasmaMainnet:
+            return baseAssets_1.plasma;
+        case types_1.KnownChainIds.KatanaMainnet:
+            return baseAssets_1.katana;
+        case types_1.KnownChainIds.NearMainnet:
+            return baseAssets_1.near;
+        case types_1.KnownChainIds.ZcashMainnet:
+            return baseAssets_1.zcash;
+        default:
+            return (0, assertUnreachable_1.assertUnreachable)(knownChainId);
+    }
+};
+exports.getBaseAsset = getBaseAsset;

package/dist/cjs/assetData/index.d.ts

@@ -0,0 +1,7 @@
+export * from './encodeAssetData';
+export * from './decodeAssetData';
+export * from './baseAssets';
+export * from './getBaseAsset';
+export * from './encodeRelatedAssetIndex';
+export * from './decodeRelatedAssetIndex';
+export * from './types';

package/dist/cjs/assetData/index.js

@@ -0,0 +1,23 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./encodeAssetData"), exports);
+__exportStar(require("./decodeAssetData"), exports);
+__exportStar(require("./baseAssets"), exports);
+__exportStar(require("./getBaseAsset"), exports);
+__exportStar(require("./encodeRelatedAssetIndex"), exports);
+__exportStar(require("./decodeRelatedAssetIndex"), exports);
+__exportStar(require("./types"), exports);

package/dist/cjs/assetData/relatedAssetIndex.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/assetData/relatedAssetIndex.test.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const decodeRelatedAssetIndex_1 = require("./decodeRelatedAssetIndex");
+const encodeRelatedAssetIndex_1 = require("./encodeRelatedAssetIndex");
+// Order of these is deliberately shuffled to test sorting is preserved
+const mockSortedAssetIds = [
+    'eip155:1/erc20:0xeeecd285f60e802ecb6d8d8d37790c887f9a4b33',
+    'eip155:1/erc20:0xeeee2a2e650697d2a8e8bc990c2f3d04203be06f',
+    'eip155:1/erc20:0xeed3ae7b0f8b5b9bb8c035a9941382b1822671cd',
+    'eip155:1/erc20:0xf073bac22dab7faf4a3dd6c6189a70d54110525c',
+    'eip155:1/erc20:0xeee0fe52299f2de8e2ed5111cd521ab67dcf0faf',
+    'eip155:1/erc20:0xeeda34a377dd0ca676b9511ee1324974fa8d980d',
+    'bip122:000000000019d6689c085ae165831e93/slip44:0', // BTC
+];
+const mockRelatedAssetIndex = {
+    'eip155:1/erc20:0xeeee2a2e650697d2a8e8bc990c2f3d04203be06f': [
+        'eip155:1/erc20:0xeeee2a2e650697d2a8e8bc990c2f3d04203be06f',
+        'eip155:1/erc20:0xf073bac22dab7faf4a3dd6c6189a70d54110525c',
+    ],
+    'eip155:1/erc20:0xf073bac22dab7faf4a3dd6c6189a70d54110525c': [
+        'eip155:1/erc20:0xeeee2a2e650697d2a8e8bc990c2f3d04203be06f',
+        'eip155:1/erc20:0xf073bac22dab7faf4a3dd6c6189a70d54110525c',
+    ],
+};
+(0, vitest_1.describe)('relatedAssetIndex', () => {
+    (0, vitest_1.it)('can encode and decode related asset index as a complete round trip', () => {
+        const encodedRelatedAssetIndex = (0, encodeRelatedAssetIndex_1.encodeRelatedAssetIndex)(mockRelatedAssetIndex, mockSortedAssetIds);
+        const decodedRelatedAssetIndex = (0, decodeRelatedAssetIndex_1.decodeRelatedAssetIndex)(encodedRelatedAssetIndex, mockSortedAssetIds);
+        (0, vitest_1.expect)(decodedRelatedAssetIndex).toEqual(mockRelatedAssetIndex);
+    });
+});

package/dist/cjs/assetData/types.d.ts

@@ -0,0 +1,28 @@
+import type { FIELDS } from './constants';
+export type Field = (typeof FIELDS)[number];
+export type FieldToType = {
+    assetIdx: number;
+    name: string;
+    precision: number;
+    color: string;
+    icon: string[];
+    symbol: string;
+    relatedAssetKey: number | null;
+    isPool: 0 | 1;
+};
+export type EncodedAsset = [
+    FieldToType['assetIdx'],
+    FieldToType['name'],
+    FieldToType['precision'],
+    FieldToType['color'],
+    FieldToType['icon'],
+    FieldToType['symbol'],
+    FieldToType['relatedAssetKey'],
+    FieldToType['isPool']
+];
+export type EncodedAssetData = {
+    assetIdPrefixes: string[];
+    encodedAssetIds: string[];
+    encodedAssets: EncodedAsset[];
+};
+export type EncodedRelatedAssetIndex = Record<number, number[]>;

package/dist/cjs/assetData/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/baseUnits/baseUnits.d.ts

@@ -0,0 +1,5 @@
+import BigNumber from 'bignumber.js';
+import type { BN } from '../bignumber/bignumber';
+export declare const fromBaseUnit: (value: BigNumber.Value, precision: number, displayDecimals?: number) => string;
+export declare const toBaseUnit: (amount: BigNumber.Value | undefined, precision: number, roundingMode?: BigNumber.RoundingMode) => string;
+export declare const firstNonZeroDecimal: (number: BN) => string | undefined;

package/dist/cjs/baseUnits/baseUnits.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.firstNonZeroDecimal = exports.toBaseUnit = exports.fromBaseUnit = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const bignumber_1 = require("../bignumber/bignumber");
+// Converts from base unit to a precision/ish number
+// - If no displayDecimals are provided, it will use the full precision of the number being converted
+// - If displayDecimals are provided, it will use that precision, to return e.g a human, precision, or number stripped to any arbitrary decimal places
+// and use the ROUND_DOWN rounding mode
+const fromBaseUnit = (value, precision, displayDecimals) => {
+    const precisionNumber = (0, bignumber_1.bnOrZero)(value).div((0, bignumber_1.bn)(10).pow(precision));
+    if (typeof displayDecimals === 'number') {
+        return precisionNumber
+            .decimalPlaces(displayDecimals, bignumber_js_1.default.ROUND_DOWN)
+            .toFixed(displayDecimals);
+    }
+    return precisionNumber.toFixed();
+};
+exports.fromBaseUnit = fromBaseUnit;
+const toBaseUnit = (amount, precision, roundingMode) => {
+    return (0, bignumber_1.bnOrZero)(amount)
+        .times((0, bignumber_1.bn)(10).exponentiatedBy((0, bignumber_1.bnOrZero)(precision)))
+        .toFixed(0, roundingMode);
+};
+exports.toBaseUnit = toBaseUnit;
+const firstNonZeroDecimal = (number) => {
+    return number.toFixed(10).match(/^-?\d*\.?0*\d{0,2}/)?.[0];
+};
+exports.firstNonZeroDecimal = firstNonZeroDecimal;

package/dist/cjs/baseUnits/baseUnits.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/baseUnits/baseUnits.test.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const baseUnits_1 = require("./baseUnits");
+(0, vitest_1.describe)('@/lib/math', () => {
+    (0, vitest_1.describe)('fromBaseUnit', () => {
+        (0, vitest_1.it)('should correctly convert and round down with given displayDecimals', () => {
+            const result = (0, baseUnits_1.fromBaseUnit)(123456789, 4, 2);
+            (0, vitest_1.expect)(result).toBe('12345.67');
+        });
+        (0, vitest_1.it)('should correctly convert without displayDecimals and return full precision', () => {
+            const result = (0, baseUnits_1.fromBaseUnit)(123456789, 4);
+            (0, vitest_1.expect)(result).toBe('12345.6789');
+        });
+        (0, vitest_1.it)('should correctly convert and round down with given displayDecimals for another input', () => {
+            const result = (0, baseUnits_1.fromBaseUnit)(987654321, 6, 3);
+            (0, vitest_1.expect)(result).toBe('987.654');
+        });
+        (0, vitest_1.it)('should correctly convert without displayDecimals and return full precision for another input', () => {
+            const result = (0, baseUnits_1.fromBaseUnit)(987654321, 6);
+            (0, vitest_1.expect)(result).toBe('987.654321');
+        });
+        (0, vitest_1.it)('should correctly convert and round down with given displayDecimals for high precision input', () => {
+            const result = (0, baseUnits_1.fromBaseUnit)('182912819182912192', 18, 8);
+            (0, vitest_1.expect)(result).toBe('0.18291281');
+        });
+        (0, vitest_1.it)('should correctly convert without displayDecimals and return full precision for high precision input', () => {
+            const result = (0, baseUnits_1.fromBaseUnit)('182912819182912192', 18);
+            (0, vitest_1.expect)(result).toBe('0.182912819182912192');
+        });
+    });
+});

package/dist/cjs/basisPoints.d.ts

@@ -0,0 +1,23 @@
+import type { BigNumber } from './bignumber/bignumber';
+export declare const convertBasisPointsToDecimalPercentage: (basisPoints: BigNumber.Value) => BigNumber;
+export declare const convertDecimalPercentageToBasisPoints: (decimalPercentage: BigNumber.Value) => BigNumber;
+export declare const convertBasisPointsToPercentage: (basisPoints: BigNumber.Value) => BigNumber;
+export declare const convertPercentageToBasisPoints: (percentage: BigNumber.Value) => BigNumber;
+/**
+ * Subtracts basis point amount from a given value.
+ *
+ * @param value The value to subtract basis points from.
+ * @param basisPoints The number of basis points to subtract.
+ * @param roundingMode
+ * @returns The new number that is the input value minus the basis points of the value.
+ */
+export declare const subtractBasisPointAmount: (value: string, basisPoints: BigNumber.Value, roundingMode?: BigNumber.RoundingMode) => string;
+/**
+ * Adds basis point amount from a given value.
+ *
+ * @param value The value to subtract basis points from.
+ * @param basisPoints The number of basis points to subtract.
+ * @param roundingMode
+ * @returns The new number that is the input value minus the basis points of the value.
+ */
+export declare const addBasisPointAmount: (value: string, basisPoints: BigNumber.Value, roundingMode?: BigNumber.RoundingMode) => string;

package/dist/cjs/basisPoints.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addBasisPointAmount = exports.subtractBasisPointAmount = exports.convertPercentageToBasisPoints = exports.convertBasisPointsToPercentage = exports.convertDecimalPercentageToBasisPoints = exports.convertBasisPointsToDecimalPercentage = void 0;
+const bignumber_1 = require("./bignumber/bignumber");
+const convertBasisPointsToDecimalPercentage = (basisPoints) => (0, bignumber_1.bnOrZero)(basisPoints).div(10000);
+exports.convertBasisPointsToDecimalPercentage = convertBasisPointsToDecimalPercentage;
+const convertDecimalPercentageToBasisPoints = (decimalPercentage) => (0, bignumber_1.bnOrZero)(decimalPercentage).times(10000);
+exports.convertDecimalPercentageToBasisPoints = convertDecimalPercentageToBasisPoints;
+const convertBasisPointsToPercentage = (basisPoints) => (0, bignumber_1.bnOrZero)(basisPoints).div(100);
+exports.convertBasisPointsToPercentage = convertBasisPointsToPercentage;
+const convertPercentageToBasisPoints = (percentage) => (0, bignumber_1.bnOrZero)(percentage).times(100);
+exports.convertPercentageToBasisPoints = convertPercentageToBasisPoints;
+/**
+ * Subtracts basis point amount from a given value.
+ *
+ * @param value The value to subtract basis points from.
+ * @param basisPoints The number of basis points to subtract.
+ * @param roundingMode
+ * @returns The new number that is the input value minus the basis points of the value.
+ */
+const subtractBasisPointAmount = (value, basisPoints, roundingMode) => {
+    const bigNumValue = (0, bignumber_1.bn)(value);
+    // Basis point is 1/100th of a percent
+    const percentValue = (0, exports.convertBasisPointsToDecimalPercentage)(basisPoints);
+    const subtractValue = bigNumValue.times(percentValue);
+    // Subtract basis points from the original value
+    const resultValue = bigNumValue.minus(subtractValue);
+    return roundingMode !== undefined ? resultValue.toFixed(0, roundingMode) : resultValue.toFixed();
+};
+exports.subtractBasisPointAmount = subtractBasisPointAmount;
+/**
+ * Adds basis point amount from a given value.
+ *
+ * @param value The value to subtract basis points from.
+ * @param basisPoints The number of basis points to subtract.
+ * @param roundingMode
+ * @returns The new number that is the input value minus the basis points of the value.
+ */
+const addBasisPointAmount = (value, basisPoints, roundingMode) => {
+    const bigNumValue = (0, bignumber_1.bn)(value);
+    // Basis point is 1/100th of a percent
+    const percentValue = (0, exports.convertBasisPointsToDecimalPercentage)(basisPoints);
+    const addValue = bigNumValue.times(percentValue);
+    // Subtract basis points from the original value
+    const resultValue = bigNumValue.plus(addValue);
+    return roundingMode !== undefined ? resultValue.toFixed(0, roundingMode) : resultValue.toFixed();
+};
+exports.addBasisPointAmount = addBasisPointAmount;

package/dist/cjs/bignumber/bignumber.d.ts

@@ -0,0 +1,11 @@
+import BigNumber from 'bignumber.js';
+export { default as BigNumber } from 'bignumber.js';
+export type BN = BigNumber;
+export declare const bn: (n: BigNumber.Value, base?: number) => BN;
+export declare const bnOrZero: (n: BigNumber.Value | null | undefined) => BN;
+export declare const positiveOrZero: (n: BigNumber.Value | null | undefined) => BN;
+export declare const convertPrecision: ({ value, inputExponent, outputExponent, }: {
+    value: BigNumber.Value;
+    inputExponent?: number | undefined;
+    outputExponent?: number | undefined;
+}) => BigNumber;

package/dist/cjs/bignumber/bignumber.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertPrecision = exports.positiveOrZero = exports.bnOrZero = exports.bn = exports.BigNumber = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+var bignumber_js_2 = require("bignumber.js");
+Object.defineProperty(exports, "BigNumber", { enumerable: true, get: function () { return __importDefault(bignumber_js_2).default; } });
+const bn = (n, base = 10) => new bignumber_js_1.default(n, base);
+exports.bn = bn;
+const bnOrZero = (n) => {
+    const value = (0, exports.bn)(n || 0);
+    return value.isFinite() ? value : (0, exports.bn)(0);
+};
+exports.bnOrZero = bnOrZero;
+const positiveOrZero = (n) => {
+    const value = (0, exports.bn)(n || 0);
+    return value.isPositive() ? value : (0, exports.bn)(0);
+};
+exports.positiveOrZero = positiveOrZero;
+const convertPrecision = ({ value, inputExponent = 0, outputExponent = 0, }) => {
+    return (0, exports.bnOrZero)(value)
+        .dividedBy((0, exports.bn)(10).exponentiatedBy(inputExponent))
+        .multipliedBy((0, exports.bn)(10).exponentiatedBy(outputExponent));
+};
+exports.convertPrecision = convertPrecision;

package/dist/cjs/bignumber/bignumber.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/bignumber/bignumber.test.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const bignumber_1 = require("./bignumber");
+(0, vitest_1.describe)('bignumber', () => {
+    (0, vitest_1.describe)('bnOrZero', () => {
+        (0, vitest_1.it)('returns an instance of bignumber', () => {
+            const zero = (0, bignumber_1.bnOrZero)(0);
+            (0, vitest_1.expect)(zero).toBeInstanceOf(bignumber_1.BigNumber);
+            const one = (0, bignumber_1.bnOrZero)(1);
+            (0, vitest_1.expect)(one).toBeInstanceOf(bignumber_1.BigNumber);
+            const foo = (0, bignumber_1.bnOrZero)('foo');
+            (0, vitest_1.expect)(foo).toBeInstanceOf(bignumber_1.BigNumber);
+            (0, vitest_1.expect)(foo.toString()).toBe('0');
+            const empty = (0, bignumber_1.bnOrZero)('');
+            (0, vitest_1.expect)(empty).toBeInstanceOf(bignumber_1.BigNumber);
+            (0, vitest_1.expect)(empty.toString()).toBe('0');
+        });
+    });
+    (0, vitest_1.describe)('convertPrecision', () => {
+        (0, vitest_1.it)('can convert values for increased precision', () => {
+            const value = '1234';
+            const expectation = (0, bignumber_1.bn)('1234000');
+            const result = (0, bignumber_1.convertPrecision)({ value, inputExponent: 3, outputExponent: 6 });
+            (0, vitest_1.expect)(result).toEqual(expectation);
+        });
+        (0, vitest_1.it)('can convert values for decreased precision', () => {
+            const value = '1234000';
+            const expectation = (0, bignumber_1.bn)('1234');
+            const result = (0, bignumber_1.convertPrecision)({ value, inputExponent: 6, outputExponent: 3 });
+            (0, vitest_1.expect)(result).toEqual(expectation);
+        });
+        (0, vitest_1.it)('treats 0 as 0 when increasing precision', () => {
+            const value = '0';
+            const expectation = (0, bignumber_1.bn)('0');
+            const result = (0, bignumber_1.convertPrecision)({ value, inputExponent: 12, outputExponent: 18 });
+            (0, vitest_1.expect)(result).toEqual(expectation);
+        });
+        (0, vitest_1.it)('treats 0 as 0 when decreasing precision', () => {
+            const value = '0';
+            const expectation = (0, bignumber_1.bn)('0');
+            const result = (0, bignumber_1.convertPrecision)({ value, inputExponent: 18, outputExponent: 12 });
+            (0, vitest_1.expect)(result).toEqual(expectation);
+        });
+        (0, vitest_1.it)('does not remove decimals with rounding', () => {
+            const value = '1234567';
+            const expectation = (0, bignumber_1.bn)('1234.567');
+            const result = (0, bignumber_1.convertPrecision)({ value, inputExponent: 6, outputExponent: 3 });
+            (0, vitest_1.expect)(result).toEqual(expectation);
+        });
+    });
+});