@shapeshiftoss/caip 8.16.1 → 9.0.0-alpha.0

package/dist/esm/adapters/coingecko/index.d.ts

@@ -0,0 +1,26 @@
+import type { AssetId } from '../../assetId/assetId';
+import type { ChainId } from '../../chainId/chainId';
+export { fetchData as fetchCoingeckoData, parseData as parseCoingeckoData } from './utils';
+export declare enum CoingeckoAssetPlatform {
+    Ethereum = "ethereum",
+    Cosmos = "cosmos",
+    Polygon = "polygon-pos",
+    Gnosis = "xdai",
+    Avalanche = "avalanche",
+    Thorchain = "thorchain",
+    Mayachain = "cacao",
+    Optimism = "optimistic-ethereum",
+    BnbSmartChain = "binance-smart-chain",
+    Arbitrum = "arbitrum-one",
+    ArbitrumNova = "arbitrum-nova",
+    Base = "base",
+    Solana = "solana"
+}
+type CoinGeckoId = string;
+export declare const coingeckoBaseUrl = "https://api.proxy.shapeshift.com/api/v1/markets";
+export declare const coingeckoUrl = "https://api.proxy.shapeshift.com/api/v1/markets/coins/list?include_platform=true";
+export declare const coingeckoToAssetIds: (id: CoinGeckoId) => AssetId[];
+export declare const assetIdToCoingecko: (assetId: AssetId) => CoinGeckoId | undefined;
+export declare const chainIdToCoingeckoAssetPlatform: (chainId: ChainId) => string;
+export declare const coingeckoAssetPlatformToChainId: (platform: CoingeckoAssetPlatform) => ChainId | undefined;
+export declare const makeCoingeckoAssetUrl: (assetId: AssetId) => string | undefined;

package/dist/esm/adapters/coingecko/index.test.d.ts

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

package/dist/esm/adapters/coingecko/utils.d.ts

@@ -0,0 +1,11 @@
+import type { AssetId } from '../../assetId/assetId';
+import type { ChainId } from '../../chainId/chainId';
+export type CoingeckoCoin = {
+    id: string;
+    platforms: Record<string, string>;
+};
+type AssetMap = Record<ChainId, Record<AssetId, string>>;
+export declare const fetchData: (URL: string) => Promise<CoingeckoCoin[]>;
+export declare const parseData: (coins: CoingeckoCoin[]) => AssetMap;
+export declare const writeFiles: (data: AssetMap) => Promise<void>;
+export {};

package/dist/esm/adapters/coingecko/utils.test.d.ts

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

package/dist/esm/adapters/index.js

@@ -0,0 +1,6 @@
+export * from './coingecko';
+export * from './coincap';
+export * from './banxa';
+export * from './coinbase';
+export * from './mtpelerin';
+export * from './onramper';

package/dist/esm/adapters/mtpelerin/index.d.ts

@@ -0,0 +1,10 @@
+import type { AssetId } from '../../assetId/assetId';
+export declare const mtPelerinSymbolToAssetIds: (id: string) => AssetId[];
+export declare const assetIdToMtPelerinSymbol: (assetId: AssetId) => string | undefined;
+/**
+ * Convert a mtPelerin asset identifier to a MtPelerin chain identifier for use in MtPelerin HTTP URLs
+ *
+ * @param {string} assetId - an assetId string referencing a specific asset; e.g., ethAssetId
+ * @returns {string} - a MtPelerin network identifier; e.g., 'mainnet'
+ */
+export declare const getMtPelerinNetFromAssetId: (assetId: AssetId) => string | undefined;

package/dist/esm/adapters/onramper/index.d.ts

@@ -0,0 +1,7 @@
+import type { AssetId } from '../../assetId/assetId';
+type OnRamperTokenId = string;
+export declare const AssetIdToOnRamperIdMap: Record<AssetId, OnRamperTokenId[]>;
+export declare const getOnRamperSupportedAssets: () => void;
+export declare const onRamperTokenIdToAssetId: (tokenId: OnRamperTokenId) => AssetId | undefined;
+export declare const assetIdToOnRamperTokenList: (assetId: AssetId) => OnRamperTokenId[] | undefined;
+export {};

package/dist/esm/assetId/assetId.d.ts

@@ -0,0 +1,36 @@
+import type { ChainId, ChainNamespace, ChainReference } from '../chainId/chainId';
+import type { ASSET_NAMESPACE, ASSET_REFERENCE } from '../constants';
+import type { Nominal } from '../utils';
+export type AssetId = Nominal<string, 'AssetId'>;
+export type AssetNamespace = (typeof ASSET_NAMESPACE)[keyof typeof ASSET_NAMESPACE];
+export type AssetReference = (typeof ASSET_REFERENCE)[keyof typeof ASSET_REFERENCE];
+type ToAssetIdWithChainId = {
+    chainNamespace?: never;
+    chainReference?: never;
+    chainId: ChainId;
+    assetNamespace: AssetNamespace;
+    assetReference: AssetReference | string;
+};
+type ToAssetIdWithChainIdParts = {
+    chainNamespace: ChainNamespace;
+    chainReference: ChainReference;
+    chainId?: never;
+    assetNamespace: AssetNamespace;
+    assetReference: AssetReference | string;
+};
+export type ToAssetIdArgs = ToAssetIdWithChainId | ToAssetIdWithChainIdParts;
+type ToAssetId = (args: ToAssetIdArgs) => AssetId;
+export declare const toAssetId: ToAssetId;
+type FromAssetIdReturn = {
+    chainNamespace: ChainNamespace;
+    chainReference: ChainReference;
+    chainId: ChainId;
+    assetNamespace: AssetNamespace;
+    assetReference: AssetReference;
+};
+export type FromAssetId = (assetId: AssetId) => FromAssetIdReturn;
+export declare const fromAssetId: FromAssetId;
+export declare const isNft: (assetId: AssetId) => boolean;
+export declare const toCAIP19: ToAssetId;
+export declare const fromCAIP19: FromAssetId;
+export {};

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

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

package/dist/{assetId → esm/assetId}/assetId.test.js

@@ -76,20 +76,6 @@ describe('assetId', () => {
             expect(toAssetId(omit(assetIdArgSuperset, 'chainId'))).toEqual(expected);
             expect(toAssetId(omit(assetIdArgSuperset, ['chainNamespace', 'chainReference']))).toEqual(expected);
         });
-        it('can make an IBC AssetId on CosmosHub', () => {
-            const chainNamespace = CHAIN_NAMESPACE.CosmosSdk;
-            const chainReference = CHAIN_REFERENCE.CosmosHubMainnet;
-            const assetIdArgSuperset = {
-                chainNamespace,
-                chainReference,
-                assetNamespace: 'ibc',
-                assetReference: '14F9BC3E44B8A9C1BE1FB08980FAB87034C9905EF17CF2F5008FC085218811CC',
-                chainId: toChainId({ chainNamespace, chainReference }),
-            };
-            const expected = 'cosmos:cosmoshub-4/ibc:14F9BC3E44B8A9C1BE1FB08980FAB87034C9905EF17CF2F5008FC085218811CC';
-            expect(toAssetId(omit(assetIdArgSuperset, 'chainId'))).toEqual(expected);
-            expect(toAssetId(omit(assetIdArgSuperset, ['chainNamespace', 'chainReference']))).toEqual(expected);
-        });
         it('throws with invalid Cosmos network', () => {
             const chainNamespace = CHAIN_NAMESPACE.CosmosSdk;
             const chainReference = CHAIN_REFERENCE.BitcoinMainnet;

package/dist/esm/chainId/chainId.d.ts

@@ -0,0 +1,20 @@
+import type { CHAIN_NAMESPACE, CHAIN_REFERENCE } from '../constants';
+import type { Nominal } from '../utils';
+export type ChainId = Nominal<string, 'ChainId'>;
+export type ChainNamespace = (typeof CHAIN_NAMESPACE)[keyof typeof CHAIN_NAMESPACE];
+export type ChainReference = (typeof CHAIN_REFERENCE)[keyof typeof CHAIN_REFERENCE];
+type ToChainIdArgs = {
+    chainNamespace: ChainNamespace;
+    chainReference: ChainReference;
+};
+export declare const toChainId: (args: ToChainIdArgs) => ChainId;
+export declare const fromChainId: (chainId: ChainId) => {
+    chainNamespace: ChainNamespace;
+    chainReference: ChainReference;
+};
+export declare const toCAIP2: (args: ToChainIdArgs) => ChainId;
+export declare const fromCAIP2: (chainId: ChainId) => {
+    chainNamespace: ChainNamespace;
+    chainReference: ChainReference;
+};
+export {};

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

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

package/dist/esm/constants.d.ts

@@ -0,0 +1,121 @@
+import type { AssetId, AssetNamespace } from './assetId/assetId';
+import type { ChainId, ChainNamespace, ChainReference } from './chainId/chainId';
+export declare const btcAssetId: AssetId;
+export declare const bchAssetId: AssetId;
+export declare const dogeAssetId: AssetId;
+export declare const ltcAssetId: AssetId;
+export declare const ethAssetId: AssetId;
+export declare const avalancheAssetId: AssetId;
+export declare const optimismAssetId: AssetId;
+export declare const bscAssetId: AssetId;
+export declare const polygonAssetId: AssetId;
+export declare const gnosisAssetId: AssetId;
+export declare const arbitrumAssetId: AssetId;
+export declare const arbitrumNovaAssetId: AssetId;
+export declare const baseAssetId: AssetId;
+export declare const solAssetId: AssetId;
+export declare const wrappedSolAssetId: AssetId;
+export declare const uniV2EthFoxArbitrumAssetId: AssetId;
+export declare const foxatarAssetId: AssetId;
+export declare const foxyAssetId: AssetId;
+export declare const foxOnGnosisAssetId: AssetId;
+export declare const foxOnArbitrumOneAssetId: AssetId;
+export declare const foxAssetId: AssetId;
+export declare const foxOnOptimismAssetId: AssetId;
+export declare const foxOnPolygonAssetId: AssetId;
+export declare const usdtAssetId: AssetId;
+export declare const usdcAssetId: AssetId;
+export declare const usdcOnArbitrumOneAssetId: AssetId;
+export declare const usdcOnSolanaAssetId: AssetId;
+export declare const flipAssetId: AssetId;
+export declare const foxWifHatAssetId: AssetId;
+export declare const cosmosAssetId: AssetId;
+export declare const thorchainAssetId: AssetId;
+export declare const tcyAssetId: AssetId;
+export declare const rujiAssetId: AssetId;
+export declare const mayachainAssetId: AssetId;
+export declare const binanceAssetId: AssetId;
+export declare const btcChainId: ChainId;
+export declare const bchChainId: ChainId;
+export declare const dogeChainId: ChainId;
+export declare const ltcChainId: ChainId;
+export declare const ethChainId: ChainId;
+export declare const avalancheChainId: ChainId;
+export declare const optimismChainId: ChainId;
+export declare const bscChainId: ChainId;
+export declare const polygonChainId: ChainId;
+export declare const gnosisChainId: ChainId;
+export declare const arbitrumChainId: ChainId;
+export declare const arbitrumNovaChainId: ChainId;
+export declare const baseChainId: ChainId;
+export declare const cosmosChainId: ChainId;
+export declare const thorchainChainId: ChainId;
+export declare const mayachainChainId: ChainId;
+export declare const binanceChainId: ChainId;
+export declare const solanaChainId: ChainId;
+export declare const CHAIN_NAMESPACE: {
+    readonly Evm: "eip155";
+    readonly Utxo: "bip122";
+    readonly CosmosSdk: "cosmos";
+    readonly Solana: "solana";
+};
+type ValidChainMap = {
+    [k in ChainNamespace]: ChainReference[];
+};
+export declare const CHAIN_REFERENCE: {
+    readonly EthereumMainnet: "1";
+    readonly BitcoinMainnet: "000000000019d6689c085ae165831e93";
+    readonly BitcoinCashMainnet: "000000000000000000651ef99cb9fcbe";
+    readonly DogecoinMainnet: "00000000001a91e3dace36e2be3bf030";
+    readonly LitecoinMainnet: "12a765e31ffd4059bada1e25190f6e98";
+    readonly CosmosHubMainnet: "cosmoshub-4";
+    readonly ThorchainMainnet: "thorchain-1";
+    readonly MayachainMainnet: "mayachain-mainnet-v1";
+    readonly BinanceMainnet: "binance-chain-tigris";
+    readonly AvalancheCChain: "43114";
+    readonly OptimismMainnet: "10";
+    readonly BnbSmartChainMainnet: "56";
+    readonly PolygonMainnet: "137";
+    readonly GnosisMainnet: "100";
+    readonly ArbitrumMainnet: "42161";
+    readonly ArbitrumNovaMainnet: "42170";
+    readonly BaseMainnet: "8453";
+    readonly SolanaMainnet: "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+};
+export declare const ASSET_NAMESPACE: {
+    readonly erc20: "erc20";
+    readonly erc721: "erc721";
+    readonly erc1155: "erc1155";
+    readonly bep20: "bep20";
+    readonly bep721: "bep721";
+    readonly bep1155: "bep1155";
+    readonly slip44: "slip44";
+    readonly splToken: "token";
+};
+export declare const ASSET_REFERENCE: {
+    readonly Bitcoin: "0";
+    readonly BitcoinCash: "145";
+    readonly Litecoin: "2";
+    readonly Dogecoin: "3";
+    readonly Cosmos: "118";
+    readonly Thorchain: "931";
+    readonly Mayachain: "931";
+    readonly Binance: "714";
+    readonly Ethereum: "60";
+    readonly AvalancheC: "60";
+    readonly Optimism: "60";
+    readonly BnbSmartChain: "60";
+    readonly Polygon: "60";
+    readonly Gnosis: "60";
+    readonly Arbitrum: "60";
+    readonly ArbitrumNova: "60";
+    readonly Base: "60";
+    readonly Solana: "501";
+};
+export declare const VALID_CHAIN_IDS: ValidChainMap;
+type ValidAssetNamespace = {
+    [k in ChainNamespace]: AssetNamespace[];
+};
+export declare const VALID_ASSET_NAMESPACE: ValidAssetNamespace;
+export declare const FEE_ASSET_IDS: AssetId[];
+export {};

package/dist/{constants.js → esm/constants.js}

@@ -30,6 +30,7 @@ export const foxWifHatAssetId = 'eip155:8453/erc20:0xd14acd73ade7f3c652f05365115
 export const cosmosAssetId = 'cosmos:cosmoshub-4/slip44:118';
 export const thorchainAssetId = 'cosmos:thorchain-1/slip44:931';
 export const tcyAssetId = 'cosmos:thorchain-1/slip44:tcy';
+export const rujiAssetId = 'cosmos:thorchain-1/slip44:ruji';
 export const mayachainAssetId = 'cosmos:mayachain-mainnet-v1/slip44:931';
 export const binanceAssetId = 'cosmos:binance-chain-tigris/slip44:714';
 export const btcChainId = 'bip122:000000000019d6689c085ae165831e93';
@@ -84,7 +85,6 @@ export const ASSET_NAMESPACE = {
     bep721: 'bep721',
     bep1155: 'bep1155',
     slip44: 'slip44',
-    ibc: 'ibc',
     splToken: 'token',
 };
 export const ASSET_REFERENCE = {
@@ -144,7 +144,7 @@ export const VALID_ASSET_NAMESPACE = Object.freeze({
         ASSET_NAMESPACE.bep721,
         ASSET_NAMESPACE.bep1155,
     ],
-    [CHAIN_NAMESPACE.CosmosSdk]: [ASSET_NAMESPACE.ibc, ASSET_NAMESPACE.slip44],
+    [CHAIN_NAMESPACE.CosmosSdk]: [ASSET_NAMESPACE.slip44],
     [CHAIN_NAMESPACE.Solana]: [ASSET_NAMESPACE.splToken, ASSET_NAMESPACE.slip44],
 });
 // We should prob change this once we add more chains

package/dist/esm/index.js

@@ -0,0 +1,7 @@
+export * as adapters from './adapters';
+export * from './chainId/chainId';
+export * from './accountId/accountId';
+export * from './assetId/assetId';
+export * from './utils';
+export * from './constants';
+export * from './typeGuards';

package/dist/esm/typeGuards.d.ts

@@ -0,0 +1,16 @@
+import type { AssetId, AssetNamespace, AssetReference } from './assetId/assetId';
+import type { ChainId, ChainNamespace, ChainReference } from './chainId/chainId';
+export declare const isChainNamespace: (maybeChainNamespace: ChainNamespace | string) => maybeChainNamespace is ChainNamespace;
+export declare const isChainReference: (maybeChainReference: ChainReference | string) => maybeChainReference is ChainReference;
+export declare const isAssetNamespace: (maybeAssetNamespace: AssetNamespace | string) => maybeAssetNamespace is AssetNamespace;
+export declare const isAssetReference: (maybeAssetReference: AssetReference | string) => maybeAssetReference is AssetReference;
+export declare const isAssetId: (maybeAssetId: AssetId | string) => maybeAssetId is AssetId;
+export declare const isAssetIdParts: (maybeChainNamespace: string, maybeChainReference: string, maybeAssetNamespace: string) => boolean;
+export declare const isChainId: (maybeChainId: ChainId | string) => maybeChainId is ChainId;
+export declare const isChainIdParts: (chainNamespace: string, chainReference: string) => boolean;
+export declare const assertIsChainId: (value: ChainId | string | undefined) => asserts value is ChainId;
+export declare const assertIsChainNamespace: (value: ChainNamespace | string | undefined) => asserts value is ChainNamespace;
+export declare const assertIsChainReference: (value: ChainReference | string | undefined) => asserts value is ChainReference;
+export declare const assertIsAssetNamespace: (value: AssetNamespace | string | undefined) => asserts value is AssetNamespace;
+export declare const assertIsAssetReference: (value: AssetReference | string | undefined) => asserts value is AssetReference;
+export declare const assertValidChainPartsPair: (chainNamespace: ChainNamespace, chainReference: ChainReference) => void;

package/dist/esm/utils.d.ts

@@ -0,0 +1,33 @@
+import type { AccountId } from './accountId/accountId';
+import type { AssetId } from './assetId/assetId';
+import type { ChainId, ChainNamespace, ChainReference } from './chainId/chainId';
+export declare const accountIdToChainId: (accountId: AccountId) => ChainId;
+export declare const accountIdToSpecifier: (accountId: AccountId) => string;
+export declare const isValidChainPartsPair: (chainNamespace: ChainNamespace, chainReference: ChainReference) => boolean;
+export declare const generateAssetIdFromCosmosSdkDenom: (denom: string) => AssetId;
+export declare const bitcoinAssetMap: {
+    [x: string]: string;
+};
+export declare const bitcoinCashAssetMap: {
+    [x: string]: string;
+};
+export declare const dogecoinAssetMap: {
+    [x: string]: string;
+};
+export declare const litecoinAssetMap: {
+    [x: string]: string;
+};
+export declare const cosmosAssetMap: {
+    [x: string]: string;
+};
+export declare const thorchainAssetMap: {
+    [x: string]: string;
+};
+export declare const mayachainAssetMap: {
+    [x: string]: string;
+};
+interface Flavoring<FlavorT> {
+    _type?: FlavorT;
+}
+export type Nominal<T, FlavorT> = T & Flavoring<FlavorT>;
+export {};

package/dist/{utils.js → esm/utils.js}

@@ -1,24 +1,21 @@
 import { fromAccountId } from './accountId/accountId';
-import { fromAssetId, toAssetId } from './assetId/assetId';
 import * as constants from './constants';
-import { tcyAssetId } from './constants';
+import { rujiAssetId, tcyAssetId } from './constants';
 const mayaTokenAssetId = 'cosmos:mayachain-mainnet-v1/slip44:maya';
 export const accountIdToChainId = (accountId) => fromAccountId(accountId).chainId;
 export const accountIdToSpecifier = (accountId) => fromAccountId(accountId).account;
 export const isValidChainPartsPair = (chainNamespace, chainReference) => constants.VALID_CHAIN_IDS[chainNamespace]?.includes(chainReference) || false;
-export const generateAssetIdFromCosmosSdkDenom = (denom, nativeAssetId) => {
-    if (denom === 'tcy')
-        return tcyAssetId;
-    if (denom === 'maya')
-        return mayaTokenAssetId;
-    if (denom.startsWith('ibc')) {
-        return toAssetId({
-            assetNamespace: constants.ASSET_NAMESPACE.ibc,
-            assetReference: denom.split('/')[1],
-            chainId: fromAssetId(nativeAssetId).chainId,
-        });
+export const generateAssetIdFromCosmosSdkDenom = (denom) => {
+    switch (denom) {
+        case 'tcy':
+            return tcyAssetId;
+        case 'x/ruji':
+            return rujiAssetId;
+        case 'maya':
+            return mayaTokenAssetId;
+        default:
+            throw new Error(`Unsupported denom: ${denom}`);
     }
-    return nativeAssetId;
 };
 export const bitcoinAssetMap = { [constants.btcAssetId]: 'bitcoin' };
 export const bitcoinCashAssetMap = { [constants.bchAssetId]: 'bitcoin-cash' };

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

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

package/dist/{utils.test.js → esm/utils.test.js}

@@ -1,6 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { toAssetId } from './assetId/assetId';
-import { ASSET_NAMESPACE, ASSET_REFERENCE, btcAssetId, btcChainId, CHAIN_NAMESPACE, CHAIN_REFERENCE, cosmosAssetId, cosmosChainId, ethAssetId, ethChainId, } from './constants';
+import { ASSET_NAMESPACE, ASSET_REFERENCE, btcAssetId, btcChainId, CHAIN_NAMESPACE, CHAIN_REFERENCE, cosmosAssetId, cosmosChainId, ethAssetId, ethChainId, rujiAssetId, tcyAssetId, } from './constants';
 import { assertIsAssetNamespace, assertIsAssetReference, assertIsChainId, assertIsChainNamespace, assertIsChainReference, assertValidChainPartsPair, isAssetId, isAssetNamespace, isAssetReference, isChainId, isChainNamespace, isChainReference, } from './typeGuards';
 import { accountIdToChainId, accountIdToSpecifier, generateAssetIdFromCosmosSdkDenom, isValidChainPartsPair, } from './utils';
 describe('accountIdToChainId', () => {
@@ -140,23 +139,20 @@ describe('type guard assertion', () => {
         });
     });
     describe('generateAssetIdFromCosmosDenom', () => {
-        it('correctly generates ATOM native asset id', () => {
-            const nativeAssetId = toAssetId({
-                assetNamespace: ASSET_NAMESPACE.slip44,
-                assetReference: ASSET_REFERENCE.Cosmos,
-                chainId: cosmosChainId,
-            });
-            const result = generateAssetIdFromCosmosSdkDenom('uatom', cosmosAssetId);
-            expect(result).toEqual(nativeAssetId);
-        });
-        it('correctly generates cosmoshub IBC asset id', () => {
-            const ibcAssetId = toAssetId({
-                assetNamespace: ASSET_NAMESPACE.ibc,
-                assetReference: '14F9BC3E44B8A9C1BE1FB08980FAB87034C9905EF17CF2F5008FC085218811CC',
-                chainId: cosmosChainId,
-            });
-            const result = generateAssetIdFromCosmosSdkDenom('ibc/14F9BC3E44B8A9C1BE1FB08980FAB87034C9905EF17CF2F5008FC085218811CC', cosmosAssetId);
-            expect(result).toEqual(ibcAssetId);
+        it('correctly generates RUJI AssetId', () => {
+            const result = generateAssetIdFromCosmosSdkDenom('x/ruji');
+            expect(result).toEqual(rujiAssetId);
+        });
+        it('correctly generates TCY AssetId', () => {
+            const result = generateAssetIdFromCosmosSdkDenom('tcy');
+            expect(result).toEqual(tcyAssetId);
+        });
+        it('correctly generates MAYA AssetId', () => {
+            const result = generateAssetIdFromCosmosSdkDenom('maya');
+            expect(result).toEqual('cosmos:mayachain-mainnet-v1/slip44:maya');
+        });
+        it('throws on unsupported denom', () => {
+            expect(() => generateAssetIdFromCosmosSdkDenom('unsupported')).toThrow();
         });
     });
 });

package/package.json

@@ -1,11 +1,20 @@
 {
   "name": "@shapeshiftoss/caip",
-  "version": "8.16.1",
+  "version": "9.0.0-alpha.0",
   "description": "CAIP Implementation",
   "repository": "https://github.com/shapeshift/web",
   "license": "MIT",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "type": "module",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js",
+      "types": "./dist/esm/index.d.ts"
+    }
+  },
   "files": [
     "dist"
   ],
@@ -13,11 +22,12 @@
     "access": "public"
   },
   "scripts": {
-    "build": "yarn clean && yarn run -T tsc --build",
-    "clean": "rm -rf dist tsconfig.tsbuildinfo",
+    "build": "yarn clean && yarn run -T tsc --build && yarn postbuild",
+    "clean": "rm -rf dist",
     "dev": "yarn run -T tsc --build --watch",
     "generate": "yarn generate:coingecko && yarn generate:coincap",
     "generate:coingecko": "yarn build && yarn run -T tsx src/adapters/coingecko/generate.ts",
-    "generate:coincap": "yarn build && yarn run -T tsx src/adapters/coincap/generate.ts"
+    "generate:coincap": "yarn build && yarn run -T tsx src/adapters/coincap/generate.ts",
+    "postbuild": "echo '{\"type\": \"commonjs\"}' > dist/cjs/package.json"
   }
-}
+}