@shapeshiftoss/caip 8.15.0 → 8.16.0

package/dist/assetId/assetId.d.ts

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

@@ -1,30 +1,29 @@
-"use strict";
 // https://github.com/ChainAgnostic/CAIPs/blob/master/CAIPs/caip-19.md
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fromCAIP19 = exports.toCAIP19 = exports.fromAssetId = exports.toAssetId = void 0;
-const chainId_1 = require("../chainId/chainId");
-const constants_1 = require("../constants");
-const typeGuards_1 = require("../typeGuards");
-const utils_1 = require("../utils");
+import { fromChainId, toChainId } from '../chainId/chainId';
+import { VALID_ASSET_NAMESPACE } from '../constants';
+import { assertIsAssetNamespace, assertIsChainNamespace, assertIsChainReference, assertValidChainPartsPair, isAssetIdParts, isAssetNamespace, } from '../typeGuards';
 /**
  * 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;
-const toAssetId = (args) => {
+export const toAssetId = (args) => {
     const { assetNamespace, assetReference } = args;
-    (0, typeGuards_1.assertIsAssetNamespace)(assetNamespace);
+    assertIsAssetNamespace(assetNamespace);
     if (!assetReference)
         throw new Error('toAssetId: No assetReference provided');
     const { chainId, chainNamespace, chainReference } = (() => {
         if (isToAssetIdWithChainIdArgs(args)) {
-            const fromChainIdResult = (0, chainId_1.fromChainId)(args.chainId);
+            const fromChainIdResult = fromChainId(args.chainId);
             return {
                 chainId: args.chainId,
                 chainNamespace: fromChainIdResult.chainNamespace,
@@ -33,7 +32,7 @@ const toAssetId = (args) => {
         }
         else
             return {
-                chainId: (0, chainId_1.toChainId)({
+                chainId: toChainId({
                     chainNamespace: args.chainNamespace,
                     chainReference: args.chainReference,
                 }),
@@ -41,56 +40,81 @@ const toAssetId = (args) => {
                 chainReference: args.chainReference,
             };
     })();
-    const isContractAddress = Array('erc20', 'erc721', 'bep20', 'bep721').includes(assetNamespace);
-    (0, typeGuards_1.assertIsChainNamespace)(chainNamespace);
-    (0, typeGuards_1.assertIsChainReference)(chainReference);
-    (0, typeGuards_1.assertValidChainPartsPair)(chainNamespace, chainReference);
-    if (!constants_1.VALID_ASSET_NAMESPACE[chainNamespace].includes(assetNamespace) ||
-        !(0, typeGuards_1.isAssetNamespace)(assetNamespace))
+    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`);
     }
-    if (isContractAddress) {
-        if (!assetReference.startsWith('0x'))
-            throw new Error(`toAssetId: assetReference must start with 0x: ${assetReference}`);
-        if (assetReference.length !== 42)
-            throw new Error(`toAssetId: assetReference length must be 42, length: ${assetReference.length}`);
-    }
-    // We make Eth contract addresses lower case to simplify comparisons
-    const assetReferenceCaseCorrected = isContractAddress
-        ? assetReference.toLowerCase()
-        : assetReference;
-    return `${chainId}/${assetNamespace}:${assetReferenceCaseCorrected}`;
-};
-exports.toAssetId = toAssetId;
-const fromAssetId = (assetId) => {
-    if (!(0, typeGuards_1.isAssetId)(assetId))
-        throw new Error(`fromAssetId: invalid AssetId: ${assetId}`);
-    const matches = utils_1.parseAssetIdRegExp.exec(assetId);
-    if (!matches)
-        throw new Error(`fromAssetId: could not parse AssetId: ${assetId}`);
-    const { 1: chainNamespace, 2: chainReference, 3: assetNamespace, 4: assetReference } = matches;
-    // These should never throw because isAssetId() would have already caught it, but they help with type inference
-    (0, typeGuards_1.assertIsChainNamespace)(chainNamespace);
-    (0, typeGuards_1.assertIsChainReference)(chainReference);
-    (0, typeGuards_1.assertIsAssetNamespace)(assetNamespace);
-    const chainId = (0, chainId_1.toChainId)({ chainNamespace, chainReference });
-    if (assetNamespace && assetReference && chainId) {
-        return {
-            chainId,
-            chainReference,
-            chainNamespace,
-            assetNamespace,
-            assetReference: ['erc20', 'erc721', 'bep20', 'bep721'].includes(assetNamespace)
-                ? assetReference.toLowerCase()
-                : assetReference,
+    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}`);
         };
-    }
-    else {
+        switch (assetNamespace) {
+            case 'erc20':
+            case 'bep20':
+                assertContractAddress(assetReference);
+                return assetReference.toLowerCase();
+            case 'erc721':
+            case 'erc1155':
+            case 'bep721':
+            case 'bep1155':
+                // 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 'bep20':
+            case 'erc721':
+            case 'erc1155':
+            case 'bep721':
+            case 'bep1155':
+                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', 'bep721', 'bep1155'].includes(assetNamespace);
 };
-exports.fromAssetId = fromAssetId;
-exports.toCAIP19 = exports.toAssetId;
-exports.fromCAIP19 = exports.fromAssetId;
+export const toCAIP19 = toAssetId;
+export const fromCAIP19 = fromAssetId;

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

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

package/dist/assetId/assetId.test.js

@@ -0,0 +1,336 @@
+import { omit } from 'lodash';
+import { describe, expect, it } from 'vitest';
+import { toChainId } from '../chainId/chainId';
+import { ASSET_REFERENCE, CHAIN_NAMESPACE, CHAIN_REFERENCE } from '../constants';
+import { fromAssetId, fromCAIP19, toAssetId, toCAIP19 } from './assetId';
+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('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;
+            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/chainId/chainId.d.ts

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

package/dist/chainId/chainId.js

@@ -1,22 +1,20 @@
-"use strict";
 // https://github.com/ChainAgnostic/CAIPs/blob/master/CAIPs/caip-2.md
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fromCAIP2 = exports.toCAIP2 = exports.fromChainId = exports.toChainId = void 0;
-const typeGuards_1 = require("../typeGuards");
-const toChainId = (args) => {
+import { assertIsChainId } from '../typeGuards';
+export const toChainId = (args) => {
     const { chainNamespace, chainReference } = args;
     const maybeChainId = `${chainNamespace}:${chainReference}`;
-    (0, typeGuards_1.assertIsChainId)(maybeChainId);
+    assertIsChainId(maybeChainId);
     return maybeChainId;
 };
-exports.toChainId = toChainId;
-const fromChainId = (chainId) => {
-    const [chainNamespace, chainReference] = chainId.split(':');
-    (0, typeGuards_1.assertIsChainNamespace)(chainNamespace);
-    (0, typeGuards_1.assertIsChainReference)(chainReference);
-    (0, typeGuards_1.assertValidChainPartsPair)(chainNamespace, chainReference);
-    return { chainNamespace, chainReference };
+// 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,
+    };
 };
-exports.fromChainId = fromChainId;
-exports.toCAIP2 = exports.toChainId;
-exports.fromCAIP2 = exports.fromChainId;
+export const toCAIP2 = toChainId;
+export const fromCAIP2 = fromChainId;

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

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