@shapeshiftoss/caip 8.16.4 → 8.16.5

package/dist/esm/assetId/assetId.js

@@ -0,0 +1,114 @@
+// https://github.com/ChainAgnostic/CAIPs/blob/master/CAIPs/caip-19.md
+import { fromChainId, toChainId } from '../chainId/chainId.js';
+import { VALID_ASSET_NAMESPACE } from '../constants.js';
+import { assertIsAssetNamespace, assertIsChainNamespace, assertIsChainReference, assertValidChainPartsPair, isAssetIdParts, isAssetNamespace, } from '../typeGuards.js';
+/**
+ * validate that a value is a string slip44 value
+ * @see https://github.com/satoshilabs/slips/blob/master/slip-0044.md
+ * @param {string} value - possible slip44 value
+ */
+const isValidSlip44 = (value) => {
+    // TCY is a weird AssetId, its asset ref part is not a number
+    if (value === 'tcy')
+        return true;
+    const n = Number(value);
+    // slip44 has a max value of an unsigned 32-bit integer
+    return !isNaN(n) && n >= 0 && n < 4294967296;
+};
+const isToAssetIdWithChainIdArgs = (args) => !!args.chainId;
+export const toAssetId = (args) => {
+    const { assetNamespace, assetReference } = args;
+    assertIsAssetNamespace(assetNamespace);
+    if (!assetReference)
+        throw new Error('toAssetId: No assetReference provided');
+    const { chainId, chainNamespace, chainReference } = (() => {
+        if (isToAssetIdWithChainIdArgs(args)) {
+            const fromChainIdResult = fromChainId(args.chainId);
+            return {
+                chainId: args.chainId,
+                chainNamespace: fromChainIdResult.chainNamespace,
+                chainReference: fromChainIdResult.chainReference,
+            };
+        }
+        else
+            return {
+                chainId: toChainId({
+                    chainNamespace: args.chainNamespace,
+                    chainReference: args.chainReference,
+                }),
+                chainNamespace: args.chainNamespace,
+                chainReference: args.chainReference,
+            };
+    })();
+    assertIsChainNamespace(chainNamespace);
+    assertIsChainReference(chainReference);
+    assertValidChainPartsPair(chainNamespace, chainReference);
+    if (!VALID_ASSET_NAMESPACE[chainNamespace].includes(assetNamespace) ||
+        !isAssetNamespace(assetNamespace))
+        throw new Error(`toAssetId: AssetNamespace ${assetNamespace} not supported for Chain Namespace ${chainNamespace}`);
+    if (assetNamespace === 'slip44' && !isValidSlip44(String(assetReference))) {
+        throw new Error(`Invalid reference for namespace slip44`);
+    }
+    const assetReferenceNormalized = (() => {
+        const assertContractAddress = (address) => {
+            if (!address.startsWith('0x'))
+                throw new Error(`toAssetId: assetReference must start with 0x: ${assetReference}`);
+            if (address.length !== 42)
+                throw new Error(`toAssetId: assetReference length must be 42, length: ${assetReference.length}, ${assetReference}`);
+        };
+        switch (assetNamespace) {
+            case 'erc20':
+                assertContractAddress(assetReference);
+                return assetReference.toLowerCase();
+            case 'erc721':
+            case 'erc1155':
+                // caip-22 (https://github.com/ChainAgnostic/CAIPs/blob/master/CAIPs/caip-22.md)
+                // caip-29 (https://github.com/ChainAgnostic/CAIPs/blob/master/CAIPs/caip-29.md)
+                const [address] = assetReference.split('/');
+                assertContractAddress(address);
+                return assetReference.toLowerCase();
+            default:
+                return assetReference;
+        }
+    })();
+    return `${chainId}/${assetNamespace}:${assetReferenceNormalized}`;
+};
+// NOTE: perf critical - benchmark any changes
+export const fromAssetId = (assetId) => {
+    const slashIdx = assetId.indexOf('/');
+    const chainId = assetId.substring(0, slashIdx);
+    const assetParts = assetId.substring(slashIdx + 1);
+    const { chainNamespace, chainReference } = fromChainId(chainId);
+    const idx = assetParts.indexOf(':');
+    const assetNamespace = assetParts.substring(0, idx);
+    const assetReference = assetParts.substring(idx + 1);
+    if (!isAssetIdParts(chainNamespace, chainReference, assetNamespace))
+        throw new Error(`fromAssetId: invalid AssetId: ${assetId}`);
+    const assetReferenceNormalized = (() => {
+        switch (assetNamespace) {
+            case 'erc20':
+            case 'erc721':
+            case 'erc1155':
+                return assetReference.toLowerCase();
+            default:
+                return assetReference;
+        }
+    })();
+    return {
+        chainId,
+        chainNamespace: chainNamespace,
+        chainReference: chainReference,
+        assetNamespace: assetNamespace,
+        assetReference: assetReferenceNormalized,
+    };
+};
+// NOTE: perf critical - benchmark any changes
+export const isNft = (assetId) => {
+    const slashIdx = assetId.indexOf('/');
+    const assetParts = assetId.substring(slashIdx + 1);
+    const idx = assetParts.indexOf(':');
+    const assetNamespace = assetParts.substring(0, idx);
+    return ['erc721', 'erc1155'].includes(assetNamespace);
+};
+export const toCAIP19 = toAssetId;
+export const fromCAIP19 = fromAssetId;

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

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

package/dist/esm/assetId/assetId.test.js

@@ -0,0 +1,322 @@
+import { omit } from 'lodash';
+import { describe, expect, it } from 'vitest';
+import { toChainId } from '../chainId/chainId.js';
+import { ASSET_REFERENCE, CHAIN_NAMESPACE, CHAIN_REFERENCE } from '../constants.js';
+import { fromAssetId, fromCAIP19, toAssetId, toCAIP19 } from './assetId.js';
+describe('assetId', () => {
+    it('should have matching CAIP19 aliases', () => {
+        expect(toAssetId).toEqual(toCAIP19);
+        expect(fromAssetId).toEqual(fromCAIP19);
+    });
+    describe('toAssetId', () => {
+        describe('toAssetId(fromAssetId())', () => {
+            it.each([
+                ['eip155:1/slip44:60'],
+                ['eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d'],
+                ['bip122:000000000019d6689c085ae165831e93/slip44:0'],
+                ['cosmos:cosmoshub-4/slip44:118'],
+                ['cosmos:thorchain-1/slip44:tcy'],
+            ])('returns an AssetId from the result of fromAssetId for %s', assetId => {
+                const result = fromAssetId(assetId);
+                expect(toAssetId(omit(result, 'chainId'))).toBe(assetId);
+                expect(toAssetId(omit(result, ['chainNamespace', 'chainReference']))).toBe(assetId);
+            });
+        });
+        it('can make eth AssetId on mainnet', () => {
+            const chainNamespace = CHAIN_NAMESPACE.Evm;
+            const chainReference = CHAIN_REFERENCE.EthereumMainnet;
+            const assetIdArgSuperset = {
+                chainNamespace,
+                chainReference,
+                assetNamespace: 'slip44',
+                assetReference: ASSET_REFERENCE.Ethereum,
+                chainId: toChainId({ chainNamespace, chainReference }),
+            };
+            const expected = 'eip155:1/slip44:60';
+            expect(toAssetId(omit(assetIdArgSuperset, 'chainId'))).toEqual(expected);
+            expect(toAssetId(omit(assetIdArgSuperset, ['chainNamespace', 'chainReference']))).toEqual(expected);
+        });
+        it('throws with invalid eth network', () => {
+            const chainNamespace = CHAIN_NAMESPACE.Evm;
+            const chainReference = CHAIN_REFERENCE.CosmosHubMainnet;
+            const assetIdArgSuperset = {
+                chainNamespace,
+                chainReference,
+                assetNamespace: 'slip44',
+                assetReference: ASSET_REFERENCE.Ethereum,
+                chainId: `${chainNamespace}:${chainReference}`,
+            };
+            expect(() => toAssetId(omit(assetIdArgSuperset, 'chainId'))).toThrow();
+            expect(() => toAssetId(omit(assetIdArgSuperset, ['chainNamespace', 'chainReference']))).toThrow();
+        });
+        it('throws with invalid namespace', () => {
+            const chainNamespace = CHAIN_NAMESPACE.Evm;
+            const chainReference = CHAIN_REFERENCE.EthereumMainnet;
+            const assetIdArgSuperset = {
+                chainNamespace,
+                chainReference,
+                assetNamespace: 'bad',
+                assetReference: ASSET_REFERENCE.Ethereum,
+                chainId: `${chainNamespace}:${chainReference}`,
+            };
+            expect(() => toAssetId(omit(assetIdArgSuperset, 'chainId'))).toThrow();
+            expect(() => toAssetId(omit(assetIdArgSuperset, ['chainNamespace', 'chainReference']))).toThrow();
+        });
+        it('can make Cosmos AssetId on CosmosHub mainnet', () => {
+            const chainNamespace = CHAIN_NAMESPACE.CosmosSdk;
+            const chainReference = CHAIN_REFERENCE.CosmosHubMainnet;
+            const assetIdArgSuperset = {
+                chainNamespace,
+                chainReference,
+                assetNamespace: 'slip44',
+                assetReference: ASSET_REFERENCE.Cosmos,
+                chainId: toChainId({ chainNamespace, chainReference }),
+            };
+            const expected = 'cosmos:cosmoshub-4/slip44:118';
+            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;
+            const assetIdArgSuperset = {
+                chainNamespace,
+                chainReference,
+                assetNamespace: 'slip44',
+                assetReference: ASSET_REFERENCE.Cosmos,
+                chainId: `${chainNamespace}:${chainReference}`,
+            };
+            expect(() => toAssetId(omit(assetIdArgSuperset, 'chainId'))).toThrow();
+            expect(() => toAssetId(omit(assetIdArgSuperset, ['chainNamespace', 'chainReference']))).toThrow();
+        });
+        it('throws with invalid Cosmos slip44 reference', () => {
+            const chainNamespace = CHAIN_NAMESPACE.CosmosSdk;
+            const chainReference = CHAIN_REFERENCE.CosmosHubMainnet;
+            const assetIdArgSuperset = {
+                chainNamespace,
+                chainReference,
+                assetNamespace: 'slip44',
+                assetReference: 'bad',
+                chainId: `${chainNamespace}:${chainReference}`,
+            };
+            expect(() => toAssetId(omit(assetIdArgSuperset, 'chainId'))).toThrow();
+            expect(() => toAssetId(omit(assetIdArgSuperset, ['chainNamespace', 'chainReference']))).toThrow();
+        });
+        it('throws with invalid btc network', () => {
+            const chainNamespace = CHAIN_NAMESPACE.Utxo;
+            const chainReference = CHAIN_REFERENCE.EthereumMainnet;
+            const assetIdArgSuperset = {
+                chainNamespace,
+                chainReference,
+                assetNamespace: 'slip44',
+                assetReference: ASSET_REFERENCE.Bitcoin,
+                chainId: `${chainNamespace}:${chainReference}`,
+            };
+            expect(() => toAssetId(omit(assetIdArgSuperset, 'chainId'))).toThrow();
+            expect(() => toAssetId(omit(assetIdArgSuperset, ['chainNamespace', 'chainReference']))).toThrow();
+        });
+        it('can make FOX AssetId on mainnet', () => {
+            const chainNamespace = CHAIN_NAMESPACE.Evm;
+            const chainReference = CHAIN_REFERENCE.EthereumMainnet;
+            const assetIdArgSuperset = {
+                chainNamespace,
+                chainReference,
+                assetNamespace: 'erc20',
+                assetReference: '0xc770eefad204b5180df6a14ee197d99d808ee52d',
+                chainId: `${chainNamespace}:${chainReference}`,
+            };
+            const expected = 'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d';
+            expect(toAssetId(omit(assetIdArgSuperset, 'chainId'))).toEqual(expected);
+            expect(toAssetId(omit(assetIdArgSuperset, ['chainNamespace', 'chainReference']))).toEqual(expected);
+        });
+        it('should lower case ERC20 asset references', () => {
+            const chainNamespace = CHAIN_NAMESPACE.Evm;
+            const chainReference = CHAIN_REFERENCE.EthereumMainnet;
+            const assetIdArgSuperset = {
+                chainNamespace,
+                chainReference,
+                assetNamespace: 'erc20',
+                assetReference: '0xc770EEfAd204B5180dF6a14Ee197D99d808ee52d',
+                chainId: `${chainNamespace}:${chainReference}`,
+            };
+            const expected = 'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d';
+            expect(toAssetId(omit(assetIdArgSuperset, 'chainId'))).toEqual(expected);
+            expect(toAssetId(omit(assetIdArgSuperset, ['chainNamespace', 'chainReference']))).toEqual(expected);
+        });
+        it('should lower case ERC721 asset references', () => {
+            const chainNamespace = CHAIN_NAMESPACE.Evm;
+            const chainReference = CHAIN_REFERENCE.EthereumMainnet;
+            const assetIdArgSuperset = {
+                chainNamespace,
+                chainReference,
+                assetNamespace: 'erc721',
+                assetReference: '0xc770EEfAd204B5180dF6a14Ee197D99d808ee52d/12345',
+                chainId: `${chainNamespace}:${chainReference}`,
+            };
+            const expected = 'eip155:1/erc721:0xc770eefad204b5180df6a14ee197d99d808ee52d/12345';
+            expect(toAssetId(omit(assetIdArgSuperset, 'chainId'))).toEqual(expected);
+            expect(toAssetId(omit(assetIdArgSuperset, ['chainNamespace', 'chainReference']))).toEqual(expected);
+        });
+        it('throws with invalid assetReference length', () => {
+            const chainNamespace = CHAIN_NAMESPACE.Evm;
+            const chainReference = CHAIN_REFERENCE.EthereumMainnet;
+            const assetIdArgSuperset = {
+                chainNamespace,
+                chainReference,
+                assetNamespace: 'erc20',
+                assetReference: '0xfoo',
+                chainId: `${chainNamespace}:${chainReference}`,
+            };
+            expect(() => toAssetId(omit(assetIdArgSuperset, 'chainId'))).toThrow();
+            expect(() => toAssetId(omit(assetIdArgSuperset, ['chainNamespace', 'chainReference']))).toThrow();
+        });
+        it('throws with no assetReference string', () => {
+            const chainNamespace = CHAIN_NAMESPACE.Evm;
+            const chainReference = CHAIN_REFERENCE.EthereumMainnet;
+            const assetIdArgSuperset = {
+                chainNamespace,
+                chainReference,
+                assetNamespace: 'erc20',
+                assetReference: '',
+                chainId: `${chainNamespace}:${chainReference}`,
+            };
+            expect(() => toAssetId(omit(assetIdArgSuperset, 'chainId'))).toThrow();
+            expect(() => toAssetId(omit(assetIdArgSuperset, ['chainNamespace', 'chainReference']))).toThrow();
+        });
+        it('throws with invalid assetReference string', () => {
+            const chainNamespace = CHAIN_NAMESPACE.Evm;
+            const chainReference = CHAIN_REFERENCE.EthereumMainnet;
+            const assetIdArgSuperset = {
+                chainNamespace,
+                chainReference,
+                assetNamespace: 'erc20',
+                assetReference: 'gm',
+                chainId: `${chainNamespace}:${chainReference}`,
+            };
+            expect(() => toAssetId(omit(assetIdArgSuperset, 'chainId'))).toThrow();
+            expect(() => toAssetId(omit(assetIdArgSuperset, ['chainNamespace', 'chainReference']))).toThrow();
+        });
+        it('throws if no asset namespace provided', () => {
+            const chainNamespace = CHAIN_NAMESPACE.Evm;
+            const chainReference = CHAIN_REFERENCE.EthereumMainnet;
+            const assetIdArgSuperset = {
+                chainNamespace,
+                chainReference,
+                assetNamespace: '',
+                assetReference: '0xdef1cafe',
+                chainId: `${chainNamespace}:${chainReference}`,
+            };
+            expect(() => toAssetId(omit(assetIdArgSuperset, 'chainId'))).toThrow();
+            expect(() => toAssetId(omit(assetIdArgSuperset, ['chainNamespace', 'chainReference']))).toThrow();
+        });
+        it('can make bitcoin AssetId on mainnet', () => {
+            const chainNamespace = CHAIN_NAMESPACE.Utxo;
+            const chainReference = CHAIN_REFERENCE.BitcoinMainnet;
+            const assetIdArgSuperset = {
+                chainNamespace,
+                chainReference,
+                assetNamespace: 'slip44',
+                assetReference: ASSET_REFERENCE.Bitcoin,
+                chainId: `${chainNamespace}:${chainReference}`,
+            };
+            const expected = 'bip122:000000000019d6689c085ae165831e93/slip44:0';
+            expect(toAssetId(omit(assetIdArgSuperset, 'chainId'))).toEqual(expected);
+            expect(toAssetId(omit(assetIdArgSuperset, ['chainNamespace', 'chainReference']))).toEqual(expected);
+        });
+    });
+    describe('fromAssetId', () => {
+        describe('fromAssetId(toAssetId())', () => {
+            const slip44 = 'slip44';
+            const erc20 = 'erc20';
+            it.each([
+                [CHAIN_NAMESPACE.Utxo, CHAIN_REFERENCE.BitcoinMainnet, slip44, ASSET_REFERENCE.Bitcoin],
+                [CHAIN_NAMESPACE.Evm, CHAIN_REFERENCE.EthereumMainnet, slip44, ASSET_REFERENCE.Ethereum],
+                [
+                    CHAIN_NAMESPACE.Evm,
+                    CHAIN_REFERENCE.EthereumMainnet,
+                    erc20,
+                    '0xc770eefad204b5180df6a14ee197d99d808ee52d',
+                ],
+                [
+                    CHAIN_NAMESPACE.CosmosSdk,
+                    CHAIN_REFERENCE.CosmosHubMainnet,
+                    slip44,
+                    ASSET_REFERENCE.Cosmos,
+                ],
+            ])('returns a AssetId from the result of fromAssetId for %s', (chainNamespace, chainReference, assetNamespace, assetReference) => {
+                expect(fromAssetId(toAssetId({ chainNamespace, chainReference, assetNamespace, assetReference }))).toStrictEqual({
+                    chainNamespace,
+                    chainReference,
+                    assetReference,
+                    assetNamespace,
+                    chainId: toChainId({ chainNamespace, chainReference }),
+                });
+            });
+        });
+        it('can return chain, network from eth AssetId on mainnet', () => {
+            const AssetId = 'eip155:1/slip44:60';
+            const { chainId, chainReference, chainNamespace, assetNamespace, assetReference } = fromAssetId(AssetId);
+            expect(chainNamespace).toEqual(CHAIN_NAMESPACE.Evm);
+            expect(chainReference).toEqual(CHAIN_REFERENCE.EthereumMainnet);
+            expect(chainId).toEqual(toChainId({ chainNamespace, chainReference }));
+            expect(assetNamespace).toEqual('slip44');
+            expect(assetReference).toEqual(ASSET_REFERENCE.Ethereum);
+        });
+        it('can return chain, network from bitcoin AssetId on mainnet', () => {
+            const AssetId = 'bip122:000000000019d6689c085ae165831e93/slip44:0';
+            const { chainId, chainReference, chainNamespace, assetNamespace, assetReference } = fromAssetId(AssetId);
+            expect(chainNamespace).toEqual(CHAIN_NAMESPACE.Utxo);
+            expect(chainReference).toEqual(CHAIN_REFERENCE.BitcoinMainnet);
+            expect(chainId).toEqual(toChainId({ chainNamespace, chainReference }));
+            expect(assetNamespace).toEqual('slip44');
+            expect(assetReference).toEqual(ASSET_REFERENCE.Bitcoin);
+        });
+        it('can return chainId, chainReference, chainNamespace, assetNamespace, assetReference from FOX AssetId on mainnet', () => {
+            const AssetId = 'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d';
+            const { chainId, chainReference, chainNamespace, assetNamespace, assetReference } = fromAssetId(AssetId);
+            expect(chainNamespace).toEqual(CHAIN_NAMESPACE.Evm);
+            expect(chainReference).toEqual(CHAIN_REFERENCE.EthereumMainnet);
+            expect(chainId).toEqual(toChainId({ chainNamespace, chainReference }));
+            expect(assetNamespace).toEqual('erc20');
+            expect(assetReference).toEqual('0xc770eefad204b5180df6a14ee197d99d808ee52d');
+        });
+        it('should lower case assetReference for assetNamespace ERC20', () => {
+            const AssetId = 'eip155:1/erc20:0xc770EEfAd204B5180dF6a14Ee197D99d808ee52d';
+            const { chainId, chainReference, chainNamespace, assetNamespace, assetReference } = fromAssetId(AssetId);
+            expect(chainNamespace).toEqual(CHAIN_NAMESPACE.Evm);
+            expect(chainReference).toEqual(CHAIN_REFERENCE.EthereumMainnet);
+            expect(chainId).toEqual(toChainId({ chainNamespace, chainReference }));
+            expect(assetNamespace).toEqual('erc20');
+            expect(assetReference).toEqual('0xc770eefad204b5180df6a14ee197d99d808ee52d');
+        });
+        it('should lower case assetReference for assetNamespace ERC721', () => {
+            const AssetId = 'eip155:1/erc721:0xc770EEfAd204B5180dF6a14Ee197D99d808ee52d/12345';
+            const { chainId, chainReference, chainNamespace, assetNamespace, assetReference } = fromAssetId(AssetId);
+            expect(chainNamespace).toEqual(CHAIN_NAMESPACE.Evm);
+            expect(chainReference).toEqual(CHAIN_REFERENCE.EthereumMainnet);
+            expect(chainId).toEqual(toChainId({ chainNamespace, chainReference }));
+            expect(assetNamespace).toEqual('erc721');
+            const [address, id] = assetReference.split('/');
+            expect(address).toEqual('0xc770eefad204b5180df6a14ee197d99d808ee52d');
+            expect(id).toEqual('12345');
+        });
+        it('can parse a cosmoshub native token', () => {
+            const AssetId = 'cosmos:cosmoshub-4/slip44:118';
+            const { chainId, chainReference, chainNamespace, assetNamespace, assetReference } = fromAssetId(AssetId);
+            expect(chainNamespace).toEqual(CHAIN_NAMESPACE.CosmosSdk);
+            expect(chainReference).toEqual(CHAIN_REFERENCE.CosmosHubMainnet);
+            expect(chainId).toEqual(toChainId({ chainNamespace, chainReference }));
+            expect(assetNamespace).toEqual('slip44');
+            expect(assetReference).toEqual(ASSET_REFERENCE.Cosmos);
+        });
+        it('errors for an invalid AssetId format', () => {
+            expect(() => fromAssetId('invalid')).toThrow();
+        });
+        it('errors for invalid ChainNamespace', () => {
+            expect(() => fromAssetId('invalid:cosmoshub-4/slip44:118')).toThrow();
+        });
+        it('errors for invalid ChainReference type', () => {
+            expect(() => fromAssetId('cosmos:invalid/slip44:118')).toThrow();
+        });
+    });
+});

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

@@ -0,0 +1,20 @@
+import type { CHAIN_NAMESPACE, CHAIN_REFERENCE } from '../constants.js';
+import type { Nominal } from '../utils.js';
+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.js

@@ -0,0 +1,20 @@
+// https://github.com/ChainAgnostic/CAIPs/blob/master/CAIPs/caip-2.md
+import { assertIsChainId } from '../typeGuards.js';
+export const toChainId = (args) => {
+    const { chainNamespace, chainReference } = args;
+    const maybeChainId = `${chainNamespace}:${chainReference}`;
+    assertIsChainId(maybeChainId);
+    return maybeChainId;
+};
+// NOTE: perf critical - benchmark any changes
+export const fromChainId = (chainId) => {
+    const idx = chainId.indexOf(':');
+    const chainNamespace = chainId.substring(0, idx);
+    const chainReference = chainId.substring(idx + 1);
+    return {
+        chainNamespace: chainNamespace,
+        chainReference: chainReference,
+    };
+};
+export const toCAIP2 = toChainId;
+export const fromCAIP2 = fromChainId;

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

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

package/dist/esm/chainId/chainId.test.js

@@ -0,0 +1,88 @@
+import { describe, expect, it } from 'vitest';
+import { CHAIN_NAMESPACE, CHAIN_REFERENCE } from '../constants.js';
+import { assertIsChainId, isChainId } from '../typeGuards.js';
+import { fromCAIP2, fromChainId, toCAIP2, toChainId } from './chainId.js';
+describe('chainId', () => {
+    it('should have matching CAIP2 aliases', () => {
+        expect(toChainId).toEqual(toCAIP2);
+        expect(fromChainId).toEqual(fromCAIP2);
+    });
+    describe('toChainId', () => {
+        it('can turn CosmosHub mainnet to ChainId', () => {
+            const chainNamespace = CHAIN_NAMESPACE.CosmosSdk;
+            const chainReference = CHAIN_REFERENCE.CosmosHubMainnet;
+            const result = toChainId({ chainNamespace, chainReference });
+            expect(result).toEqual('cosmos:cosmoshub-4');
+        });
+        it('can turn Ethereum mainnet to ChainId', () => {
+            const chainNamespace = CHAIN_NAMESPACE.Evm;
+            const chainReference = CHAIN_REFERENCE.EthereumMainnet;
+            const result = toChainId({ chainNamespace, chainReference });
+            expect(result).toEqual('eip155:1');
+        });
+        it('can turn Bitcoin mainnet to ChainId', () => {
+            const chainNamespace = CHAIN_NAMESPACE.Utxo;
+            const chainReference = CHAIN_REFERENCE.BitcoinMainnet;
+            const result = toChainId({ chainNamespace, chainReference });
+            expect(result).toEqual('bip122:000000000019d6689c085ae165831e93');
+        });
+        it('should throw an error for an invalid chain', () => {
+            // @ts-ignore
+            expect(() => toChainId({
+                chainNamespace: CHAIN_NAMESPACE.Utxo,
+                chainReference: CHAIN_REFERENCE.CosmosHubMainnet,
+            })).toThrow('assertIsChainId: unsupported ChainId: bip122:cosmoshub-4');
+        });
+    });
+    describe('fromChainId', () => {
+        it('can turn Bitcoin mainnet to chain and network', () => {
+            const bitcoinChainId = 'bip122:000000000019d6689c085ae165831e93';
+            const { chainNamespace, chainReference } = fromChainId(bitcoinChainId);
+            expect(chainNamespace).toEqual(CHAIN_NAMESPACE.Utxo);
+            expect(chainReference).toEqual(CHAIN_REFERENCE.BitcoinMainnet);
+        });
+        it('can turn CosmosHub mainnet to chain and network', () => {
+            const cosmosHubChainId = 'cosmos:cosmoshub-4';
+            const { chainNamespace, chainReference } = fromChainId(cosmosHubChainId);
+            expect(chainNamespace).toEqual(CHAIN_NAMESPACE.CosmosSdk);
+            expect(chainReference).toEqual(CHAIN_REFERENCE.CosmosHubMainnet);
+        });
+        it('can turn Ethereum mainnet to chain and network', () => {
+            const ethereumChainId = 'eip155:1';
+            const { chainNamespace, chainReference } = fromChainId(ethereumChainId);
+            expect(chainNamespace).toEqual(CHAIN_NAMESPACE.Evm);
+            expect(chainReference).toEqual(CHAIN_REFERENCE.EthereumMainnet);
+        });
+    });
+});
+describe('isChainId', () => {
+    it('throws on eip155 without a network reference', () => {
+        expect(() => assertIsChainId('eip155')).toThrow();
+    });
+    it('validates eip155:1 mainnet as true', () => {
+        expect(isChainId('eip155:1')).toBe(true);
+    });
+    it('throws on eip155:2 unsupported network reference', () => {
+        expect(() => assertIsChainId('eip155:2')).toThrow();
+    });
+    it('validates bip122:000000000019d6689c085ae165831e93 mainnet as true', () => {
+        expect(isChainId('bip122:000000000019d6689c085ae165831e93')).toBe(true);
+    });
+    it('throws on bip122 with the wrong network reference', () => {
+        expect(() => assertIsChainId('bip122:1')).toThrow();
+    });
+    it('throws on bip122', () => {
+        // missing network
+        expect(() => assertIsChainId('bip122')).toThrow();
+    });
+    it('throws on empty string', () => {
+        // missing network
+        expect(() => assertIsChainId('')).toThrow();
+    });
+    it('should return true for cosmos', () => {
+        expect(isChainId('cosmos:cosmoshub-4')).toBe(true);
+    });
+    it('should throw for an unknown cosmos chain', () => {
+        expect(() => assertIsChainId('cosmos:fakechain-1')).toThrow('assertIsChainId: unsupported ChainId: cosmos:fakechain-1');
+    });
+});