@shapeshiftoss/utils 1.0.3 → 1.0.5

package/dist/esm/chainIdToFeeAssetId.js

@@ -0,0 +1,62 @@
+import { arbitrumAssetId, arbitrumNovaAssetId, avalancheAssetId, baseAssetId, bchAssetId, bscAssetId, btcAssetId, cosmosAssetId, dogeAssetId, ethAssetId, gnosisAssetId, hyperEvmAssetId, katanaAssetId, ltcAssetId, mayachainAssetId, monadAssetId, nearAssetId, optimismAssetId, plasmaAssetId, polygonAssetId, solAssetId, starknetAssetId, suiAssetId, thorchainAssetId, tronAssetId, zecAssetId, } from '@shapeshiftoss/caip';
+import { KnownChainIds } from '@shapeshiftoss/types';
+import { assertUnreachable } from './assertUnreachable.js';
+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;
+        case KnownChainIds.TronMainnet:
+            return tronAssetId;
+        case KnownChainIds.SuiMainnet:
+            return suiAssetId;
+        case KnownChainIds.StarknetMainnet:
+            return starknetAssetId;
+        case KnownChainIds.MonadMainnet:
+            return monadAssetId;
+        case KnownChainIds.HyperEvmMainnet:
+            return hyperEvmAssetId;
+        case KnownChainIds.PlasmaMainnet:
+            return plasmaAssetId;
+        case KnownChainIds.KatanaMainnet:
+            return katanaAssetId;
+        case KnownChainIds.ZcashMainnet:
+            return zecAssetId;
+        case KnownChainIds.NearMainnet:
+            return nearAssetId;
+        default:
+            return assertUnreachable(chainId);
+    }
+};

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

@@ -0,0 +1,42 @@
+import { ASSET_NAMESPACE } from '@shapeshiftoss/caip';
+import { KnownChainIds } from '@shapeshiftoss/types';
+import { assertUnreachable } from './assertUnreachable.js';
+export const getAssetNamespaceFromChainId = (chainId) => {
+    switch (chainId) {
+        case KnownChainIds.SolanaMainnet:
+            return ASSET_NAMESPACE.splToken;
+        case KnownChainIds.SuiMainnet:
+            return ASSET_NAMESPACE.suiCoin;
+        case KnownChainIds.NearMainnet:
+            return ASSET_NAMESPACE.nep141;
+        case KnownChainIds.TronMainnet:
+            return ASSET_NAMESPACE.trc20;
+        case KnownChainIds.EthereumMainnet:
+        case KnownChainIds.AvalancheMainnet:
+        case KnownChainIds.OptimismMainnet:
+        case KnownChainIds.PolygonMainnet:
+        case KnownChainIds.GnosisMainnet:
+        case KnownChainIds.ArbitrumMainnet:
+        case KnownChainIds.ArbitrumNovaMainnet:
+        case KnownChainIds.BaseMainnet:
+        case KnownChainIds.BnbSmartChainMainnet:
+        case KnownChainIds.MonadMainnet:
+        case KnownChainIds.HyperEvmMainnet:
+        case KnownChainIds.PlasmaMainnet:
+        case KnownChainIds.KatanaMainnet:
+            return ASSET_NAMESPACE.erc20;
+        case KnownChainIds.StarknetMainnet:
+            return ASSET_NAMESPACE.starknetToken;
+        case KnownChainIds.CosmosMainnet:
+        case KnownChainIds.BitcoinMainnet:
+        case KnownChainIds.BitcoinCashMainnet:
+        case KnownChainIds.DogecoinMainnet:
+        case KnownChainIds.LitecoinMainnet:
+        case KnownChainIds.ZcashMainnet:
+        case KnownChainIds.ThorchainMainnet:
+        case KnownChainIds.MayachainMainnet:
+            throw Error(`Unhandled case '${chainId}'`);
+        default:
+            return assertUnreachable(chainId);
+    }
+};

package/dist/esm/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" | "TRX" | "SUI" | "STRK" | "MON" | "HYPE" | "XPL" | "KAT" | "ZEC" | "NEAR" | undefined;

package/dist/esm/getChainShortName.js

@@ -0,0 +1,61 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+import { assertUnreachable } from './assertUnreachable.js';
+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';
+        case KnownChainIds.TronMainnet:
+            return 'TRX';
+        case KnownChainIds.SuiMainnet:
+            return 'SUI';
+        case KnownChainIds.StarknetMainnet:
+            return 'STRK';
+        case KnownChainIds.MonadMainnet:
+            return 'MON';
+        case KnownChainIds.HyperEvmMainnet:
+            return 'HYPE';
+        case KnownChainIds.PlasmaMainnet:
+            return 'XPL';
+        case KnownChainIds.KatanaMainnet:
+            return 'KAT';
+        case KnownChainIds.ZcashMainnet:
+            return 'ZEC';
+        case KnownChainIds.NearMainnet:
+            return 'NEAR';
+        default: {
+            assertUnreachable(chainId);
+        }
+    }
+};

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

@@ -0,0 +1,101 @@
+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;
+                    case CHAIN_REFERENCE.ZcashMainnet:
+                        return ASSET_REFERENCE.Zcash;
+                    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;
+                    case CHAIN_REFERENCE.MonadMainnet:
+                        return ASSET_REFERENCE.Monad;
+                    case CHAIN_REFERENCE.HyperEvmMainnet:
+                        return ASSET_REFERENCE.HyperEvm;
+                    case CHAIN_REFERENCE.PlasmaMainnet:
+                        return ASSET_REFERENCE.Plasma;
+                    case CHAIN_REFERENCE.KatanaMainnet:
+                        return ASSET_REFERENCE.Katana;
+                    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.`);
+                }
+            case CHAIN_NAMESPACE.Tron:
+                switch (chainReference) {
+                    case CHAIN_REFERENCE.TronMainnet:
+                        return ASSET_REFERENCE.Tron;
+                    default:
+                        throw new Error(`Chain namespace ${chainNamespace} on ${chainReference} not supported.`);
+                }
+            case CHAIN_NAMESPACE.Sui:
+                switch (chainReference) {
+                    case CHAIN_REFERENCE.SuiMainnet:
+                        return ASSET_REFERENCE.Sui;
+                    default:
+                        throw new Error(`Chain namespace ${chainNamespace} on ${chainReference} not supported.`);
+                }
+            case CHAIN_NAMESPACE.Near:
+                switch (chainReference) {
+                    case CHAIN_REFERENCE.NearMainnet:
+                        return ASSET_REFERENCE.Near;
+                    default:
+                        throw new Error(`Chain namespace ${chainNamespace} on ${chainReference} not supported.`);
+                }
+            case CHAIN_NAMESPACE.Starknet:
+                switch (chainReference) {
+                    case CHAIN_REFERENCE.StarknetMainnet:
+                        return ASSET_REFERENCE.Starknet;
+                    default:
+                        throw new Error(`Chain namespace ${chainNamespace} on ${chainReference} not supported.`);
+                }
+            default:
+                throw new Error(`Chain namespace ${chainNamespace} on ${chainReference} not supported.`);
+        }
+    })();
+};

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

@@ -0,0 +1,29 @@
+import { HistoryTimeframe } from '@shapeshiftoss/types';
+import dayjs from 'dayjs';
+import { assertUnreachable } from './assertUnreachable.js';
+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 };
+};

package/dist/esm/index.d.ts

@@ -0,0 +1,24 @@
+import type { AssetId } from '@shapeshiftoss/caip';
+export * from './assertUnreachable.js';
+export * from './assetData/index.js';
+export * from './baseUnits/baseUnits.js';
+export * from './basisPoints.js';
+export * from './bignumber/bignumber.js';
+export * from './chainIdToFeeAsset.js';
+export * from './chainIdToFeeAssetId.js';
+export * from './createThrottle.js';
+export * from './getAssetNamespaceFromChainId.js';
+export * from './getChainShortName.js';
+export * from './getNativeFeeAssetReference.js';
+export * from './historyTimeframe.js';
+export * from './makeAsset/makeAsset.js';
+export * from './promises.js';
+export * from './sha256.js';
+export * from './timeout.js';
+export * from './treasury.js';
+export * from './unfreeze.js';
+export * from './utxo.js';
+export declare const isSome: <T>(option: T | null | undefined) => option is T;
+export declare const isToken: (assetId: AssetId) => boolean;
+export declare const isSplToken: (assetId: AssetId) => boolean;
+export declare const contractAddressOrUndefined: (assetId: AssetId) => import("@shapeshiftoss/caip").AssetReference | undefined;

package/dist/esm/index.js

@@ -0,0 +1,41 @@
+import { ASSET_NAMESPACE, fromAssetId } from '@shapeshiftoss/caip';
+import { isNull, isUndefined } from 'lodash';
+export * from './assertUnreachable.js';
+export * from './assetData/index.js';
+export * from './baseUnits/baseUnits.js';
+export * from './basisPoints.js';
+export * from './bignumber/bignumber.js';
+export * from './chainIdToFeeAsset.js';
+export * from './chainIdToFeeAssetId.js';
+export * from './createThrottle.js';
+export * from './getAssetNamespaceFromChainId.js';
+export * from './getChainShortName.js';
+export * from './getNativeFeeAssetReference.js';
+export * from './historyTimeframe.js';
+export * from './makeAsset/makeAsset.js';
+export * from './promises.js';
+export * from './sha256.js';
+export * from './timeout.js';
+export * from './treasury.js';
+export * from './unfreeze.js';
+export * from './utxo.js';
+export const isSome = (option) => !isUndefined(option) && !isNull(option);
+export const isToken = (assetId) => {
+    switch (fromAssetId(assetId).assetNamespace) {
+        case ASSET_NAMESPACE.erc20:
+        case ASSET_NAMESPACE.erc721:
+        case ASSET_NAMESPACE.erc1155:
+        case ASSET_NAMESPACE.splToken:
+        case ASSET_NAMESPACE.trc20:
+        case ASSET_NAMESPACE.suiCoin:
+        case ASSET_NAMESPACE.starknetToken:
+        case ASSET_NAMESPACE.nep141:
+            return true;
+        default:
+            return false;
+    }
+};
+export const isSplToken = (assetId) => {
+    return fromAssetId(assetId).assetNamespace === ASSET_NAMESPACE.splToken;
+};
+export const contractAddressOrUndefined = (assetId) => isToken(assetId) || isSplToken(assetId) ? fromAssetId(assetId).assetReference : undefined;

package/dist/esm/makeAsset/makeAsset.d.ts

@@ -0,0 +1,10 @@
+import type { AssetId } from '@shapeshiftoss/caip';
+import type { Asset } from '@shapeshiftoss/types';
+export type MinimalAsset = Partial<Asset> & Pick<Asset, 'assetId' | 'symbol' | 'name' | 'precision'>;
+/**
+ * utility to create an asset from minimal asset data from external sources at runtime
+ * e.g. zapper/zerion/etherscan
+ * required fields are assetId, symbol, name, precision
+ * the rest can be inferred from existing data
+ */
+export declare const makeAsset: (assetsById: Partial<Record<AssetId, Asset>>, minimalAsset: MinimalAsset) => Asset;

package/dist/esm/makeAsset/makeAsset.js

@@ -0,0 +1,41 @@
+import { fromAssetId } from '@shapeshiftoss/caip';
+import { chainIdToFeeAsset } from '../chainIdToFeeAsset.js';
+import { sha256 } from '../sha256.js';
+/**
+ * utility to create an asset from minimal asset data from external sources at runtime
+ * e.g. zapper/zerion/etherscan
+ * required fields are assetId, symbol, name, precision
+ * the rest can be inferred from existing data
+ */
+export const makeAsset = (assetsById, minimalAsset) => {
+    const { assetId } = minimalAsset;
+    const color = (() => {
+        if (minimalAsset.color)
+            return minimalAsset.color;
+        const shaAssetId = sha256(assetId);
+        return `#${shaAssetId.slice(0, 6)}`;
+    })();
+    const chainId = (() => {
+        if (minimalAsset.chainId)
+            return minimalAsset.chainId;
+        return fromAssetId(assetId).chainId;
+    })();
+    // currently, dynamic assets are LP pairs, and they have two icon urls and are rendered differently
+    const icon = minimalAsset?.icon ?? '';
+    const explorerLinks = (() => {
+        const feeAsset = chainIdToFeeAsset(assetsById, chainId);
+        return {
+            explorer: feeAsset?.explorer ?? '',
+            explorerTxLink: feeAsset?.explorerTxLink ?? '',
+            explorerAddressLink: feeAsset?.explorerAddressLink ?? '',
+        };
+    })();
+    return Object.assign({}, minimalAsset, explorerLinks, {
+        chainId,
+        color,
+        icon,
+        relatedAssetKey: null,
+        isPrimary: true,
+        isChainSpecific: true,
+    });
+};

package/dist/esm/makeAsset/makeAsset.test.d.ts

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

package/dist/esm/makeAsset/makeAsset.test.js

@@ -0,0 +1,45 @@
+import { ASSET_NAMESPACE, ethAssetId, ethChainId, toAssetId } from '@shapeshiftoss/caip';
+import { describe, expect, it } from 'vitest';
+import { makeAsset } from './makeAsset.js';
+const ETH = {
+    assetId: ethAssetId,
+    chainId: ethChainId,
+    symbol: 'ETH',
+    name: 'Ethereum',
+    precision: 18,
+    color: '#FFFFFF',
+    icon: 'https://rawcdn.githack.com/trustwallet/assets/32e51d582a890b3dd3135fe3ee7c20c2fd699a6d/blockchains/ethereum/info/logo.png',
+    explorer: 'https://etherscan.io',
+    explorerTxLink: 'https://etherscan.io/tx/',
+    explorerAddressLink: 'https://etherscan.io/address/',
+    relatedAssetKey: null,
+};
+describe('makeAsset', () => {
+    it('can make erc20 shitcoins', () => {
+        const assetReference = '0xfoobar0000000000000000000000000000000000';
+        const assetNamespace = ASSET_NAMESPACE.erc20;
+        const symbol = 'FOOO';
+        const name = 'Humble Panda';
+        const precision = 18;
+        const chainId = ethChainId;
+        const assetId = toAssetId({ chainId, assetNamespace, assetReference });
+        const minimalAsset = { assetId, symbol, precision, name };
+        const assetsById = { [ETH.assetId]: ETH };
+        const asset = makeAsset(assetsById, minimalAsset);
+        const asset2 = makeAsset(assetsById, minimalAsset);
+        // doesn't molest asset id, precision, symbol, name
+        expect(asset?.assetId).toEqual(assetId);
+        expect(asset?.name).toEqual(name);
+        expect(asset?.symbol).toEqual(symbol);
+        expect(asset?.precision).toEqual(precision);
+        // belongs to correct chain
+        expect(asset?.chainId).toEqual(chainId);
+        // inherits fee asset explorer links
+        expect(asset?.explorer).toEqual(ETH.explorer);
+        expect(asset?.explorerTxLink).toEqual(ETH.explorerTxLink);
+        expect(asset?.explorerAddressLink).toEqual(ETH.explorerAddressLink);
+        // is deterministic on color and icon
+        expect(asset?.color).toEqual(asset2?.color);
+        expect(asset?.icon).toEqual(asset2?.icon);
+    });
+});

package/dist/esm/promises.d.ts

@@ -0,0 +1,4 @@
+import type { Result } from '@sniptt/monads';
+export declare const isFulfilled: <T>(promise: PromiseSettledResult<T>) => promise is PromiseFulfilledResult<T>;
+export declare const isRejected: <T>(promise: PromiseSettledResult<T>) => promise is PromiseRejectedResult;
+export declare const isResolvedErr: <U, V, T extends Result<U, V>>(promise: PromiseSettledResult<T>) => promise is PromiseRejectedResult;

package/dist/esm/promises.js

@@ -0,0 +1,3 @@
+export const isFulfilled = (promise) => promise.status === 'fulfilled';
+export const isRejected = (promise) => promise.status === 'rejected';
+export const isResolvedErr = (promise) => 'value' in promise && promise.value.isErr();

package/dist/esm/sha256.d.ts

@@ -0,0 +1 @@
+export declare const sha256: (input: string) => string;

package/dist/esm/sha256.js

@@ -0,0 +1,2 @@
+import crypto from 'node:crypto';
+export const sha256 = (input) => crypto.createHash('sha256').update(input).digest('hex');

package/dist/esm/timeout.d.ts

@@ -0,0 +1,7 @@
+import type { Result } from '@sniptt/monads';
+export declare const timeout: <SuccessType, FallbackType>(promise: Promise<SuccessType>, timeoutMs: number, fallbackValue: FallbackType) => Promise<SuccessType | FallbackType>;
+export declare const timeoutMonadic: <Left, Right>(promise: Promise<Result<Left, Right>>, timeoutMs: number, timeoutRight: Right) => Promise<Result<Left, Right>>;
+export declare const timeoutMonadicWithOriginal: <Ok, ErrType>(promise: Promise<Result<Ok, ErrType>>, timeoutMs: number, timeoutErr: ErrType) => {
+    timed: Promise<Result<Ok, ErrType>>;
+    original: Promise<Result<Ok, ErrType>>;
+};

package/dist/esm/timeout.js

@@ -0,0 +1,28 @@
+import { Err } from '@sniptt/monads';
+export const timeout = (promise, timeoutMs, fallbackValue) => {
+    return Promise.race([
+        promise,
+        new Promise(resolve => setTimeout(() => {
+            resolve(fallbackValue);
+        }, timeoutMs)),
+    ]);
+};
+export const timeoutMonadic = (promise, timeoutMs, timeoutRight) => {
+    return Promise.race([
+        promise,
+        new Promise(resolve => setTimeout(() => {
+            resolve(Err(timeoutRight));
+        }, timeoutMs)),
+    ]);
+};
+export const timeoutMonadicWithOriginal = (promise, timeoutMs, timeoutErr) => {
+    return {
+        timed: Promise.race([
+            promise,
+            new Promise(resolve => setTimeout(() => {
+                resolve(Err(timeoutErr));
+            }, timeoutMs)),
+        ]),
+        original: promise,
+    };
+};

package/dist/esm/treasury.d.ts

@@ -0,0 +1,17 @@
+import type { ChainId } from '@shapeshiftoss/caip';
+import { KnownChainIds } from '@shapeshiftoss/types';
+export declare const treasuryChainIds: readonly [KnownChainIds.EthereumMainnet, KnownChainIds.AvalancheMainnet, KnownChainIds.OptimismMainnet, KnownChainIds.BnbSmartChainMainnet, KnownChainIds.PolygonMainnet, KnownChainIds.GnosisMainnet, KnownChainIds.ArbitrumMainnet, KnownChainIds.BaseMainnet, KnownChainIds.SolanaMainnet, KnownChainIds.BitcoinMainnet, KnownChainIds.StarknetMainnet];
+export type TreasuryChainId = (typeof treasuryChainIds)[number];
+export declare const isTreasuryChainId: (chainId: ChainId) => chainId is KnownChainIds.EthereumMainnet | KnownChainIds.AvalancheMainnet | KnownChainIds.OptimismMainnet | KnownChainIds.BnbSmartChainMainnet | KnownChainIds.PolygonMainnet | KnownChainIds.GnosisMainnet | KnownChainIds.ArbitrumMainnet | KnownChainIds.BaseMainnet | KnownChainIds.BitcoinMainnet | KnownChainIds.SolanaMainnet | KnownChainIds.StarknetMainnet;
+export declare const DAO_TREASURY_ETHEREUM_MAINNET = "0x90a48d5cf7343b08da12e067680b4c6dbfe551be";
+export declare const DAO_TREASURY_OPTIMISM = "0x6268d07327f4fb7380732dc6d63d95F88c0E083b";
+export declare const DAO_TREASURY_AVALANCHE = "0x74d63F31C2335b5b3BA7ad2812357672b2624cEd";
+export declare const DAO_TREASURY_POLYGON = "0xB5F944600785724e31Edb90F9DFa16dBF01Af000";
+export declare const DAO_TREASURY_GNOSIS = "0xb0E3175341794D1dc8E5F02a02F9D26989EbedB3";
+export declare const DAO_TREASURY_BSC = "0x8b92b1698b57bEDF2142297e9397875ADBb2297E";
+export declare const DAO_TREASURY_ARBITRUM = "0x38276553F8fbf2A027D901F8be45f00373d8Dd48";
+export declare const DAO_TREASURY_BASE = "0x9c9aA90363630d4ab1D9dbF416cc3BBC8d3Ed502";
+export declare const DAO_TREASURY_SOLANA = "Bh7R3MeJ98D7Ersxh7TgVQVQUSmDMqwrFVHH9DLfb4u3";
+export declare const DAO_TREASURY_BITCOIN = "bc1qr2whxtd0gvqnctcxlynwejp6fvntv0mtxkv0dlv02vyale8h69ysm6l32n";
+export declare const DAO_TREASURY_NEAR = "f471d0b0f90593d85125f38aaf5458748d6f23fd5b437b844d293d8e87557070";
+export declare const DAO_TREASURY_STARKNET = "0x052a1132ea4db81Bde863AFb18a4d4CE5de9d3efdfda6b3DaA6484e26425D467";

package/dist/esm/treasury.js

@@ -0,0 +1,32 @@
+// Wallets relating to the ShapeShift DAO Treasury
+// https://forum.shapeshift.com/thread/dao-treasuries-and-multisigs-43646
+import { KnownChainIds } from '@shapeshiftoss/types';
+export const treasuryChainIds = [
+    KnownChainIds.EthereumMainnet,
+    KnownChainIds.AvalancheMainnet,
+    KnownChainIds.OptimismMainnet,
+    KnownChainIds.BnbSmartChainMainnet,
+    KnownChainIds.PolygonMainnet,
+    KnownChainIds.GnosisMainnet,
+    KnownChainIds.ArbitrumMainnet,
+    KnownChainIds.BaseMainnet,
+    KnownChainIds.SolanaMainnet,
+    KnownChainIds.BitcoinMainnet,
+    KnownChainIds.StarknetMainnet,
+];
+export const isTreasuryChainId = (chainId) => {
+    return treasuryChainIds.includes(chainId);
+};
+// Safes
+export const DAO_TREASURY_ETHEREUM_MAINNET = '0x90a48d5cf7343b08da12e067680b4c6dbfe551be';
+export const DAO_TREASURY_OPTIMISM = '0x6268d07327f4fb7380732dc6d63d95F88c0E083b';
+export const DAO_TREASURY_AVALANCHE = '0x74d63F31C2335b5b3BA7ad2812357672b2624cEd';
+export const DAO_TREASURY_POLYGON = '0xB5F944600785724e31Edb90F9DFa16dBF01Af000';
+export const DAO_TREASURY_GNOSIS = '0xb0E3175341794D1dc8E5F02a02F9D26989EbedB3';
+export const DAO_TREASURY_BSC = '0x8b92b1698b57bEDF2142297e9397875ADBb2297E';
+export const DAO_TREASURY_ARBITRUM = '0x38276553F8fbf2A027D901F8be45f00373d8Dd48';
+export const DAO_TREASURY_BASE = '0x9c9aA90363630d4ab1D9dbF416cc3BBC8d3Ed502';
+export const DAO_TREASURY_SOLANA = 'Bh7R3MeJ98D7Ersxh7TgVQVQUSmDMqwrFVHH9DLfb4u3';
+export const DAO_TREASURY_BITCOIN = 'bc1qr2whxtd0gvqnctcxlynwejp6fvntv0mtxkv0dlv02vyale8h69ysm6l32n';
+export const DAO_TREASURY_NEAR = 'f471d0b0f90593d85125f38aaf5458748d6f23fd5b437b844d293d8e87557070';
+export const DAO_TREASURY_STARKNET = '0x052a1132ea4db81Bde863AFb18a4d4CE5de9d3efdfda6b3DaA6484e26425D467';

package/dist/esm/unfreeze.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Creates a shallow clone to allow mutation of a readonly object
+ */
+export declare const unfreeze: <T>(obj: Readonly<T>) => T;