@shapeshiftoss/utils 1.0.0

package/dist/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/assetData/getBaseAsset.js

@@ -0,0 +1,44 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+import { assertUnreachable } from '../assertUnreachable';
+import { arbitrum, arbitrumNova, atom, avax, base, bitcoin, bitcoincash, bnbsmartchain, dogecoin, ethereum, gnosis, litecoin, mayachain, optimism, polygon, solana, thorchain, } from './baseAssets';
+export const getBaseAsset = (chainId) => {
+    const knownChainId = chainId;
+    switch (knownChainId) {
+        case KnownChainIds.EthereumMainnet:
+            return ethereum;
+        case KnownChainIds.AvalancheMainnet:
+            return avax;
+        case KnownChainIds.OptimismMainnet:
+            return optimism;
+        case KnownChainIds.BnbSmartChainMainnet:
+            return bnbsmartchain;
+        case KnownChainIds.PolygonMainnet:
+            return polygon;
+        case KnownChainIds.GnosisMainnet:
+            return gnosis;
+        case KnownChainIds.ArbitrumMainnet:
+            return arbitrum;
+        case KnownChainIds.ArbitrumNovaMainnet:
+            return arbitrumNova;
+        case KnownChainIds.BaseMainnet:
+            return base;
+        case KnownChainIds.SolanaMainnet:
+            return solana;
+        case KnownChainIds.BitcoinMainnet:
+            return bitcoin;
+        case KnownChainIds.BitcoinCashMainnet:
+            return bitcoincash;
+        case KnownChainIds.DogecoinMainnet:
+            return dogecoin;
+        case KnownChainIds.LitecoinMainnet:
+            return litecoin;
+        case KnownChainIds.CosmosMainnet:
+            return atom;
+        case KnownChainIds.ThorchainMainnet:
+            return thorchain;
+        case KnownChainIds.MayachainMainnet:
+            return mayachain;
+        default:
+            return assertUnreachable(knownChainId);
+    }
+};

package/dist/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/assetData/index.js

@@ -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/assetData/relatedAssetIndex.test.d.ts

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

package/dist/assetData/relatedAssetIndex.test.js

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { decodeRelatedAssetIndex } from './decodeRelatedAssetIndex';
+import { encodeRelatedAssetIndex } from './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',
+    ],
+};
+describe('relatedAssetIndex', () => {
+    it('can encode and decode related asset index as a complete round trip', () => {
+        const encodedRelatedAssetIndex = encodeRelatedAssetIndex(mockRelatedAssetIndex, mockSortedAssetIds);
+        const decodedRelatedAssetIndex = decodeRelatedAssetIndex(encodedRelatedAssetIndex, mockSortedAssetIds);
+        expect(decodedRelatedAssetIndex).toEqual(mockRelatedAssetIndex);
+    });
+});

package/dist/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/assetData/types.js

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

package/dist/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/baseUnits/baseUnits.js

@@ -0,0 +1,23 @@
+import BigNumber from 'bignumber.js';
+import { bn, bnOrZero } from '../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
+export const fromBaseUnit = (value, precision, displayDecimals) => {
+    const precisionNumber = bnOrZero(value).div(bn(10).pow(precision));
+    if (typeof displayDecimals === 'number') {
+        return precisionNumber
+            .decimalPlaces(displayDecimals, BigNumber.ROUND_DOWN)
+            .toFixed(displayDecimals);
+    }
+    return precisionNumber.toFixed();
+};
+export const toBaseUnit = (amount, precision, roundingMode) => {
+    return bnOrZero(amount)
+        .times(bn(10).exponentiatedBy(bnOrZero(precision)))
+        .toFixed(0, roundingMode);
+};
+export const firstNonZeroDecimal = (number) => {
+    return number.toFixed(10).match(/^-?\d*\.?0*\d{0,2}/)?.[0];
+};

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

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

package/dist/baseUnits/baseUnits.test.js

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { fromBaseUnit } from './baseUnits';
+describe('@/lib/math', () => {
+    describe('fromBaseUnit', () => {
+        it('should correctly convert and round down with given displayDecimals', () => {
+            const result = fromBaseUnit(123456789, 4, 2);
+            expect(result).toBe('12345.67');
+        });
+        it('should correctly convert without displayDecimals and return full precision', () => {
+            const result = fromBaseUnit(123456789, 4);
+            expect(result).toBe('12345.6789');
+        });
+        it('should correctly convert and round down with given displayDecimals for another input', () => {
+            const result = fromBaseUnit(987654321, 6, 3);
+            expect(result).toBe('987.654');
+        });
+        it('should correctly convert without displayDecimals and return full precision for another input', () => {
+            const result = fromBaseUnit(987654321, 6);
+            expect(result).toBe('987.654321');
+        });
+        it('should correctly convert and round down with given displayDecimals for high precision input', () => {
+            const result = fromBaseUnit('182912819182912192', 18, 8);
+            expect(result).toBe('0.18291281');
+        });
+        it('should correctly convert without displayDecimals and return full precision for high precision input', () => {
+            const result = fromBaseUnit('182912819182912192', 18);
+            expect(result).toBe('0.182912819182912192');
+        });
+    });
+});

package/dist/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/basisPoints.js

@@ -0,0 +1,39 @@
+import { bn, bnOrZero } from './bignumber/bignumber';
+export const convertBasisPointsToDecimalPercentage = (basisPoints) => bnOrZero(basisPoints).div(10000);
+export const convertDecimalPercentageToBasisPoints = (decimalPercentage) => bnOrZero(decimalPercentage).times(10000);
+export const convertBasisPointsToPercentage = (basisPoints) => bnOrZero(basisPoints).div(100);
+export const convertPercentageToBasisPoints = (percentage) => bnOrZero(percentage).times(100);
+/**
+ * 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 const subtractBasisPointAmount = (value, basisPoints, roundingMode) => {
+    const bigNumValue = bn(value);
+    // Basis point is 1/100th of a percent
+    const percentValue = 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();
+};
+/**
+ * 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 const addBasisPointAmount = (value, basisPoints, roundingMode) => {
+    const bigNumValue = bn(value);
+    // Basis point is 1/100th of a percent
+    const percentValue = 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();
+};

package/dist/bignumber/bignumber.d.ts

@@ -0,0 +1,11 @@
+import BigNumber from 'bignumber.js';
+export * 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/bignumber/bignumber.js

@@ -0,0 +1,16 @@
+import BigNumber from 'bignumber.js';
+export * from 'bignumber.js';
+export const bn = (n, base = 10) => new BigNumber(n, base);
+export const bnOrZero = (n) => {
+    const value = bn(n || 0);
+    return value.isFinite() ? value : bn(0);
+};
+export const positiveOrZero = (n) => {
+    const value = bn(n || 0);
+    return value.isPositive() ? value : bn(0);
+};
+export const convertPrecision = ({ value, inputExponent = 0, outputExponent = 0, }) => {
+    return bnOrZero(value)
+        .dividedBy(bn(10).exponentiatedBy(inputExponent))
+        .multipliedBy(bn(10).exponentiatedBy(outputExponent));
+};

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

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

package/dist/bignumber/bignumber.test.js

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

package/dist/chainIdToFeeAsset.d.ts

@@ -0,0 +1,3 @@
+import type { AssetId, ChainId } from '@shapeshiftoss/caip';
+import type { Asset } from '@shapeshiftoss/types';
+export declare const chainIdToFeeAsset: (assetsById: Partial<Record<AssetId, Asset>>, chainId: ChainId) => Asset | undefined;

package/dist/chainIdToFeeAsset.js

@@ -0,0 +1,5 @@
+import { chainIdToFeeAssetId } from './chainIdToFeeAssetId';
+export const chainIdToFeeAsset = (assetsById, chainId) => {
+    const assetId = chainIdToFeeAssetId(chainId);
+    return assetsById[assetId];
+};

package/dist/chainIdToFeeAssetId.d.ts

@@ -0,0 +1,2 @@
+import type { AssetId, ChainId } from '@shapeshiftoss/caip';
+export declare const chainIdToFeeAssetId: (_chainId: ChainId) => AssetId;

package/dist/chainIdToFeeAssetId.js

@@ -0,0 +1,44 @@
+import { arbitrumAssetId, arbitrumNovaAssetId, avalancheAssetId, baseAssetId, bchAssetId, bscAssetId, btcAssetId, cosmosAssetId, dogeAssetId, ethAssetId, gnosisAssetId, ltcAssetId, mayachainAssetId, optimismAssetId, polygonAssetId, solAssetId, thorchainAssetId, } from '@shapeshiftoss/caip';
+import { KnownChainIds } from '@shapeshiftoss/types';
+import { assertUnreachable } from './assertUnreachable';
+export const chainIdToFeeAssetId = (_chainId) => {
+    const chainId = _chainId;
+    switch (chainId) {
+        case KnownChainIds.ArbitrumMainnet:
+            return arbitrumAssetId;
+        case KnownChainIds.AvalancheMainnet:
+            return avalancheAssetId;
+        case KnownChainIds.ArbitrumNovaMainnet:
+            return arbitrumNovaAssetId;
+        case KnownChainIds.BaseMainnet:
+            return baseAssetId;
+        case KnownChainIds.BitcoinCashMainnet:
+            return bchAssetId;
+        case KnownChainIds.BitcoinMainnet:
+            return btcAssetId;
+        case KnownChainIds.BnbSmartChainMainnet:
+            return bscAssetId;
+        case KnownChainIds.CosmosMainnet:
+            return cosmosAssetId;
+        case KnownChainIds.DogecoinMainnet:
+            return dogeAssetId;
+        case KnownChainIds.EthereumMainnet:
+            return ethAssetId;
+        case KnownChainIds.GnosisMainnet:
+            return gnosisAssetId;
+        case KnownChainIds.LitecoinMainnet:
+            return ltcAssetId;
+        case KnownChainIds.OptimismMainnet:
+            return optimismAssetId;
+        case KnownChainIds.PolygonMainnet:
+            return polygonAssetId;
+        case KnownChainIds.ThorchainMainnet:
+            return thorchainAssetId;
+        case KnownChainIds.MayachainMainnet:
+            return mayachainAssetId;
+        case KnownChainIds.SolanaMainnet:
+            return solAssetId;
+        default:
+            return assertUnreachable(chainId);
+    }
+};

package/dist/createThrottle.d.ts

@@ -0,0 +1,9 @@
+export declare const createThrottle: ({ capacity, costPerReq, drainPerInterval, intervalMs, }: {
+    capacity: number;
+    costPerReq: number;
+    drainPerInterval: number;
+    intervalMs: number;
+}) => {
+    throttle: () => Promise<void>;
+    clear: () => void;
+};

package/dist/createThrottle.js

@@ -0,0 +1,32 @@
+export const createThrottle = ({ capacity, costPerReq, drainPerInterval, intervalMs, }) => {
+    let currentLevel = 0;
+    let pendingResolves = [];
+    const drain = () => {
+        const drainAmount = Math.min(currentLevel, drainPerInterval);
+        currentLevel -= drainAmount;
+        // Resolve pending promises if there's enough capacity
+        while (pendingResolves.length > 0 && currentLevel + costPerReq <= capacity) {
+            const resolve = pendingResolves.shift();
+            if (resolve) {
+                currentLevel += costPerReq;
+                resolve();
+            }
+        }
+    };
+    // Start the interval to drain the capacity
+    const intervalId = setInterval(drain, intervalMs);
+    const throttle = async () => {
+        if (currentLevel + costPerReq <= capacity) {
+            // If adding another request doesn't exceed capacity, proceed immediately
+            currentLevel += costPerReq;
+        }
+        else {
+            // Otherwise, wait until there's enough capacity
+            await new Promise(resolve => {
+                pendingResolves.push(resolve);
+            });
+        }
+    };
+    const clear = () => clearInterval(intervalId);
+    return { throttle, clear };
+};

package/dist/getAssetNamespaceFromChainId.d.ts

@@ -0,0 +1,3 @@
+import type { AssetNamespace } from '@shapeshiftoss/caip';
+import { KnownChainIds } from '@shapeshiftoss/types';
+export declare const getAssetNamespaceFromChainId: (chainId: KnownChainIds) => AssetNamespace;

package/dist/getAssetNamespaceFromChainId.js

@@ -0,0 +1,31 @@
+import { ASSET_NAMESPACE } from '@shapeshiftoss/caip';
+import { KnownChainIds } from '@shapeshiftoss/types';
+import { assertUnreachable } from './assertUnreachable';
+export const getAssetNamespaceFromChainId = (chainId) => {
+    switch (chainId) {
+        case KnownChainIds.BnbSmartChainMainnet:
+            return ASSET_NAMESPACE.bep20;
+        case KnownChainIds.SolanaMainnet:
+            return ASSET_NAMESPACE.splToken;
+        case KnownChainIds.EthereumMainnet:
+        case KnownChainIds.AvalancheMainnet:
+        case KnownChainIds.OptimismMainnet:
+        case KnownChainIds.PolygonMainnet:
+        case KnownChainIds.GnosisMainnet:
+        case KnownChainIds.ArbitrumMainnet:
+        case KnownChainIds.ArbitrumNovaMainnet:
+        case KnownChainIds.BaseMainnet:
+            return ASSET_NAMESPACE.erc20;
+        case KnownChainIds.CosmosMainnet:
+            return ASSET_NAMESPACE.ibc;
+        case KnownChainIds.BitcoinMainnet:
+        case KnownChainIds.BitcoinCashMainnet:
+        case KnownChainIds.DogecoinMainnet:
+        case KnownChainIds.LitecoinMainnet:
+        case KnownChainIds.ThorchainMainnet:
+        case KnownChainIds.MayachainMainnet:
+            throw Error(`Unhandled case '${chainId}'`);
+        default:
+            return assertUnreachable(chainId);
+    }
+};

package/dist/getChainShortName.d.ts

@@ -0,0 +1,2 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+export declare const getChainShortName: (chainId: KnownChainIds) => "AVA" | "OP" | "ETH" | "POLY" | "GNO" | "BNB" | "ARB" | "ARB-Nova" | "BAS" | "BTC" | "BCH" | "COSM" | "THOR" | "MAYA" | "DOGE" | "LTC" | "SOL" | undefined;

package/dist/getChainShortName.js

@@ -0,0 +1,43 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+import { assertUnreachable } from './assertUnreachable';
+export const getChainShortName = (chainId) => {
+    switch (chainId) {
+        case KnownChainIds.AvalancheMainnet:
+            return 'AVA';
+        case KnownChainIds.OptimismMainnet:
+            return 'OP';
+        case KnownChainIds.EthereumMainnet:
+            return 'ETH';
+        case KnownChainIds.PolygonMainnet:
+            return 'POLY';
+        case KnownChainIds.GnosisMainnet:
+            return 'GNO';
+        case KnownChainIds.BnbSmartChainMainnet:
+            return 'BNB';
+        case KnownChainIds.ArbitrumMainnet:
+            return 'ARB';
+        case KnownChainIds.ArbitrumNovaMainnet:
+            return 'ARB-Nova';
+        case KnownChainIds.BaseMainnet:
+            return 'BAS';
+        case KnownChainIds.BitcoinMainnet:
+            return 'BTC';
+        case KnownChainIds.BitcoinCashMainnet:
+            return 'BCH';
+        case KnownChainIds.CosmosMainnet:
+            return 'COSM';
+        case KnownChainIds.ThorchainMainnet:
+            return 'THOR';
+        case KnownChainIds.MayachainMainnet:
+            return 'MAYA';
+        case KnownChainIds.DogecoinMainnet:
+            return 'DOGE';
+        case KnownChainIds.LitecoinMainnet:
+            return 'LTC';
+        case KnownChainIds.SolanaMainnet:
+            return 'SOL';
+        default: {
+            assertUnreachable(chainId);
+        }
+    }
+};

package/dist/getNativeFeeAssetReference.d.ts

@@ -0,0 +1,2 @@
+import type { AssetReference, ChainNamespace, ChainReference } from '@shapeshiftoss/caip';
+export declare const getNativeFeeAssetReference: (chainNamespace: ChainNamespace, chainReference: ChainReference) => AssetReference;

package/dist/getNativeFeeAssetReference.js

@@ -0,0 +1,63 @@
+import { ASSET_REFERENCE, CHAIN_NAMESPACE, CHAIN_REFERENCE } from '@shapeshiftoss/caip';
+export const getNativeFeeAssetReference = (chainNamespace, chainReference) => {
+    return (() => {
+        switch (chainNamespace) {
+            case CHAIN_NAMESPACE.Utxo:
+                switch (chainReference) {
+                    case CHAIN_REFERENCE.BitcoinMainnet:
+                        return ASSET_REFERENCE.Bitcoin;
+                    case CHAIN_REFERENCE.BitcoinCashMainnet:
+                        return ASSET_REFERENCE.BitcoinCash;
+                    case CHAIN_REFERENCE.DogecoinMainnet:
+                        return ASSET_REFERENCE.Dogecoin;
+                    case CHAIN_REFERENCE.LitecoinMainnet:
+                        return ASSET_REFERENCE.Litecoin;
+                    default:
+                        throw new Error(`Chain namespace ${chainNamespace} on ${chainReference} not supported.`);
+                }
+            case CHAIN_NAMESPACE.Evm:
+                switch (chainReference) {
+                    case CHAIN_REFERENCE.AvalancheCChain:
+                        return ASSET_REFERENCE.AvalancheC;
+                    case CHAIN_REFERENCE.EthereumMainnet:
+                        return ASSET_REFERENCE.Ethereum;
+                    case CHAIN_REFERENCE.OptimismMainnet:
+                        return ASSET_REFERENCE.Optimism;
+                    case CHAIN_REFERENCE.BnbSmartChainMainnet:
+                        return ASSET_REFERENCE.BnbSmartChain;
+                    case CHAIN_REFERENCE.PolygonMainnet:
+                        return ASSET_REFERENCE.Polygon;
+                    case CHAIN_REFERENCE.GnosisMainnet:
+                        return ASSET_REFERENCE.Gnosis;
+                    case CHAIN_REFERENCE.ArbitrumMainnet:
+                        return ASSET_REFERENCE.Arbitrum;
+                    case CHAIN_REFERENCE.ArbitrumNovaMainnet:
+                        return ASSET_REFERENCE.ArbitrumNova;
+                    case CHAIN_REFERENCE.BaseMainnet:
+                        return ASSET_REFERENCE.Base;
+                    default:
+                        throw new Error(`Chain namespace ${chainNamespace} on ${chainReference} not supported.`);
+                }
+            case CHAIN_NAMESPACE.CosmosSdk:
+                switch (chainReference) {
+                    case CHAIN_REFERENCE.CosmosHubMainnet:
+                        return ASSET_REFERENCE.Cosmos;
+                    case CHAIN_REFERENCE.ThorchainMainnet:
+                        return ASSET_REFERENCE.Thorchain;
+                    case CHAIN_REFERENCE.MayachainMainnet:
+                        return ASSET_REFERENCE.Mayachain;
+                    default:
+                        throw new Error(`Chain namespace ${chainNamespace} on ${chainReference} not supported.`);
+                }
+            case CHAIN_NAMESPACE.Solana:
+                switch (chainReference) {
+                    case CHAIN_REFERENCE.SolanaMainnet:
+                        return ASSET_REFERENCE.Solana;
+                    default:
+                        throw new Error(`Chain namespace ${chainNamespace} on ${chainReference} not supported.`);
+                }
+            default:
+                throw new Error(`Chain namespace ${chainNamespace} on ${chainReference} not supported.`);
+        }
+    })();
+};

package/dist/historyTimeframe.d.ts

@@ -0,0 +1,6 @@
+import { HistoryTimeframe } from '@shapeshiftoss/types';
+import dayjs from 'dayjs';
+export declare const getHistoryTimeframeBounds: (timeframe: HistoryTimeframe, end?: dayjs.Dayjs) => {
+    start: dayjs.Dayjs;
+    end: dayjs.Dayjs;
+};

package/dist/historyTimeframe.js

@@ -0,0 +1,29 @@
+import { HistoryTimeframe } from '@shapeshiftoss/types';
+import dayjs from 'dayjs';
+import { assertUnreachable } from './assertUnreachable';
+export const getHistoryTimeframeBounds = (timeframe, end = dayjs().endOf('day')) => {
+    let start = end; // Shut up typescript.
+    switch (timeframe) {
+        case HistoryTimeframe.HOUR:
+            start = end.subtract(1, 'day');
+            break;
+        case HistoryTimeframe.DAY:
+            start = end.subtract(1, 'day');
+            break;
+        case HistoryTimeframe.WEEK:
+            start = end.subtract(1, 'week');
+            break;
+        case HistoryTimeframe.MONTH:
+            start = end.subtract(1, 'month');
+            break;
+        case HistoryTimeframe.YEAR:
+            start = end.subtract(1, 'year');
+            break;
+        case HistoryTimeframe.ALL:
+            start = end.subtract(5, 'years');
+            break;
+        default:
+            assertUnreachable(timeframe);
+    }
+    return { start, end };
+};