@shapeshiftoss/caip 8.15.0 → 8.16.1

package/dist/typeGuards.js

@@ -1,50 +1,44 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertValidChainPartsPair = exports.assertIsAssetReference = exports.assertIsAssetNamespace = exports.assertIsChainReference = exports.assertIsChainNamespace = exports.assertIsChainId = exports.isChainId = exports.isAssetId = exports.isAssetReference = exports.isAssetNamespace = exports.isChainReference = exports.isChainNamespace = void 0;
-const constants_1 = require("./constants");
-const utils_1 = require("./utils");
-const isChainNamespace = (maybeChainNamespace) => Object.values(constants_1.CHAIN_NAMESPACE).some((s) => s === maybeChainNamespace);
-exports.isChainNamespace = isChainNamespace;
-const isChainReference = (maybeChainReference) => Object.values(constants_1.CHAIN_REFERENCE).some((s) => s === maybeChainReference);
-exports.isChainReference = isChainReference;
-const isAssetNamespace = (maybeAssetNamespace) => Object.values(constants_1.ASSET_NAMESPACE).some((s) => s === maybeAssetNamespace);
-exports.isAssetNamespace = isAssetNamespace;
-const isAssetReference = (maybeAssetReference) => Object.values(constants_1.ASSET_REFERENCE).some((s) => s === maybeAssetReference);
-exports.isAssetReference = isAssetReference;
-const isAssetId = (maybeAssetId) => {
-    const matches = utils_1.parseAssetIdRegExp.exec(maybeAssetId);
-    if (!matches) {
-        return false;
-    }
-    const { 1: chainNamespace, 2: chainReference, 3: assetNamespace } = matches;
-    return ((0, exports.isChainNamespace)(chainNamespace) &&
-        (0, exports.isChainReference)(chainReference) &&
-        (0, exports.isAssetNamespace)(assetNamespace));
+import { fromChainId } from './chainId/chainId';
+import { ASSET_NAMESPACE, ASSET_REFERENCE, CHAIN_NAMESPACE, CHAIN_REFERENCE, VALID_CHAIN_IDS, } from './constants';
+import { isValidChainPartsPair } from './utils';
+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);
 };
-exports.isAssetId = isAssetId;
-const isChainId = (maybeChainId) => {
-    var _a, _b;
-    // https://regex101.com/r/iCqlyB/1
-    const chainIdRegExp = /(?<chainNamespace>[-a-z\d]{3,8}):(?<chainReference>[-a-zA-Z\d]{1,32})/;
-    const [maybeChainNamespace, maybeChainReference] = (_b = (_a = chainIdRegExp.exec(maybeChainId)) === null || _a === void 0 ? void 0 : _a.slice(1)) !== null && _b !== void 0 ? _b : [];
-    return ((0, exports.isChainNamespace)(maybeChainNamespace) &&
-        (0, exports.isChainReference)(maybeChainReference) &&
-        (0, utils_1.isValidChainPartsPair)(maybeChainNamespace, maybeChainReference));
+// 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);
 };
-exports.isChainId = isChainId;
 const getTypeGuardAssertion = (typeGuard, message) => {
     return (value) => {
         if ((value && !typeGuard(value)) || !value)
             throw new Error(`${message}: ${value}`);
     };
 };
-exports.assertIsChainId = getTypeGuardAssertion(exports.isChainId, 'assertIsChainId: unsupported ChainId');
-exports.assertIsChainNamespace = getTypeGuardAssertion(exports.isChainNamespace, 'assertIsChainNamespace: unsupported ChainNamespace');
-exports.assertIsChainReference = getTypeGuardAssertion(exports.isChainReference, 'assertIsChainReference: unsupported ChainReference');
-exports.assertIsAssetNamespace = getTypeGuardAssertion(exports.isAssetNamespace, 'assertIsAssetNamespace: unsupported AssetNamespace');
-exports.assertIsAssetReference = getTypeGuardAssertion(exports.isAssetReference, 'assertIsAssetReference: unsupported AssetReference');
-const assertValidChainPartsPair = (chainNamespace, chainReference) => {
-    if (!(0, utils_1.isValidChainPartsPair)(chainNamespace, chainReference))
+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}`);
 };
-exports.assertValidChainPartsPair = assertValidChainPartsPair;

package/dist/utils.d.ts

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

package/dist/utils.js

@@ -1,73 +1,29 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.thorchainAssetMap = exports.osmosisAssetMap = exports.cosmosAssetMap = exports.litecoinAssetMap = exports.dogecoinAssetMap = exports.bitcoinCashAssetMap = exports.bitcoinAssetMap = exports.generateAssetIdFromOsmosisDenom = exports.isValidChainPartsPair = exports.accountIdToSpecifier = exports.accountIdToChainId = exports.parseAssetIdRegExp = void 0;
-const accountId_1 = require("./accountId/accountId");
-const assetId_1 = require("./assetId/assetId");
-const constants = __importStar(require("./constants"));
-// https://regex101.com/r/xqVzV2/1
-exports.parseAssetIdRegExp = /([-a-z\d]{3,8}):([-a-zA-Z\d]{1,32})\/([-a-z\d]{3,8}):([-a-zA-Z/\d]+)/;
-const accountIdToChainId = (accountId) => (0, accountId_1.fromAccountId)(accountId).chainId;
-exports.accountIdToChainId = accountIdToChainId;
-const accountIdToSpecifier = (accountId) => (0, accountId_1.fromAccountId)(accountId).account;
-exports.accountIdToSpecifier = accountIdToSpecifier;
-const isValidChainPartsPair = (chainNamespace, chainReference) => { var _a; return ((_a = constants.VALID_CHAIN_IDS[chainNamespace]) === null || _a === void 0 ? void 0 : _a.includes(chainReference)) || false; };
-exports.isValidChainPartsPair = isValidChainPartsPair;
-const generateAssetIdFromOsmosisDenom = (denom) => {
-    if (denom.startsWith('u') && denom !== 'uosmo') {
-        return (0, assetId_1.toAssetId)({
-            assetNamespace: constants.ASSET_NAMESPACE.native,
-            assetReference: denom,
-            chainId: constants.osmosisChainId,
-        });
-    }
+import { fromAccountId } from './accountId/accountId';
+import { fromAssetId, toAssetId } from './assetId/assetId';
+import * as constants from './constants';
+import { tcyAssetId } from './constants';
+const mayaTokenAssetId = 'cosmos:mayachain-mainnet-v1/slip44:maya';
+export const accountIdToChainId = (accountId) => fromAccountId(accountId).chainId;
+export const accountIdToSpecifier = (accountId) => fromAccountId(accountId).account;
+export const isValidChainPartsPair = (chainNamespace, chainReference) => constants.VALID_CHAIN_IDS[chainNamespace]?.includes(chainReference) || false;
+export const generateAssetIdFromCosmosSdkDenom = (denom, nativeAssetId) => {
+    if (denom === 'tcy')
+        return tcyAssetId;
+    if (denom === 'maya')
+        return mayaTokenAssetId;
     if (denom.startsWith('ibc')) {
-        return (0, assetId_1.toAssetId)({
+        return toAssetId({
             assetNamespace: constants.ASSET_NAMESPACE.ibc,
             assetReference: denom.split('/')[1],
-            chainId: constants.osmosisChainId,
-        });
-    }
-    if (denom.startsWith('gamm')) {
-        return (0, assetId_1.toAssetId)({
-            assetNamespace: constants.ASSET_NAMESPACE.ibc,
-            assetReference: denom,
-            chainId: constants.osmosisChainId,
+            chainId: fromAssetId(nativeAssetId).chainId,
         });
     }
-    return (0, assetId_1.toAssetId)({
-        assetNamespace: constants.ASSET_NAMESPACE.slip44,
-        assetReference: constants.ASSET_REFERENCE.Osmosis,
-        chainId: constants.osmosisChainId,
-    });
+    return nativeAssetId;
 };
-exports.generateAssetIdFromOsmosisDenom = generateAssetIdFromOsmosisDenom;
-exports.bitcoinAssetMap = { [constants.btcAssetId]: 'bitcoin' };
-exports.bitcoinCashAssetMap = { [constants.bchAssetId]: 'bitcoin-cash' };
-exports.dogecoinAssetMap = { [constants.dogeAssetId]: 'dogecoin' };
-exports.litecoinAssetMap = { [constants.ltcAssetId]: 'litecoin' };
-exports.cosmosAssetMap = { [constants.cosmosAssetId]: 'cosmos' };
-exports.osmosisAssetMap = { [constants.osmosisAssetId]: 'osmosis' };
-exports.thorchainAssetMap = { [constants.thorchainAssetId]: 'thorchain' };
+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/utils.test.d.ts

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

package/dist/utils.test.js

@@ -0,0 +1,162 @@
+import { describe, expect, it } from 'vitest';
+import { toAssetId } from './assetId/assetId';
+import { ASSET_NAMESPACE, ASSET_REFERENCE, btcAssetId, btcChainId, CHAIN_NAMESPACE, CHAIN_REFERENCE, cosmosAssetId, cosmosChainId, ethAssetId, ethChainId, } from './constants';
+import { assertIsAssetNamespace, assertIsAssetReference, assertIsChainId, assertIsChainNamespace, assertIsChainReference, assertValidChainPartsPair, isAssetId, isAssetNamespace, isAssetReference, isChainId, isChainNamespace, isChainReference, } from './typeGuards';
+import { accountIdToChainId, accountIdToSpecifier, generateAssetIdFromCosmosSdkDenom, isValidChainPartsPair, } from './utils';
+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 ATOM native asset id', () => {
+            const nativeAssetId = toAssetId({
+                assetNamespace: ASSET_NAMESPACE.slip44,
+                assetReference: ASSET_REFERENCE.Cosmos,
+                chainId: cosmosChainId,
+            });
+            const result = generateAssetIdFromCosmosSdkDenom('uatom', cosmosAssetId);
+            expect(result).toEqual(nativeAssetId);
+        });
+        it('correctly generates cosmoshub IBC asset id', () => {
+            const ibcAssetId = toAssetId({
+                assetNamespace: ASSET_NAMESPACE.ibc,
+                assetReference: '14F9BC3E44B8A9C1BE1FB08980FAB87034C9905EF17CF2F5008FC085218811CC',
+                chainId: cosmosChainId,
+            });
+            const result = generateAssetIdFromCosmosSdkDenom('ibc/14F9BC3E44B8A9C1BE1FB08980FAB87034C9905EF17CF2F5008FC085218811CC', cosmosAssetId);
+            expect(result).toEqual(ibcAssetId);
+        });
+    });
+});

package/package.json

@@ -1,42 +1,23 @@
 {
   "name": "@shapeshiftoss/caip",
-  "version": "8.15.0",
+  "version": "8.16.1",
   "description": "CAIP Implementation",
-  "homepage": "",
+  "repository": "https://github.com/shapeshift/web",
   "license": "MIT",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "files": [
     "dist"
   ],
   "publishConfig": {
     "access": "public"
   },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/shapeshift/lib"
-  },
   "scripts": {
-    "build": "yarn clean && yarn compile",
-    "clean": "rm -rf dist && rm -rf tsconfig.build.tsbuildinfo",
-    "compile": "tsc -p tsconfig.build.json",
-    "dev": "tsc --watch",
-    "generate-coingecko": "ts-node -P tsconfig.build.json src/adapters/coingecko/generate.ts",
-    "generate-coincap": "ts-node -P tsconfig.build.json src/adapters/coincap/generate.ts",
-    "generate-yearn": "ts-node -P tsconfig.build.json src/adapters/yearn/generate.ts",
-    "generate-osmosis": "ts-node -P tsconfig.build.json src/adapters/osmosis/generate.ts",
-    "generate": "yarn generate-coingecko && yarn generate-coincap && yarn generate-yearn && yarn generate-osmosis",
-    "prepare": "yarn build",
-    "test": "jest test",
-    "type-check": "tsc --project ./tsconfig.build.json --noEmit"
-  },
-  "peerDependencies": {
-    "@shapeshiftoss/types": "^8.1.0"
-  },
-  "devDependencies": {
-    "@shapeshiftoss/types": "^8.1.0",
-    "@yfi/sdk": "^1.2.0",
-    "axios": "^0.26.1",
-    "ts-node": "^10.7.0"
+    "build": "yarn clean && yarn run -T tsc --build",
+    "clean": "rm -rf dist tsconfig.tsbuildinfo",
+    "dev": "yarn run -T tsc --build --watch",
+    "generate": "yarn generate:coingecko && yarn generate:coincap",
+    "generate:coingecko": "yarn build && yarn run -T tsx src/adapters/coingecko/generate.ts",
+    "generate:coincap": "yarn build && yarn run -T tsx src/adapters/coincap/generate.ts"
   }
-}
+}

package/dist/adapters/coincap/generated/cosmos_osmosis-1/adapter.json

@@ -1 +0,0 @@
-{ "cosmos:osmosis-1/slip44:118": "osmosis" }

package/dist/adapters/coincap/generated/cosmos_thorchain-mainnet-v1/adapter.json

@@ -1 +0,0 @@
-{ "cosmos:thorchain-mainnet-v1/slip44:931": "thorchain" }

package/dist/adapters/coingecko/generated/cosmos_osmosis-1/adapter.json

@@ -1 +0,0 @@
-{ "cosmos:osmosis-1/slip44:118": "osmosis" }

package/dist/adapters/coingecko/generated/cosmos_thorchain-mainnet-v1/adapter.json

@@ -1 +0,0 @@
-{ "cosmos:thorchain-mainnet-v1/slip44:931": "thorchain" }

package/dist/adapters/gem/index.d.ts

@@ -1,2 +0,0 @@
-export declare const gemTickerToAssetId: (id: string) => string | undefined;
-export declare const assetIdToGemTicker: (assetId: string) => string | undefined;

package/dist/adapters/gem/index.js

@@ -1,39 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assetIdToGemTicker = exports.gemTickerToAssetId = void 0;
-const invert_1 = __importDefault(require("lodash/invert"));
-const toLower_1 = __importDefault(require("lodash/toLower"));
-const assetIdToGemAssetIdMap = {
-    'bip122:000000000019d6689c085ae165831e93/slip44:0': 'bitcoin',
-    'bip122:00000000001a91e3dace36e2be3bf030/slip44:3': 'dogecoin',
-    'bip122:000000000000000000651ef99cb9fcbe/slip44:145': 'bitcoin-cash',
-    'bip122:12a765e31ffd4059bada1e25190f6e98/slip44:2': 'litecoin',
-    'eip155:1/slip44:60': 'ethereum',
-    'eip155:1/erc20:0x7fc66500c84a76ad7e9c93437bfc5ac33e2ddae9': 'aave',
-    'eip155:1/erc20:0x0d8775f648430679a709e98d2b0cb6250d2887ef': 'basic-attention-token',
-    'eip155:1/erc20:0x4fabb145d64652a948d72533023f6e7a623c7c53': 'busd',
-    'eip155:1/erc20:0xc00e94cb662c3520282e6f5717214004a7f26888': 'compound-coin',
-    'eip155:1/erc20:0xd533a949740bb3306d119cc777fa900ba034cd52': 'curve-dao',
-    'eip155:1/erc20:0x6b175474e89094c44da98b954eedeac495271d0f': 'dai',
-    'eip155:1/erc20:0x056fd409e1d7a124bd7017459dfea2f387b6d5cd': 'gemini-dollar',
-    'eip155:1/erc20:0x514910771af9ca656af840dff83e8264ecf986ca': 'chainlink',
-    'eip155:1/erc20:0x9f8f72aa9304c8b593d555f12ef6589cc3a579a2': 'maker',
-    'eip155:1/erc20:0x75231f58b43240c9718dd58b4967c5114342a86c': 'okb',
-    'eip155:1/erc20:0xc011a73ee8576fb46f5e1c5751ca3b9fe0af2a6f': 'synthetix-network-token',
-    'eip155:1/erc20:0xa4bdb11dc0a2bec88d24a3aa1e6bb17201112ebe': 'usds',
-    'eip155:1/erc20:0xdac17f958d2ee523a2206206994597c13d831ec7': 'tether',
-    'eip155:1/erc20:0x04fa0d235c4abf4bcf4787af4cf447de572ef828': 'universal-market-access',
-    'eip155:1/erc20:0x1f9840a85d5af5bf1d1762f925bdaddc4201f984': 'uniswap',
-    'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48': 'usd-coin',
-    'eip155:1/erc20:0x2260fac5e5542a773aa44fbcfedf7c193bc2c599': 'wrapped-bitcoin',
-    'eip155:1/erc20:0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2': 'weth',
-    'eip155:1/erc20:0x0bc529c00c6401aef6d220be8c6ea1667f6ad93e': 'yearn-finance',
-};
-const gemAssetIdToAssetIdMap = (0, invert_1.default)(assetIdToGemAssetIdMap);
-const gemTickerToAssetId = (id) => gemAssetIdToAssetIdMap[id];
-exports.gemTickerToAssetId = gemTickerToAssetId;
-const assetIdToGemTicker = (assetId) => assetIdToGemAssetIdMap[(0, toLower_1.default)(assetId)];
-exports.assetIdToGemTicker = assetIdToGemTicker;

package/dist/adapters/junopay/index.d.ts

@@ -1,7 +0,0 @@
-import { AssetId } from '../../assetId/assetId';
-export declare const junoPayTickerToAssetId: (id: string) => AssetId | undefined;
-export declare const assetIdToJunoPayTicker: (assetId: string) => string | undefined;
-export declare const getSupportedJunoPayAssets: () => {
-    assetId: string;
-    ticker: string;
-}[];

package/dist/adapters/junopay/index.js

@@ -1,52 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSupportedJunoPayAssets = exports.assetIdToJunoPayTicker = exports.junoPayTickerToAssetId = void 0;
-const entries_1 = __importDefault(require("lodash/entries"));
-const invert_1 = __importDefault(require("lodash/invert"));
-const toLower_1 = __importDefault(require("lodash/toLower"));
-const constants_1 = require("../../constants");
-// source data https://docs.juno.finance/developers/reference/onjuno-pay/onjuno-pay-integration-guide
-const assetIdToJunoPayTickerMap = {
-    [constants_1.avalancheAssetId]: 'avax',
-    [constants_1.btcAssetId]: 'btc',
-    [constants_1.cosmosAssetId]: 'atom',
-    [constants_1.ethAssetId]: 'eth',
-    'eip155:1/erc20:0x7fc66500c84a76ad7e9c93437bfc5ac33e2ddae9': 'aave',
-    'eip155:1/erc20:0xbb0e17ef65f82ab018d8edd776e8dd940327b28b': 'axs',
-    'eip155:1/erc20:0x4d224452801aced8b2f0aebe155379bb5d594381': 'ape',
-    'eip155:1/erc20:0x0d8775f648430679a709e98d2b0cb6250d2887ef': 'bat',
-    'eip155:1/erc20:0x4fabb145d64652a948d72533023f6e7a623c7c53': 'busd',
-    'eip155:1/erc20:0x3506424f91fd33084466f402d5d97f05f8e3b4af': 'chz',
-    'eip155:1/erc20:0x41e5560054824ea6b0732e656e3ad64e20e94e45': 'cvc',
-    'eip155:1/erc20:0xc00e94cb662c3520282e6f5717214004a7f26888': 'comp',
-    'eip155:1/erc20:0x6b175474e89094c44da98b954eedeac495271d0f': 'dai',
-    'eip155:1/erc20:0xf629cbd94d3791c9250152bd8dfbdf380e2a3b9c': 'enj',
-    'eip155:1/erc20:0x4e15361fd6b4bb609fa63c81a2be19d873717870': 'ftm',
-    'eip155:1/erc20:0x165440036ce972c5f8ebef667086707e48b2623e': 'grt',
-    'eip155:1/erc20:0xf57e7e7c23978c3caec3c3548e3d615c346e79ff': 'imx',
-    'eip155:1/erc20:0x514910771af9ca656af840dff83e8264ecf986ca': 'link',
-    'eip155:1/erc20:0x9f8f72aa9304c8b593d555f12ef6589cc3a579a2': 'mkr',
-    'eip155:1/erc20:0x0f5d2fb29fb7d3cfee444a200298f468908cc942': 'mana',
-    'eip155:1/erc20:0xd26114cd6ee289accf82350c8d8487fedb8a0c07': 'omg',
-    'eip155:1/erc20:0x57ab1ec28d129707052df4df418d58a2d46d5f51': 'susd',
-    'eip155:1/erc20:0x6b3595068778dd592e39a122f4f5a5cf09c90fe2': 'sushi',
-    'eip155:1/erc20:0xc011a73ee8576fb46f5e1c5751ca3b9fe0af2a6f': 'snx',
-    'eip155:1/erc20:0x1f9840a85d5af5bf1d1762f925bdaddc4201f984': 'uni',
-    'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48': 'usdc',
-    'eip155:1/erc20:0x8e870d67f660d95d5be530380d0ec0bd388289e1': 'usdp',
-    'eip155:1/erc20:0xdac17f958d2ee523a2206206994597c13d831ec7': 'usdt',
-    'eip155:1/erc20:0x2260fac5e5542a773aa44fbcfedf7c193bc2c599': 'wbtc',
-};
-const junoPayTickerToAssetIdMap = (0, invert_1.default)(assetIdToJunoPayTickerMap);
-const junoPayTickerToAssetId = (id) => junoPayTickerToAssetIdMap[id];
-exports.junoPayTickerToAssetId = junoPayTickerToAssetId;
-const assetIdToJunoPayTicker = (assetId) => assetIdToJunoPayTickerMap[(0, toLower_1.default)(assetId)];
-exports.assetIdToJunoPayTicker = assetIdToJunoPayTicker;
-const getSupportedJunoPayAssets = () => (0, entries_1.default)(assetIdToJunoPayTickerMap).map(([assetId, ticker]) => ({
-    assetId,
-    ticker,
-}));
-exports.getSupportedJunoPayAssets = getSupportedJunoPayAssets;

package/dist/adapters/osmosis/generate.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_1 = require("./index");
-const utils_1 = require("./utils");
-const main = async () => {
-    const data = await (0, utils_1.fetchData)({
-        tokensUrl: index_1.osmosisGetTokensUrl,
-        lpTokensUrl: index_1.osmosisGetLpTokensUrl,
-    });
-    const output = (0, utils_1.parseData)(data);
-    await (0, utils_1.writeFiles)(output);
-};
-main();