@shapeshiftoss/caip 8.16.4 → 8.16.5

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

@@ -0,0 +1,135 @@
+import axios from 'axios';
+import fs from 'fs';
+import { toAssetId } from '../../assetId/assetId.js';
+import { arbitrumChainId, ASSET_REFERENCE, avalancheChainId, baseChainId, bchChainId, bscChainId, btcChainId, CHAIN_NAMESPACE, CHAIN_REFERENCE, cosmosChainId, dogeChainId, ethAssetId, ethChainId, ltcChainId, optimismChainId, polygonChainId, solanaChainId, thorchainChainId, } from '../../constants.js';
+import { bitcoinAssetMap, bitcoinCashAssetMap, cosmosAssetMap, dogecoinAssetMap, litecoinAssetMap, thorchainAssetMap, } from '../../utils.js';
+const COINCAP_CHAIN_REFERENCE = { ...CHAIN_REFERENCE, SolanaMainnet: '101' };
+// Chain ID to CoinCap network ID mapping
+const COINCAP_CHAIN_MAP = {
+    [COINCAP_CHAIN_REFERENCE.EthereumMainnet]: {
+        chainId: ethChainId,
+        assetNamespace: 'erc20',
+    },
+    [COINCAP_CHAIN_REFERENCE.OptimismMainnet]: {
+        chainId: optimismChainId,
+        assetNamespace: 'erc20',
+    },
+    [COINCAP_CHAIN_REFERENCE.BnbSmartChainMainnet]: {
+        chainId: bscChainId,
+        assetNamespace: 'erc20',
+    },
+    [COINCAP_CHAIN_REFERENCE.SolanaMainnet]: {
+        chainId: solanaChainId,
+        assetNamespace: 'token',
+    },
+    [COINCAP_CHAIN_REFERENCE.PolygonMainnet]: {
+        chainId: polygonChainId,
+        assetNamespace: 'erc20',
+    },
+    [COINCAP_CHAIN_REFERENCE.BaseMainnet]: {
+        chainId: baseChainId,
+        assetNamespace: 'erc20',
+    },
+    [COINCAP_CHAIN_REFERENCE.ArbitrumMainnet]: {
+        chainId: arbitrumChainId,
+        assetNamespace: 'erc20',
+    },
+    [COINCAP_CHAIN_REFERENCE.AvalancheCChain]: {
+        chainId: avalancheChainId,
+        assetNamespace: 'erc20',
+    },
+};
+export const writeFiles = async (data) => {
+    const path = './src/adapters/coincap/generated/';
+    const file = '/adapter.json';
+    const writeFile = async ([k, v]) => await fs.promises.writeFile(`${path}${k}${file}`.replace(':', '_'), JSON.stringify(v));
+    await Promise.all(Object.entries(data).map(writeFile));
+    console.info('Generated CoinCap AssetId adapter data.');
+};
+export const fetchData = async (URL) => (await axios.get(URL)).data.data;
+export 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 = CHAIN_NAMESPACE.Evm;
+        const chainReference = CHAIN_REFERENCE.EthereumMainnet;
+        let assetReference = 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 = 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 = toAssetId({
+                    chainNamespace: CHAIN_NAMESPACE.Evm,
+                    chainReference: 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[ethAssetId] = 'ethereum';
+    return ethAssetMap;
+};
+export 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 = toAssetId({
+                    chainId,
+                    assetNamespace,
+                    assetReference: address,
+                });
+                chainMaps[chainId][assetId] = id;
+            }
+            catch {
+                // Skip invalid addresses
+            }
+        });
+    });
+    return chainMaps;
+};
+export const parseData = (d) => {
+    const result = {
+        [ethChainId]: parseEthData(d),
+        [btcChainId]: bitcoinAssetMap,
+        [bchChainId]: bitcoinCashAssetMap,
+        [dogeChainId]: dogecoinAssetMap,
+        [ltcChainId]: litecoinAssetMap,
+        [cosmosChainId]: cosmosAssetMap,
+        [thorchainChainId]: thorchainAssetMap,
+    };
+    const multiChainTokens = parseMultiChainTokens(d);
+    Object.entries(multiChainTokens).forEach(([chainId, tokens]) => {
+        if (Object.keys(tokens).length > 0) {
+            result[chainId] = { ...result[chainId], ...tokens };
+        }
+    });
+    return result;
+};

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

@@ -0,0 +1,4 @@
+/**
+ * @vitest-environment node
+ */
+export {};

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

@@ -0,0 +1,168 @@
+/**
+ * @vitest-environment node
+ */
+import realFs from 'fs';
+import { describe, expect, it, vi } from 'vitest';
+import { bitcoinAssetMap, cosmosAssetMap } from '../../utils.js';
+import { parseData, parseEthData, writeFiles } from './utils.js';
+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: {},
+});
+vi.mock('fs', () => ({
+    default: {
+        promises: {
+            writeFile: vi.fn(() => undefined),
+        },
+    },
+}));
+describe('adapters:coincap:utils', () => {
+    describe('parseEthData', () => {
+        it('can parse eth data', () => {
+            const result = parseEthData([makeEthMockCoincapResponse(), makeFoxMockCoincapResponse()]);
+            const expected = {
+                'eip155:1/slip44:60': 'ethereum',
+                'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d': 'fox-token',
+            };
+            expect(result).toEqual(expected);
+        });
+        it('can parse btc data', () => {
+            const result = bitcoinAssetMap;
+            const expected = { 'bip122:000000000019d6689c085ae165831e93/slip44:0': 'bitcoin' };
+            expect(result).toEqual(expected);
+        });
+        it('can parse cosmos data', () => {
+            const result = cosmosAssetMap;
+            const expected = { 'cosmos:cosmoshub-4/slip44:118': 'cosmos' };
+            expect(result).toEqual(expected);
+        });
+    });
+    describe('parseData', () => {
+        it('can parse all data', () => {
+            const result = 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',
+                },
+            };
+            expect(result).toEqual(expected);
+        });
+    });
+    describe('writeFiles', () => {
+        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 = vi.fn();
+            await writeFiles(data);
+            expect(realFs.promises.writeFile).toBeCalledWith('./src/adapters/coincap/generated/foo/adapter.json', fooAssetIds);
+            expect(realFs.promises.writeFile).toBeCalledWith('./src/adapters/coincap/generated/bar/adapter.json', barAssetIds);
+            expect(console.info).toBeCalledWith('Generated CoinCap AssetId adapter data.');
+        });
+    });
+});

package/dist/esm/adapters/coingecko/generate.d.ts

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

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

@@ -0,0 +1,8 @@
+import { coingeckoUrl } from './index.js';
+import { fetchData, parseData, writeFiles } from './utils.js';
+const main = async () => {
+    const data = await fetchData(coingeckoUrl);
+    const output = parseData(data);
+    await writeFiles(output);
+};
+main();

package/dist/esm/adapters/coingecko/generated/bip122_000000000000000000651ef99cb9fcbe/adapter.json

@@ -0,0 +1 @@
+{ "bip122:000000000000000000651ef99cb9fcbe/slip44:145": "bitcoin-cash" }

package/dist/esm/adapters/coingecko/generated/bip122_000000000019d6689c085ae165831e93/adapter.json

@@ -0,0 +1 @@
+{ "bip122:000000000019d6689c085ae165831e93/slip44:0": "bitcoin" }

package/dist/esm/adapters/coingecko/generated/bip122_00000000001a91e3dace36e2be3bf030/adapter.json

@@ -0,0 +1 @@
+{ "bip122:00000000001a91e3dace36e2be3bf030/slip44:3": "dogecoin" }

package/dist/esm/adapters/coingecko/generated/bip122_12a765e31ffd4059bada1e25190f6e98/adapter.json

@@ -0,0 +1 @@
+{ "bip122:12a765e31ffd4059bada1e25190f6e98/slip44:2": "litecoin" }

package/dist/esm/adapters/coingecko/generated/cosmos_cosmoshub-4/adapter.json

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

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

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

package/dist/esm/adapters/coingecko/generated/cosmos_thorchain-1/adapter.json

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