@shapeshiftoss/caip 8.16.4 → 8.16.5

package/dist/esm/constants.d.ts

@@ -0,0 +1,135 @@
+import type { AssetId, AssetNamespace } from './assetId/assetId.js';
+import type { ChainId, ChainNamespace, ChainReference } from './chainId/chainId.js';
+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 monadAssetId: AssetId;
+export declare const solAssetId: AssetId;
+export declare const wrappedSolAssetId: AssetId;
+export declare const tronAssetId: AssetId;
+export declare const suiAssetId: 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 monadChainId: 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 tronChainId: ChainId;
+export declare const suiChainId: ChainId;
+export declare const CHAIN_NAMESPACE: {
+    readonly Evm: "eip155";
+    readonly Utxo: "bip122";
+    readonly CosmosSdk: "cosmos";
+    readonly Solana: "solana";
+    readonly Tron: "tron";
+    readonly Sui: "sui";
+};
+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 MonadMainnet: "143";
+    readonly SolanaMainnet: "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+    readonly TronMainnet: "0x2b6653dc";
+    readonly SuiMainnet: "35834a8a";
+};
+export declare const ASSET_NAMESPACE: {
+    readonly erc20: "erc20";
+    readonly erc721: "erc721";
+    readonly erc1155: "erc1155";
+    readonly slip44: "slip44";
+    readonly splToken: "token";
+    readonly trc20: "trc20";
+    readonly trc10: "trc10";
+    readonly suiCoin: "coin";
+};
+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 Monad: "60";
+    readonly Solana: "501";
+    readonly Tron: "195";
+    readonly Sui: "784";
+};
+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/esm/constants.js

@@ -0,0 +1,188 @@
+export const btcAssetId = 'bip122:000000000019d6689c085ae165831e93/slip44:0';
+export const bchAssetId = 'bip122:000000000000000000651ef99cb9fcbe/slip44:145';
+export const dogeAssetId = 'bip122:00000000001a91e3dace36e2be3bf030/slip44:3';
+export const ltcAssetId = 'bip122:12a765e31ffd4059bada1e25190f6e98/slip44:2';
+export const ethAssetId = 'eip155:1/slip44:60';
+export const avalancheAssetId = 'eip155:43114/slip44:60';
+export const optimismAssetId = 'eip155:10/slip44:60';
+export const bscAssetId = 'eip155:56/slip44:60';
+export const polygonAssetId = 'eip155:137/slip44:60';
+export const gnosisAssetId = 'eip155:100/slip44:60';
+export const arbitrumAssetId = 'eip155:42161/slip44:60';
+export const arbitrumNovaAssetId = 'eip155:42170/slip44:60';
+export const baseAssetId = 'eip155:8453/slip44:60';
+export const monadAssetId = 'eip155:143/slip44:60';
+export const solAssetId = 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp/slip44:501';
+export const wrappedSolAssetId = 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp/token:So11111111111111111111111111111111111111112';
+export const tronAssetId = 'tron:0x2b6653dc/slip44:195';
+export const suiAssetId = 'sui:35834a8a/slip44:784';
+export const uniV2EthFoxArbitrumAssetId = 'eip155:42161/erc20:0x5f6ce0ca13b87bd738519545d3e018e70e339c24';
+export const foxatarAssetId = 'eip155:137/erc721:0x2e727c425a11ce6b8819b3004db332c12d2af2a2';
+export const foxyAssetId = 'eip155:1/erc20:0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3';
+export const foxOnGnosisAssetId = 'eip155:100/erc20:0x21a42669643f45bc0e086b8fc2ed70c23d67509d';
+export const foxOnArbitrumOneAssetId = 'eip155:42161/erc20:0xf929de51d91c77e42f5090069e0ad7a09e513c73';
+export const foxAssetId = 'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d';
+export const foxOnOptimismAssetId = 'eip155:10/erc20:0xf1a0da3367bc7aa04f8d94ba57b862ff37ced174';
+export const foxOnPolygonAssetId = 'eip155:137/erc20:0x65a05db8322701724c197af82c9cae41195b0aa8';
+export const usdtAssetId = 'eip155:1/erc20:0xdac17f958d2ee523a2206206994597c13d831ec7';
+export const usdcAssetId = 'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48';
+export const usdcOnArbitrumOneAssetId = 'eip155:42161/erc20:0xaf88d065e77c8cc2239327c5edb3a432268e5831';
+export const usdcOnSolanaAssetId = 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp/token:EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v';
+export const flipAssetId = 'eip155:1/erc20:0x826180541412d574cf1336d22c0c0a287822678a';
+export const foxWifHatAssetId = 'eip155:8453/erc20:0xd14acd73ade7f3c652f05365115f015e905a6bf4';
+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';
+export const bchChainId = 'bip122:000000000000000000651ef99cb9fcbe';
+export const dogeChainId = 'bip122:00000000001a91e3dace36e2be3bf030';
+export const ltcChainId = 'bip122:12a765e31ffd4059bada1e25190f6e98';
+export const ethChainId = 'eip155:1';
+export const avalancheChainId = 'eip155:43114';
+export const optimismChainId = 'eip155:10';
+export const bscChainId = 'eip155:56';
+export const polygonChainId = 'eip155:137';
+export const gnosisChainId = 'eip155:100';
+export const arbitrumChainId = 'eip155:42161';
+export const arbitrumNovaChainId = 'eip155:42170';
+export const baseChainId = 'eip155:8453';
+export const monadChainId = 'eip155:143';
+export const cosmosChainId = 'cosmos:cosmoshub-4';
+export const thorchainChainId = 'cosmos:thorchain-1';
+export const mayachainChainId = 'cosmos:mayachain-mainnet-v1';
+export const binanceChainId = 'cosmos:binance-chain-tigris';
+export const solanaChainId = 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp';
+export const tronChainId = 'tron:0x2b6653dc';
+export const suiChainId = 'sui:35834a8a';
+export const CHAIN_NAMESPACE = {
+    Evm: 'eip155',
+    Utxo: 'bip122',
+    CosmosSdk: 'cosmos',
+    Solana: 'solana',
+    Tron: 'tron',
+    Sui: 'sui',
+};
+export const CHAIN_REFERENCE = {
+    EthereumMainnet: '1',
+    BitcoinMainnet: '000000000019d6689c085ae165831e93',
+    BitcoinCashMainnet: '000000000000000000651ef99cb9fcbe',
+    DogecoinMainnet: '00000000001a91e3dace36e2be3bf030',
+    LitecoinMainnet: '12a765e31ffd4059bada1e25190f6e98',
+    CosmosHubMainnet: 'cosmoshub-4',
+    ThorchainMainnet: 'thorchain-1',
+    MayachainMainnet: 'mayachain-mainnet-v1',
+    BinanceMainnet: 'binance-chain-tigris',
+    AvalancheCChain: '43114',
+    OptimismMainnet: '10',
+    BnbSmartChainMainnet: '56',
+    PolygonMainnet: '137',
+    GnosisMainnet: '100',
+    ArbitrumMainnet: '42161',
+    ArbitrumNovaMainnet: '42170',
+    BaseMainnet: '8453',
+    MonadMainnet: '143',
+    SolanaMainnet: '5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+    TronMainnet: '0x2b6653dc',
+    SuiMainnet: '35834a8a', // First 8 chars of SUI mainnet genesis hash
+};
+export const ASSET_NAMESPACE = {
+    erc20: 'erc20',
+    erc721: 'erc721',
+    erc1155: 'erc1155',
+    slip44: 'slip44',
+    splToken: 'token',
+    trc20: 'trc20',
+    trc10: 'trc10',
+    suiCoin: 'coin',
+};
+export const ASSET_REFERENCE = {
+    Bitcoin: '0',
+    BitcoinCash: '145',
+    Litecoin: '2',
+    Dogecoin: '3',
+    Cosmos: '118',
+    Thorchain: '931',
+    Mayachain: '931',
+    Binance: '714',
+    Ethereum: '60',
+    AvalancheC: '60',
+    Optimism: '60',
+    BnbSmartChain: '60',
+    Polygon: '60',
+    Gnosis: '60',
+    Arbitrum: '60',
+    ArbitrumNova: '60',
+    Base: '60',
+    Monad: '60',
+    Solana: '501',
+    Tron: '195',
+    Sui: '784',
+};
+export const VALID_CHAIN_IDS = Object.freeze({
+    [CHAIN_NAMESPACE.Utxo]: [
+        CHAIN_REFERENCE.BitcoinMainnet,
+        CHAIN_REFERENCE.BitcoinCashMainnet,
+        CHAIN_REFERENCE.DogecoinMainnet,
+        CHAIN_REFERENCE.LitecoinMainnet,
+    ],
+    [CHAIN_NAMESPACE.Evm]: [
+        CHAIN_REFERENCE.EthereumMainnet,
+        CHAIN_REFERENCE.AvalancheCChain,
+        CHAIN_REFERENCE.OptimismMainnet,
+        CHAIN_REFERENCE.BnbSmartChainMainnet,
+        CHAIN_REFERENCE.PolygonMainnet,
+        CHAIN_REFERENCE.GnosisMainnet,
+        CHAIN_REFERENCE.ArbitrumMainnet,
+        CHAIN_REFERENCE.ArbitrumNovaMainnet,
+        CHAIN_REFERENCE.BaseMainnet,
+        CHAIN_REFERENCE.MonadMainnet,
+    ],
+    [CHAIN_NAMESPACE.CosmosSdk]: [
+        CHAIN_REFERENCE.CosmosHubMainnet,
+        CHAIN_REFERENCE.ThorchainMainnet,
+        CHAIN_REFERENCE.MayachainMainnet,
+        CHAIN_REFERENCE.BinanceMainnet,
+    ],
+    [CHAIN_NAMESPACE.Solana]: [CHAIN_REFERENCE.SolanaMainnet],
+    [CHAIN_NAMESPACE.Tron]: [CHAIN_REFERENCE.TronMainnet],
+    [CHAIN_NAMESPACE.Sui]: [CHAIN_REFERENCE.SuiMainnet],
+});
+export const VALID_ASSET_NAMESPACE = Object.freeze({
+    [CHAIN_NAMESPACE.Utxo]: [ASSET_NAMESPACE.slip44],
+    [CHAIN_NAMESPACE.Evm]: [
+        ASSET_NAMESPACE.slip44,
+        ASSET_NAMESPACE.erc20,
+        ASSET_NAMESPACE.erc721,
+        ASSET_NAMESPACE.erc1155,
+    ],
+    [CHAIN_NAMESPACE.CosmosSdk]: [ASSET_NAMESPACE.slip44],
+    [CHAIN_NAMESPACE.Solana]: [ASSET_NAMESPACE.splToken, ASSET_NAMESPACE.slip44],
+    [CHAIN_NAMESPACE.Tron]: [ASSET_NAMESPACE.slip44, ASSET_NAMESPACE.trc20],
+    [CHAIN_NAMESPACE.Sui]: [ASSET_NAMESPACE.slip44, ASSET_NAMESPACE.suiCoin],
+});
+// We should prob change this once we add more chains
+export const FEE_ASSET_IDS = [
+    ethAssetId,
+    btcAssetId,
+    bchAssetId,
+    cosmosAssetId,
+    thorchainAssetId,
+    mayachainAssetId,
+    dogeAssetId,
+    ltcAssetId,
+    avalancheAssetId,
+    optimismAssetId,
+    bscAssetId,
+    polygonAssetId,
+    gnosisAssetId,
+    arbitrumAssetId,
+    arbitrumNovaAssetId,
+    baseAssetId,
+    monadAssetId,
+    solAssetId,
+    tronAssetId,
+    suiAssetId,
+];

package/dist/esm/index.d.ts

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

package/dist/esm/index.js

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

package/dist/esm/typeGuards.d.ts

@@ -0,0 +1,16 @@
+import type { AssetId, AssetNamespace, AssetReference } from './assetId/assetId.js';
+import type { ChainId, ChainNamespace, ChainReference } from './chainId/chainId.js';
+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/typeGuards.js

@@ -0,0 +1,44 @@
+import { fromChainId } from './chainId/chainId.js';
+import { ASSET_NAMESPACE, ASSET_REFERENCE, CHAIN_NAMESPACE, CHAIN_REFERENCE, VALID_CHAIN_IDS, } from './constants.js';
+import { isValidChainPartsPair } from './utils.js';
+export const isChainNamespace = (maybeChainNamespace) => Object.values(CHAIN_NAMESPACE).includes(maybeChainNamespace);
+export const isChainReference = (maybeChainReference) => Object.values(CHAIN_REFERENCE).includes(maybeChainReference);
+export const isAssetNamespace = (maybeAssetNamespace) => Object.values(ASSET_NAMESPACE).includes(maybeAssetNamespace);
+export const isAssetReference = (maybeAssetReference) => Object.values(ASSET_REFERENCE).includes(maybeAssetReference);
+// NOTE: perf critical - benchmark any changes
+export const isAssetId = (maybeAssetId) => {
+    const slashIdx = maybeAssetId.indexOf('/');
+    const chainId = maybeAssetId.substring(0, slashIdx);
+    const assetParts = maybeAssetId.substring(slashIdx + 1);
+    const { chainNamespace, chainReference } = fromChainId(chainId);
+    const idx = assetParts.indexOf(':');
+    const assetNamespace = assetParts.substring(0, idx);
+    return isAssetIdParts(chainNamespace, chainReference, assetNamespace);
+};
+// NOTE: perf critical - benchmark any changes
+export const isAssetIdParts = (maybeChainNamespace, maybeChainReference, maybeAssetNamespace) => {
+    return (!!VALID_CHAIN_IDS[maybeChainNamespace]?.includes(maybeChainReference) && isAssetNamespace(maybeAssetNamespace));
+};
+// NOTE: perf critical - benchmark any changes
+export const isChainId = (maybeChainId) => {
+    const { chainNamespace, chainReference } = fromChainId(maybeChainId);
+    return !!VALID_CHAIN_IDS[chainNamespace]?.includes(chainReference);
+};
+export const isChainIdParts = (chainNamespace, chainReference) => {
+    return !!VALID_CHAIN_IDS[chainNamespace]?.includes(chainReference);
+};
+const getTypeGuardAssertion = (typeGuard, message) => {
+    return (value) => {
+        if ((value && !typeGuard(value)) || !value)
+            throw new Error(`${message}: ${value}`);
+    };
+};
+export const assertIsChainId = getTypeGuardAssertion(isChainId, 'assertIsChainId: unsupported ChainId');
+export const assertIsChainNamespace = getTypeGuardAssertion(isChainNamespace, 'assertIsChainNamespace: unsupported ChainNamespace');
+export const assertIsChainReference = getTypeGuardAssertion(isChainReference, 'assertIsChainReference: unsupported ChainReference');
+export const assertIsAssetNamespace = getTypeGuardAssertion(isAssetNamespace, 'assertIsAssetNamespace: unsupported AssetNamespace');
+export const assertIsAssetReference = getTypeGuardAssertion(isAssetReference, 'assertIsAssetReference: unsupported AssetReference');
+export const assertValidChainPartsPair = (chainNamespace, chainReference) => {
+    if (!isValidChainPartsPair(chainNamespace, chainReference))
+        throw new Error(`toAssetId: Chain Reference ${chainReference} not supported for Chain Namespace ${chainNamespace}`);
+};

package/dist/esm/utils.d.ts

@@ -0,0 +1,33 @@
+import type { AccountId } from './accountId/accountId.js';
+import type { AssetId } from './assetId/assetId.js';
+import type { ChainId, ChainNamespace, ChainReference } from './chainId/chainId.js';
+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/esm/utils.js

@@ -0,0 +1,26 @@
+import { fromAccountId } from './accountId/accountId.js';
+import * as constants from './constants.js';
+import { rujiAssetId, tcyAssetId } from './constants.js';
+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) => {
+    switch (denom) {
+        case 'tcy':
+            return tcyAssetId;
+        case 'x/ruji':
+            return rujiAssetId;
+        case 'maya':
+            return mayaTokenAssetId;
+        default:
+            throw new Error(`Unsupported denom: ${denom}`);
+    }
+};
+export const bitcoinAssetMap = { [constants.btcAssetId]: 'bitcoin' };
+export const bitcoinCashAssetMap = { [constants.bchAssetId]: 'bitcoin-cash' };
+export const dogecoinAssetMap = { [constants.dogeAssetId]: 'dogecoin' };
+export const litecoinAssetMap = { [constants.ltcAssetId]: 'litecoin' };
+export const cosmosAssetMap = { [constants.cosmosAssetId]: 'cosmos' };
+export const thorchainAssetMap = { [constants.thorchainAssetId]: 'thorchain' };
+export const mayachainAssetMap = { [constants.mayachainAssetId]: 'cacao' };

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

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

package/dist/esm/utils.test.js

@@ -0,0 +1,158 @@
+import { describe, expect, it } from 'vitest';
+import { ASSET_NAMESPACE, ASSET_REFERENCE, btcAssetId, btcChainId, CHAIN_NAMESPACE, CHAIN_REFERENCE, cosmosAssetId, cosmosChainId, ethAssetId, ethChainId, rujiAssetId, tcyAssetId, } from './constants.js';
+import { assertIsAssetNamespace, assertIsAssetReference, assertIsChainId, assertIsChainNamespace, assertIsChainReference, assertValidChainPartsPair, isAssetId, isAssetNamespace, isAssetReference, isChainId, isChainNamespace, isChainReference, } from './typeGuards.js';
+import { accountIdToChainId, accountIdToSpecifier, generateAssetIdFromCosmosSdkDenom, isValidChainPartsPair, } from './utils.js';
+describe('accountIdToChainId', () => {
+    it('can get eth chainId from accountId', () => {
+        const accountId = 'eip155:1:0xdef1cafe';
+        const chainId = accountIdToChainId(accountId);
+        expect(chainId).toEqual(ethChainId);
+    });
+    it('can get btc chainId from accountId', () => {
+        const accountId = 'bip122:000000000019d6689c085ae165831e93:xpubfoobarbaz';
+        const chainId = accountIdToChainId(accountId);
+        expect(chainId).toEqual(btcChainId);
+    });
+});
+describe('accountIdToSpecifier', () => {
+    it('can get eth address from accountId', () => {
+        const address = '0xdef1cafe';
+        const accountId = 'eip155:1:0xdef1cafe';
+        const result = accountIdToSpecifier(accountId);
+        expect(result).toEqual(address);
+    });
+    it('can get xpub from accountId', () => {
+        const xpub = 'xpubfoobarbaz';
+        const accountId = 'bip122:000000000019d6689c085ae165831e93:xpubfoobarbaz';
+        const result = accountIdToSpecifier(accountId);
+        expect(result).toEqual(xpub);
+    });
+});
+describe('isValidChainPartsPair', () => {
+    it('correctly validates pairs', () => {
+        expect(isValidChainPartsPair(CHAIN_NAMESPACE.Utxo, CHAIN_REFERENCE.BitcoinMainnet)).toEqual(true);
+        expect(isValidChainPartsPair(CHAIN_NAMESPACE.Evm, CHAIN_REFERENCE.BitcoinMainnet)).toEqual(false);
+        expect(isValidChainPartsPair('invalid', CHAIN_REFERENCE.BitcoinMainnet)).toEqual(false);
+        expect(isValidChainPartsPair(CHAIN_NAMESPACE.Evm, 'invalid')).toEqual(false);
+    });
+});
+describe('type guard', () => {
+    describe('isChainNamespace', () => {
+        it('correctly determines type', () => {
+            expect(isChainNamespace(CHAIN_NAMESPACE.Utxo)).toEqual(true);
+            expect(isChainNamespace(CHAIN_NAMESPACE.Evm)).toEqual(true);
+            expect(isChainNamespace('invalid')).toEqual(false);
+            expect(isChainNamespace('')).toEqual(false);
+        });
+    });
+    describe('isChainReference', () => {
+        it('correctly determines type', () => {
+            expect(isChainReference(CHAIN_REFERENCE.EthereumMainnet)).toEqual(true);
+            expect(isChainReference(CHAIN_REFERENCE.BitcoinMainnet)).toEqual(true);
+            expect(isChainReference('invalid')).toEqual(false);
+            expect(isChainReference('')).toEqual(false);
+        });
+    });
+    describe('isValidChainId', () => {
+        it('correctly determines type', () => {
+            expect(isChainId(ethChainId)).toEqual(true);
+            expect(isChainId(btcChainId)).toEqual(true);
+            expect(isChainId(cosmosChainId)).toEqual(true);
+            expect(isChainId('invalid')).toEqual(false);
+            expect(isChainId('')).toEqual(false);
+        });
+    });
+    describe('isAssetNamespace', () => {
+        it('correctly determines type', () => {
+            expect(isAssetNamespace(ASSET_NAMESPACE.erc20)).toEqual(true);
+            expect(isAssetNamespace(ASSET_NAMESPACE.erc721)).toEqual(true);
+            expect(isAssetNamespace('invalid')).toEqual(false);
+            expect(isAssetNamespace('')).toEqual(false);
+        });
+    });
+    describe('isAssetReference', () => {
+        it('correctly determines type', () => {
+            expect(isAssetReference(ASSET_REFERENCE.Bitcoin)).toEqual(true);
+            expect(isAssetReference(ASSET_REFERENCE.Ethereum)).toEqual(true);
+            expect(isAssetReference('invalid')).toEqual(false);
+            expect(isAssetReference('')).toEqual(false);
+        });
+    });
+    describe('isAssetId', () => {
+        it('correctly determines type', () => {
+            expect(isAssetId(btcAssetId)).toEqual(true);
+            expect(isAssetId(ethAssetId)).toEqual(true);
+            expect(isAssetId(cosmosAssetId)).toEqual(true);
+            expect(isAssetId('invalid')).toEqual(false);
+            expect(isAssetId('')).toEqual(false);
+        });
+    });
+});
+describe('type guard assertion', () => {
+    describe('assertIsChainId', () => {
+        it('correctly asserts type', () => {
+            expect(() => assertIsChainId(ethChainId)).not.toThrow();
+            expect(() => assertIsChainId(btcChainId)).not.toThrow();
+            expect(() => assertIsChainId(cosmosChainId)).not.toThrow();
+            expect(() => assertIsChainId('invalid')).toThrow();
+            expect(() => assertIsChainId('')).toThrow();
+        });
+    });
+    describe('assertIsChainNamespace', () => {
+        it('correctly asserts type', () => {
+            expect(() => assertIsChainNamespace(CHAIN_NAMESPACE.Utxo)).not.toThrow();
+            expect(() => assertIsChainNamespace(CHAIN_NAMESPACE.Evm)).not.toThrow();
+            expect(() => assertIsChainNamespace('invalid')).toThrow();
+            expect(() => assertIsChainNamespace('')).toThrow();
+        });
+    });
+    describe('assertIsChainReference', () => {
+        it('correctly asserts type', () => {
+            expect(() => assertIsChainReference(CHAIN_REFERENCE.EthereumMainnet)).not.toThrow();
+            expect(() => assertIsChainReference(CHAIN_REFERENCE.BitcoinMainnet)).not.toThrow();
+            expect(() => assertIsChainReference('invalid')).toThrow();
+            expect(() => assertIsChainReference('')).toThrow();
+        });
+    });
+    describe('assertIsAssetNamespace', () => {
+        it('correctly asserts type', () => {
+            expect(() => assertIsAssetNamespace(ASSET_NAMESPACE.erc20)).not.toThrow();
+            expect(() => assertIsAssetNamespace(ASSET_NAMESPACE.erc721)).not.toThrow();
+            expect(() => assertIsAssetNamespace('invalid')).toThrow();
+            expect(() => assertIsAssetNamespace('')).toThrow();
+        });
+    });
+    describe('assertIsAssetReference', () => {
+        it('correctly asserts type', () => {
+            expect(() => assertIsAssetReference(ASSET_REFERENCE.Bitcoin)).not.toThrow();
+            expect(() => assertIsAssetReference(ASSET_REFERENCE.Ethereum)).not.toThrow();
+            expect(() => assertIsAssetReference('invalid')).toThrow();
+            expect(() => assertIsAssetReference('')).toThrow();
+        });
+    });
+    describe('assertValidChainPartsPair', () => {
+        it('correctly asserts type', () => {
+            expect(() => assertValidChainPartsPair(CHAIN_NAMESPACE.Utxo, CHAIN_REFERENCE.BitcoinMainnet)).not.toThrow();
+            expect(() => assertValidChainPartsPair(CHAIN_NAMESPACE.Utxo, CHAIN_REFERENCE.EthereumMainnet)).toThrow();
+            expect(() => assertValidChainPartsPair('invalid', CHAIN_REFERENCE.BitcoinMainnet)).toThrow();
+            expect(() => assertValidChainPartsPair(CHAIN_NAMESPACE.Evm, 'invalid')).toThrow();
+        });
+    });
+    describe('generateAssetIdFromCosmosDenom', () => {
+        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,6 +1,6 @@
 {
   "name": "@shapeshiftoss/caip",
-  "version": "8.16.4",
+  "version": "8.16.5",
   "description": "CAIP Implementation",
   "repository": "https://github.com/shapeshift/web",
   "license": "MIT",