@shapeshiftoss/caip 8.16.1 → 8.16.2

package/dist/cjs/adapters/coincap/utils.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseData = exports.parseMultiChainTokens = exports.parseEthData = exports.fetchData = exports.writeFiles = void 0;
+const axios_1 = __importDefault(require("axios"));
+const fs_1 = __importDefault(require("fs"));
+const assetId_1 = require("../../assetId/assetId");
+const constants_1 = require("../../constants");
+const utils_1 = require("../../utils");
+const COINCAP_CHAIN_REFERENCE = { ...constants_1.CHAIN_REFERENCE, SolanaMainnet: '101' };
+// Chain ID to CoinCap network ID mapping
+const COINCAP_CHAIN_MAP = {
+    [COINCAP_CHAIN_REFERENCE.EthereumMainnet]: {
+        chainId: constants_1.ethChainId,
+        assetNamespace: 'erc20',
+    },
+    [COINCAP_CHAIN_REFERENCE.OptimismMainnet]: {
+        chainId: constants_1.optimismChainId,
+        assetNamespace: 'erc20',
+    },
+    [COINCAP_CHAIN_REFERENCE.BnbSmartChainMainnet]: {
+        chainId: constants_1.bscChainId,
+        assetNamespace: 'bep20',
+    },
+    [COINCAP_CHAIN_REFERENCE.SolanaMainnet]: {
+        chainId: constants_1.solanaChainId,
+        assetNamespace: 'token',
+    },
+    [COINCAP_CHAIN_REFERENCE.PolygonMainnet]: {
+        chainId: constants_1.polygonChainId,
+        assetNamespace: 'erc20',
+    },
+    [COINCAP_CHAIN_REFERENCE.BaseMainnet]: {
+        chainId: constants_1.baseChainId,
+        assetNamespace: 'erc20',
+    },
+    [COINCAP_CHAIN_REFERENCE.ArbitrumMainnet]: {
+        chainId: constants_1.arbitrumChainId,
+        assetNamespace: 'erc20',
+    },
+    [COINCAP_CHAIN_REFERENCE.AvalancheCChain]: {
+        chainId: constants_1.avalancheChainId,
+        assetNamespace: 'erc20',
+    },
+};
+const writeFiles = async (data) => {
+    const path = './src/adapters/coincap/generated/';
+    const file = '/adapter.json';
+    const writeFile = async ([k, v]) => await fs_1.default.promises.writeFile(`${path}${k}${file}`.replace(':', '_'), JSON.stringify(v));
+    await Promise.all(Object.entries(data).map(writeFile));
+    console.info('Generated CoinCap AssetId adapter data.');
+};
+exports.writeFiles = writeFiles;
+const fetchData = async (URL) => (await axios_1.default.get(URL)).data.data;
+exports.fetchData = fetchData;
+const parseEthData = (data) => {
+    const ethCoins = data.filter(({ id, explorer }) => (explorer && explorer.startsWith('https://etherscan.io/token/0x')) || id === 'ethereum');
+    const ethAssetMap = ethCoins.reduce((acc, { id, explorer }) => {
+        const chainNamespace = constants_1.CHAIN_NAMESPACE.Evm;
+        const chainReference = constants_1.CHAIN_REFERENCE.EthereumMainnet;
+        let assetReference = constants_1.ASSET_REFERENCE.Ethereum;
+        const assetNamespace = id === 'ethereum' ? 'slip44' : 'erc20';
+        if (id !== 'ethereum' && explorer) {
+            assetReference = explorer
+                .replace('https://etherscan.io/token/', '')
+                .split('#')[0]
+                .split('?')[0];
+        }
+        const assetId = (0, assetId_1.toAssetId)({ chainNamespace, chainReference, assetNamespace, assetReference });
+        acc[assetId] = id;
+        return acc;
+    }, {});
+    data.forEach(({ id, tokens }) => {
+        if (tokens[COINCAP_CHAIN_REFERENCE.EthereumMainnet] &&
+            tokens[COINCAP_CHAIN_REFERENCE.EthereumMainnet].length > 0) {
+            // Use first address for Ethereum chain
+            const address = tokens[COINCAP_CHAIN_REFERENCE.EthereumMainnet][0];
+            try {
+                const assetId = (0, assetId_1.toAssetId)({
+                    chainNamespace: constants_1.CHAIN_NAMESPACE.Evm,
+                    chainReference: constants_1.CHAIN_REFERENCE.EthereumMainnet,
+                    assetNamespace: 'erc20',
+                    assetReference: address,
+                });
+                ethAssetMap[assetId] = id;
+            }
+            catch {
+                // Skip invalid addresses
+            }
+        }
+    });
+    // This isn't in there for some reason, add it manually
+    ethAssetMap[constants_1.ethAssetId] = 'ethereum';
+    return ethAssetMap;
+};
+exports.parseEthData = parseEthData;
+const parseMultiChainTokens = (data) => {
+    const chainMaps = {};
+    // Initialize chain maps
+    Object.values(COINCAP_CHAIN_MAP).forEach(({ chainId }) => {
+        chainMaps[chainId] = {};
+    });
+    data.forEach(({ id, tokens }) => {
+        Object.entries(tokens).forEach(([chainNumber, addresses]) => {
+            const chainInfo = COINCAP_CHAIN_MAP[chainNumber];
+            if (!chainInfo || !addresses.length)
+                return;
+            const { chainId, assetNamespace } = chainInfo;
+            const address = addresses[0];
+            try {
+                const assetId = (0, assetId_1.toAssetId)({
+                    chainId,
+                    assetNamespace,
+                    assetReference: address,
+                });
+                chainMaps[chainId][assetId] = id;
+            }
+            catch {
+                // Skip invalid addresses
+            }
+        });
+    });
+    return chainMaps;
+};
+exports.parseMultiChainTokens = parseMultiChainTokens;
+const parseData = (d) => {
+    const result = {
+        [constants_1.ethChainId]: (0, exports.parseEthData)(d),
+        [constants_1.btcChainId]: utils_1.bitcoinAssetMap,
+        [constants_1.bchChainId]: utils_1.bitcoinCashAssetMap,
+        [constants_1.dogeChainId]: utils_1.dogecoinAssetMap,
+        [constants_1.ltcChainId]: utils_1.litecoinAssetMap,
+        [constants_1.cosmosChainId]: utils_1.cosmosAssetMap,
+        [constants_1.thorchainChainId]: utils_1.thorchainAssetMap,
+    };
+    const multiChainTokens = (0, exports.parseMultiChainTokens)(d);
+    Object.entries(multiChainTokens).forEach(([chainId, tokens]) => {
+        if (Object.keys(tokens).length > 0) {
+            result[chainId] = { ...result[chainId], ...tokens };
+        }
+    });
+    return result;
+};
+exports.parseData = parseData;

package/dist/cjs/adapters/coincap/utils.test.js

@@ -0,0 +1,173 @@
+"use strict";
+/**
+ * @vitest-environment node
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const vitest_1 = require("vitest");
+const utils_1 = require("../../utils");
+const utils_2 = require("./utils");
+const makeEthMockCoincapResponse = () => ({
+    id: 'ethereum',
+    rank: '2',
+    symbol: 'ETH',
+    name: 'Ethereum',
+    supply: '118739782.1240000000000000',
+    maxSupply: null,
+    marketCapUsd: '461557096820.5397856216327206',
+    volumeUsd24Hr: '13216473429.9114945699035335',
+    priceUsd: '3887.1310740534754598',
+    changePercent24Hr: '1.7301970732523704',
+    vwap24Hr: '3796.0013297212388563',
+    explorer: 'https://etherscan.io/',
+    tokens: {},
+});
+const makeFoxMockCoincapResponse = () => ({
+    id: 'fox-token',
+    rank: '396',
+    symbol: 'FOX',
+    name: 'FOX Token',
+    supply: '117022448.6044180000000000',
+    maxSupply: '1000001337.0000000000000000',
+    marketCapUsd: '76108238.1995641297877127',
+    volumeUsd24Hr: '1574012.7599955363585018',
+    priceUsd: '0.6503729763580659',
+    changePercent24Hr: '-3.1066427856364231',
+    vwap24Hr: '0.6546275575306273',
+    explorer: 'https://etherscan.io/token/0xc770eefad204b5180df6a14ee197d99d808ee52d',
+    tokens: {},
+});
+const makeBtcMockCoincapResponse = () => ({
+    id: 'bitcoin',
+    rank: '1',
+    symbol: 'BTC',
+    name: 'Bitcoin',
+    supply: '18901193.0000000000000000',
+    maxSupply: '21000000.0000000000000000',
+    marketCapUsd: '908356345541.2269154394485668',
+    volumeUsd24Hr: '19001957914.4173604708767279',
+    priceUsd: '48058.1487920485715076',
+    changePercent24Hr: '2.0370678507913180',
+    vwap24Hr: '47473.8260811456834087',
+    explorer: 'https://blockchain.info/',
+    tokens: {},
+});
+const makeThorchainMockCoincapResponse = () => ({
+    id: 'thorchain',
+    rank: '65',
+    symbol: 'RUNE',
+    name: 'THORChain',
+    supply: '330688061.3344559700000000',
+    maxSupply: '500000000.0000000000000000',
+    marketCapUsd: '657476102.4209547026470565',
+    volumeUsd24Hr: '62707742.6988409953177376',
+    priceUsd: '1.9882063469959601',
+    changePercent24Hr: '-3.0298851309669810',
+    vwap24Hr: '2.0280215210735477',
+    explorer: 'https://explorer.binance.org/asset/RUNE-B1A',
+    tokens: {},
+});
+const makeCosmosMockCoincapResponse = () => ({
+    id: 'cosmos',
+    rank: '24',
+    symbol: 'ATOM',
+    name: 'Cosmos',
+    supply: '248453201.0000000000000000',
+    maxSupply: null,
+    marketCapUsd: '6802617738.3591834303735576',
+    volumeUsd24Hr: '294469112.0045679597220454',
+    priceUsd: '27.3798756102932376',
+    changePercent24Hr: '-2.0945235735481851',
+    vwap24Hr: '27.4571410501515669',
+    explorer: 'https://www.mintscan.io/cosmos',
+    tokens: {},
+});
+vitest_1.vi.mock('fs', () => ({
+    default: {
+        promises: {
+            writeFile: vitest_1.vi.fn(() => undefined),
+        },
+    },
+}));
+(0, vitest_1.describe)('adapters:coincap:utils', () => {
+    (0, vitest_1.describe)('parseEthData', () => {
+        (0, vitest_1.it)('can parse eth data', () => {
+            const result = (0, utils_2.parseEthData)([makeEthMockCoincapResponse(), makeFoxMockCoincapResponse()]);
+            const expected = {
+                'eip155:1/slip44:60': 'ethereum',
+                'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d': 'fox-token',
+            };
+            (0, vitest_1.expect)(result).toEqual(expected);
+        });
+        (0, vitest_1.it)('can parse btc data', () => {
+            const result = utils_1.bitcoinAssetMap;
+            const expected = { 'bip122:000000000019d6689c085ae165831e93/slip44:0': 'bitcoin' };
+            (0, vitest_1.expect)(result).toEqual(expected);
+        });
+        (0, vitest_1.it)('can parse cosmos data', () => {
+            const result = utils_1.cosmosAssetMap;
+            const expected = { 'cosmos:cosmoshub-4/slip44:118': 'cosmos' };
+            (0, vitest_1.expect)(result).toEqual(expected);
+        });
+    });
+    (0, vitest_1.describe)('parseData', () => {
+        (0, vitest_1.it)('can parse all data', () => {
+            const result = (0, utils_2.parseData)([
+                makeEthMockCoincapResponse(),
+                makeFoxMockCoincapResponse(),
+                makeBtcMockCoincapResponse(),
+                makeCosmosMockCoincapResponse(),
+                makeThorchainMockCoincapResponse(),
+            ]);
+            const expected = {
+                'bip122:000000000019d6689c085ae165831e93': {
+                    'bip122:000000000019d6689c085ae165831e93/slip44:0': 'bitcoin',
+                },
+                'bip122:000000000000000000651ef99cb9fcbe': {
+                    'bip122:000000000000000000651ef99cb9fcbe/slip44:145': 'bitcoin-cash',
+                },
+                'bip122:00000000001a91e3dace36e2be3bf030': {
+                    'bip122:00000000001a91e3dace36e2be3bf030/slip44:3': 'dogecoin',
+                },
+                'bip122:12a765e31ffd4059bada1e25190f6e98': {
+                    'bip122:12a765e31ffd4059bada1e25190f6e98/slip44:2': 'litecoin',
+                },
+                'cosmos:cosmoshub-4': {
+                    'cosmos:cosmoshub-4/slip44:118': 'cosmos',
+                },
+                'cosmos:thorchain-1': {
+                    'cosmos:thorchain-1/slip44:931': 'thorchain',
+                },
+                'eip155:1': {
+                    'eip155:1/slip44:60': 'ethereum',
+                    'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d': 'fox-token',
+                },
+            };
+            (0, vitest_1.expect)(result).toEqual(expected);
+        });
+    });
+    (0, vitest_1.describe)('writeFiles', () => {
+        (0, vitest_1.it)('can writeFiles', async () => {
+            const data = {
+                foo: {
+                    assetIdAbc: 'bitcorn',
+                    assetIdDef: 'efferium',
+                },
+                bar: {
+                    assetIdGhi: 'fox',
+                    assetIdJkl: 'shib',
+                },
+            };
+            const fooAssetIds = JSON.stringify(data.foo);
+            const barAssetIds = JSON.stringify(data.bar);
+            console.info = vitest_1.vi.fn();
+            await (0, utils_2.writeFiles)(data);
+            (0, vitest_1.expect)(fs_1.default.promises.writeFile).toBeCalledWith('./src/adapters/coincap/generated/foo/adapter.json', fooAssetIds);
+            (0, vitest_1.expect)(fs_1.default.promises.writeFile).toBeCalledWith('./src/adapters/coincap/generated/bar/adapter.json', barAssetIds);
+            (0, vitest_1.expect)(console.info).toBeCalledWith('Generated CoinCap AssetId adapter data.');
+        });
+    });
+});

package/dist/cjs/adapters/coingecko/generate.js

@@ -0,0 +1,10 @@
+"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)(index_1.coingeckoUrl);
+    const output = (0, utils_1.parseData)(data);
+    await (0, utils_1.writeFiles)(output);
+};
+main();