@shapeshiftoss/caip 8.16.4 → 8.16.5

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

@@ -0,0 +1,226 @@
+import axios from 'axios';
+import fs from 'fs';
+import { toAssetId } from '../../assetId/assetId.js';
+import { arbitrumAssetId, arbitrumChainId, arbitrumNovaAssetId, arbitrumNovaChainId, ASSET_NAMESPACE, avalancheAssetId, avalancheChainId, baseAssetId, baseChainId, bchChainId, bscAssetId, bscChainId, btcChainId, CHAIN_NAMESPACE, CHAIN_REFERENCE, cosmosChainId, dogeChainId, ethAssetId, ethChainId, gnosisAssetId, gnosisChainId, ltcChainId, mayachainChainId, monadAssetId, monadChainId, optimismAssetId, optimismChainId, polygonAssetId, polygonChainId, solanaChainId, solAssetId, suiAssetId, suiChainId, thorchainChainId, tronAssetId, tronChainId, } from '../../constants.js';
+import { bitcoinAssetMap, bitcoinCashAssetMap, cosmosAssetMap, dogecoinAssetMap, litecoinAssetMap, mayachainAssetMap, thorchainAssetMap, } from '../../utils.js';
+import { CoingeckoAssetPlatform } from './index.js';
+export const fetchData = async (URL) => (await axios.get(URL)).data;
+export const parseData = (coins) => {
+    const assetMap = coins.reduce((prev, { id, platforms }) => {
+        if (Object.keys(platforms).includes(CoingeckoAssetPlatform.Ethereum)) {
+            try {
+                const assetId = toAssetId({
+                    chainNamespace: CHAIN_NAMESPACE.Evm,
+                    chainReference: CHAIN_REFERENCE.EthereumMainnet,
+                    assetNamespace: 'erc20',
+                    assetReference: platforms[CoingeckoAssetPlatform.Ethereum],
+                });
+                prev[ethChainId][assetId] = id;
+            }
+            catch {
+                // unable to create assetId, skip token
+            }
+        }
+        if (Object.keys(platforms).includes(CoingeckoAssetPlatform.Avalanche)) {
+            try {
+                const assetId = toAssetId({
+                    chainNamespace: CHAIN_NAMESPACE.Evm,
+                    chainReference: CHAIN_REFERENCE.AvalancheCChain,
+                    assetNamespace: 'erc20',
+                    assetReference: platforms[CoingeckoAssetPlatform.Avalanche],
+                });
+                prev[avalancheChainId][assetId] = id;
+            }
+            catch {
+                // unable to create assetId, skip token
+            }
+        }
+        if (Object.keys(platforms).includes(CoingeckoAssetPlatform.Optimism)) {
+            try {
+                const assetId = toAssetId({
+                    chainNamespace: CHAIN_NAMESPACE.Evm,
+                    chainReference: CHAIN_REFERENCE.OptimismMainnet,
+                    assetNamespace: 'erc20',
+                    assetReference: platforms[CoingeckoAssetPlatform.Optimism],
+                });
+                prev[optimismChainId][assetId] = id;
+            }
+            catch {
+                // unable to create assetId, skip token
+            }
+        }
+        if (Object.keys(platforms).includes(CoingeckoAssetPlatform.BnbSmartChain)) {
+            try {
+                const assetId = toAssetId({
+                    chainNamespace: CHAIN_NAMESPACE.Evm,
+                    chainReference: CHAIN_REFERENCE.BnbSmartChainMainnet,
+                    assetNamespace: 'erc20',
+                    assetReference: platforms[CoingeckoAssetPlatform.BnbSmartChain],
+                });
+                prev[bscChainId][assetId] = id;
+            }
+            catch {
+                // unable to create assetId, skip token
+            }
+        }
+        if (Object.keys(platforms).includes(CoingeckoAssetPlatform.Polygon)) {
+            try {
+                const assetId = toAssetId({
+                    chainNamespace: CHAIN_NAMESPACE.Evm,
+                    chainReference: CHAIN_REFERENCE.PolygonMainnet,
+                    assetNamespace: 'erc20',
+                    assetReference: platforms[CoingeckoAssetPlatform.Polygon],
+                });
+                prev[polygonChainId][assetId] = id;
+            }
+            catch (err) {
+                // unable to create assetId, skip token
+            }
+        }
+        if (Object.keys(platforms).includes(CoingeckoAssetPlatform.Gnosis)) {
+            try {
+                const assetId = toAssetId({
+                    chainNamespace: CHAIN_NAMESPACE.Evm,
+                    chainReference: CHAIN_REFERENCE.GnosisMainnet,
+                    assetNamespace: 'erc20',
+                    assetReference: platforms[CoingeckoAssetPlatform.Gnosis],
+                });
+                prev[gnosisChainId][assetId] = id;
+            }
+            catch (err) {
+                // unable to create assetId, skip token
+            }
+        }
+        if (Object.keys(platforms).includes(CoingeckoAssetPlatform.Arbitrum)) {
+            try {
+                const assetId = toAssetId({
+                    chainNamespace: CHAIN_NAMESPACE.Evm,
+                    chainReference: CHAIN_REFERENCE.ArbitrumMainnet,
+                    assetNamespace: 'erc20',
+                    assetReference: platforms[CoingeckoAssetPlatform.Arbitrum],
+                });
+                prev[arbitrumChainId][assetId] = id;
+            }
+            catch (err) {
+                // unable to create assetId, skip token
+            }
+        }
+        if (Object.keys(platforms).includes(CoingeckoAssetPlatform.ArbitrumNova)) {
+            try {
+                const assetId = toAssetId({
+                    chainNamespace: CHAIN_NAMESPACE.Evm,
+                    chainReference: CHAIN_REFERENCE.ArbitrumNovaMainnet,
+                    assetNamespace: 'erc20',
+                    assetReference: platforms[CoingeckoAssetPlatform.ArbitrumNova],
+                });
+                prev[arbitrumNovaChainId][assetId] = id;
+            }
+            catch (err) {
+                // unable to create assetId, skip token
+            }
+        }
+        if (Object.keys(platforms).includes(CoingeckoAssetPlatform.Base)) {
+            try {
+                const assetId = toAssetId({
+                    chainNamespace: CHAIN_NAMESPACE.Evm,
+                    chainReference: CHAIN_REFERENCE.BaseMainnet,
+                    assetNamespace: 'erc20',
+                    assetReference: platforms[CoingeckoAssetPlatform.Base],
+                });
+                prev[baseChainId][assetId] = id;
+            }
+            catch {
+                // unable to create assetId, skip token
+            }
+        }
+        if (Object.keys(platforms).includes(CoingeckoAssetPlatform.Solana)) {
+            try {
+                const assetId = toAssetId({
+                    chainNamespace: CHAIN_NAMESPACE.Solana,
+                    chainReference: CHAIN_REFERENCE.SolanaMainnet,
+                    assetNamespace: 'token',
+                    assetReference: platforms[CoingeckoAssetPlatform.Solana],
+                });
+                prev[solanaChainId][assetId] = id;
+            }
+            catch {
+                // unable to create assetId, skip token
+            }
+        }
+        if (Object.keys(platforms).includes(CoingeckoAssetPlatform.Tron)) {
+            try {
+                const assetId = toAssetId({
+                    chainNamespace: CHAIN_NAMESPACE.Tron,
+                    chainReference: CHAIN_REFERENCE.TronMainnet,
+                    assetNamespace: 'trc20',
+                    assetReference: platforms[CoingeckoAssetPlatform.Tron],
+                });
+                prev[tronChainId][assetId] = id;
+            }
+            catch {
+                // unable to create assetId, skip token
+            }
+        }
+        if (Object.keys(platforms).includes(CoingeckoAssetPlatform.Sui)) {
+            try {
+                const assetId = toAssetId({
+                    chainNamespace: CHAIN_NAMESPACE.Sui,
+                    chainReference: CHAIN_REFERENCE.SuiMainnet,
+                    assetNamespace: ASSET_NAMESPACE.suiCoin,
+                    assetReference: platforms[CoingeckoAssetPlatform.Sui],
+                });
+                prev[suiChainId][assetId] = id;
+            }
+            catch {
+                // unable to create assetId, skip token
+            }
+        }
+        if (Object.keys(platforms).includes(CoingeckoAssetPlatform.Monad)) {
+            try {
+                const assetId = toAssetId({
+                    chainNamespace: CHAIN_NAMESPACE.Evm,
+                    chainReference: CHAIN_REFERENCE.MonadMainnet,
+                    assetNamespace: 'erc20',
+                    assetReference: platforms[CoingeckoAssetPlatform.Monad],
+                });
+                prev[monadChainId][assetId] = id;
+            }
+            catch {
+                // unable to create assetId, skip token
+            }
+        }
+        return prev;
+    }, {
+        [ethChainId]: { [ethAssetId]: 'ethereum' },
+        [avalancheChainId]: { [avalancheAssetId]: 'avalanche-2' },
+        [optimismChainId]: { [optimismAssetId]: 'ethereum' },
+        [bscChainId]: { [bscAssetId]: 'binancecoin' },
+        [polygonChainId]: { [polygonAssetId]: 'matic-network' },
+        [gnosisChainId]: { [gnosisAssetId]: 'xdai' },
+        [arbitrumChainId]: { [arbitrumAssetId]: 'ethereum' },
+        [arbitrumNovaChainId]: { [arbitrumNovaAssetId]: 'ethereum' },
+        [baseChainId]: { [baseAssetId]: 'ethereum' },
+        [monadChainId]: { [monadAssetId]: 'monad' },
+        [solanaChainId]: { [solAssetId]: 'solana' },
+        [tronChainId]: { [tronAssetId]: 'tron' },
+        [suiChainId]: { [suiAssetId]: 'sui' },
+    });
+    return {
+        ...assetMap,
+        [btcChainId]: bitcoinAssetMap,
+        [bchChainId]: bitcoinCashAssetMap,
+        [dogeChainId]: dogecoinAssetMap,
+        [ltcChainId]: litecoinAssetMap,
+        [cosmosChainId]: cosmosAssetMap,
+        [thorchainChainId]: thorchainAssetMap,
+        [mayachainChainId]: mayachainAssetMap,
+    };
+};
+export const writeFiles = async (data) => {
+    await Promise.all(Object.entries(data).map(async ([chainId, assets]) => {
+        const dirPath = `./src/adapters/coingecko/generated/${chainId}`.replace(':', '_');
+        await fs.promises.mkdir(dirPath, { recursive: true });
+        await fs.promises.writeFile(`${dirPath}/adapter.json`, JSON.stringify(assets));
+    }));
+    console.info('Generated CoinGecko AssetId adapter data.');
+};

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

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

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

@@ -0,0 +1,197 @@
+import realFs from 'fs';
+import { describe, expect, it, vi } from 'vitest';
+import { bitcoinAssetMap, cosmosAssetMap } from '../../utils.js';
+import { parseData, writeFiles } from './utils.js';
+const makeEthMockCoingeckoResponse = () => ({
+    id: 'ethereum',
+    symbol: 'eth',
+    platforms: {},
+});
+const makeWethMockCoingeckoResponse = () => ({
+    id: 'weth',
+    symbol: 'weth',
+    name: 'WETH',
+    platforms: {
+        ethereum: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+        'optimistic-ethereum': '0x4200000000000000000000000000000000000006',
+        avalanche: '0x49d5c2bdffac6ce2bfdb6640f4f80f226bc10bab',
+        'binance-smart-chain': '0x2170ed0880ac9a755fd29b2688956bd959f933f8',
+        'polygon-pos': '0x7ceb23fd6bc0add59e62ac25578270cff1b9f619',
+        xdai: '0x6a023ccd1ff6f2045c3309768ead9e68f978f6e1',
+        'arbitrum-one': '0x82af49447d8a07e3bd95bd0d56f35241523fbab1',
+        'arbitrum-nova': '0x722e8bdd2ce80a4422e880164f2079488e115365',
+        base: '0x4200000000000000000000000000000000000006',
+    },
+});
+const makeAvalancheMockCoingeckoResponse = () => ({
+    id: 'avalanche-2',
+    symbol: 'avax',
+    platforms: {},
+});
+const makeFoxMockCoingeckoResponse = () => ({
+    id: 'shapeshift-fox-token',
+    symbol: 'fox',
+    platforms: {
+        ethereum: '0xc770eefad204b5180df6a14ee197d99d808ee52d',
+    },
+});
+const makeBtcMockCoingeckoResponse = () => ({
+    id: 'bitcoin',
+    symbol: 'btc',
+    platforms: {},
+});
+const makeCosmosMockCoingeckoResponse = () => ({
+    id: 'cosmos',
+    symbol: 'atom',
+    platforms: {},
+});
+const makePolygonMockCoingeckoResponse = () => ({
+    id: 'polygon-pos',
+    symbol: 'matic',
+    platforms: {},
+});
+const makeGnosisMockCoingeckoResponse = () => ({
+    id: 'gnosis',
+    symbol: 'xDai',
+    platforms: {},
+});
+const makeThorchainMockCoingeckoResponse = () => ({
+    id: 'thorchain',
+    symbol: 'rune',
+    platforms: {
+        thorchain: '',
+    },
+});
+vi.mock('fs', () => ({
+    default: {
+        promises: {
+            writeFile: vi.fn(() => undefined),
+            mkdir: vi.fn(() => undefined),
+        },
+    },
+}));
+describe('adapters:coingecko:utils', () => {
+    describe('makeData', () => {
+        it('can make btc data', () => {
+            const result = bitcoinAssetMap;
+            const expected = { 'bip122:000000000019d6689c085ae165831e93/slip44:0': 'bitcoin' };
+            expect(result).toEqual(expected);
+        });
+        it('can make 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([
+                makeEthMockCoingeckoResponse(),
+                makeWethMockCoingeckoResponse(),
+                makeFoxMockCoingeckoResponse(),
+                makeBtcMockCoingeckoResponse(),
+                makeCosmosMockCoingeckoResponse(),
+                makeThorchainMockCoingeckoResponse(),
+                makeAvalancheMockCoingeckoResponse(),
+                makePolygonMockCoingeckoResponse(),
+                makeGnosisMockCoingeckoResponse(),
+            ]);
+            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',
+                },
+                'cosmos:mayachain-mainnet-v1': {
+                    'cosmos:mayachain-mainnet-v1/slip44:931': 'cacao',
+                },
+                'eip155:1': {
+                    'eip155:1/slip44:60': 'ethereum',
+                    'eip155:1/erc20:0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2': 'weth',
+                    'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d': 'shapeshift-fox-token',
+                },
+                'eip155:43114': {
+                    'eip155:43114/slip44:60': 'avalanche-2',
+                    'eip155:43114/erc20:0x49d5c2bdffac6ce2bfdb6640f4f80f226bc10bab': 'weth',
+                },
+                'eip155:56': {
+                    'eip155:56/slip44:60': 'binancecoin',
+                    'eip155:56/erc20:0x2170ed0880ac9a755fd29b2688956bd959f933f8': 'weth',
+                },
+                'eip155:10': {
+                    'eip155:10/slip44:60': 'ethereum',
+                    'eip155:10/erc20:0x4200000000000000000000000000000000000006': 'weth',
+                },
+                'eip155:137': {
+                    'eip155:137/slip44:60': 'matic-network',
+                    'eip155:137/erc20:0x7ceb23fd6bc0add59e62ac25578270cff1b9f619': 'weth',
+                },
+                'eip155:100': {
+                    'eip155:100/slip44:60': 'xdai',
+                    'eip155:100/erc20:0x6a023ccd1ff6f2045c3309768ead9e68f978f6e1': 'weth',
+                },
+                'eip155:42161': {
+                    'eip155:42161/slip44:60': 'ethereum',
+                    'eip155:42161/erc20:0x82af49447d8a07e3bd95bd0d56f35241523fbab1': 'weth',
+                },
+                'eip155:42170': {
+                    'eip155:42170/slip44:60': 'ethereum',
+                    'eip155:42170/erc20:0x722e8bdd2ce80a4422e880164f2079488e115365': 'weth',
+                },
+                'eip155:8453': {
+                    'eip155:8453/slip44:60': 'ethereum',
+                    'eip155:8453/erc20:0x4200000000000000000000000000000000000006': 'weth',
+                },
+                'eip155:143': {
+                    'eip155:143/slip44:60': 'monad',
+                },
+                'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp': {
+                    'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp/slip44:501': 'solana',
+                },
+                'sui:35834a8a': {
+                    'sui:35834a8a/slip44:784': 'sui',
+                },
+                'tron:0x2b6653dc': {
+                    'tron:0x2b6653dc/slip44:195': 'tron',
+                },
+            };
+            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.mkdir).toHaveBeenNthCalledWith(1, './src/adapters/coingecko/generated/foo', { recursive: true });
+            expect(realFs.promises.writeFile).toHaveBeenNthCalledWith(1, './src/adapters/coingecko/generated/foo/adapter.json', fooAssetIds);
+            expect(realFs.promises.mkdir).toHaveBeenNthCalledWith(2, './src/adapters/coingecko/generated/bar', { recursive: true });
+            expect(realFs.promises.writeFile).toHaveBeenNthCalledWith(2, './src/adapters/coingecko/generated/bar/adapter.json', barAssetIds);
+            expect(console.info).toBeCalledWith('Generated CoinGecko AssetId adapter data.');
+        });
+    });
+});

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

@@ -0,0 +1,6 @@
+export * from './coingecko/index.js';
+export * from './coincap/index.js';
+export * from './banxa/index.js';
+export * from './coinbase/index.js';
+export * from './mtpelerin/index.js';
+export * from './onramper/index.js';

package/dist/esm/adapters/index.js

@@ -0,0 +1,6 @@
+export * from './coingecko/index.js';
+export * from './coincap/index.js';
+export * from './banxa/index.js';
+export * from './coinbase/index.js';
+export * from './mtpelerin/index.js';
+export * from './onramper/index.js';

package/dist/esm/adapters/mtpelerin/index.d.ts

@@ -0,0 +1,10 @@
+import type { AssetId } from '../../assetId/assetId.js';
+export declare const mtPelerinSymbolToAssetIds: (id: string) => AssetId[];
+export declare const assetIdToMtPelerinSymbol: (assetId: AssetId) => string | undefined;
+/**
+ * Convert a mtPelerin asset identifier to a MtPelerin chain identifier for use in MtPelerin HTTP URLs
+ *
+ * @param {string} assetId - an assetId string referencing a specific asset; e.g., ethAssetId
+ * @returns {string} - a MtPelerin network identifier; e.g., 'mainnet'
+ */
+export declare const getMtPelerinNetFromAssetId: (assetId: AssetId) => string | undefined;

package/dist/esm/adapters/mtpelerin/index.js

@@ -0,0 +1,121 @@
+import { fromAssetId } from '../../assetId/assetId.js';
+import { arbitrumAssetId, arbitrumChainId, avalancheAssetId, avalancheChainId, baseAssetId, baseChainId, bscAssetId, bscChainId, btcAssetId, btcChainId, ethAssetId, ethChainId, gnosisAssetId, gnosisChainId, optimismAssetId, optimismChainId, polygonAssetId, polygonChainId, } from '../../constants.js';
+/**
+ * provided from https://api.mtPelerin.com/currencies/tokens
+ */
+const MtPelerinSymbolToAssetIds = {
+    ETH: [ethAssetId, optimismAssetId, arbitrumAssetId, baseAssetId],
+    POL: [polygonAssetId],
+    XDAI: [gnosisAssetId],
+    BTC: [btcAssetId],
+    BNB: [bscAssetId],
+    DAI: ['eip155:1/erc20:0x6b175474e89094c44da98b954eedeac495271d0f'],
+    USDT: [
+        'eip155:1/erc20:0xdac17f958d2ee523a2206206994597c13d831ec7',
+        'eip155:10/erc20:0x94b008aa00579c1307b0ef2c499ad98a8ce58e58',
+        'eip155:56/erc20:0x55d398326f99059ff775485246999027b3197955',
+        'eip155:100/erc20:0x4ecaba5870353805a9f068101a40e0f32ed605c6',
+        'eip155:137/erc20:0xc2132d05d31c914a87c6611c10748aeb04b58e8f',
+        'eip155:42161/erc20:0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9',
+    ],
+    USDC: [
+        'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+        'eip155:10/erc20:0x0b2c639c533813f4aa9d7837caf62653d097ff85',
+        'eip155:56/erc20:0x8ac76a51cc950d9822d68b83fe1ad97b32cd580d',
+        'eip155:137/erc20:0x3c499c542cef5e3811e1192ce70d8cc03d5c3359',
+        'eip155:100/erc20:0xddafbb505ad214d7b80b1f830fccc89b60fb7a83',
+        'eip155:42161/erc20:0xaf88d065e77c8cc2239327c5edb3a432268e5831',
+        'eip155:43114/erc20:0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e',
+        'eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
+    ],
+    'USDC.e': [
+        'eip155:10/erc20:0x7f5c764cbc14f9669b88837ca1490cca17c31607',
+        'eip155:137/erc20:0x2791bca1f2de4661ed88a30c99a7a9449aa84174',
+        'eip155:42161/erc20:0xff970a61a04b1ca14834a43f5de4533ebddb5cc8',
+        'eip155:43114/erc20:0xa7d7079b0fead91f3e65f86e8915cb59c1a4c664',
+    ],
+    WBTC: [
+        'eip155:1/erc20:0x2260fac5e5542a773aa44fbcfedf7c193bc2c599',
+        'eip155:10/erc20:0x68f180fcce6836688e9084f035309e29bf0a2095',
+        'eip155:100/erc20:0x8e5bbbb09ed1ebde8674cda39a0c169401db4252',
+        'eip155:137/erc20:0x1bfd67037b42cf73acf2047067bd4f2c47d9bfd6',
+        'eip155:42161/erc20:0x2f2a2543b76a4166549f7aab2e75bef0aefc5b0f',
+    ],
+    AVAX: [avalancheAssetId],
+    'BTC.b': ['eip155:43114/erc20:0x152b9d0fdc40c096757f570a51e494bd4b943e50'],
+    cbBTC: [
+        'eip155:1/erc20:0xcbb7c0000ab88b473b1f5afd9ef808440eed33bf',
+        'eip155:8453/erc20:0xcbb7c0000ab88b473b1f5afd9ef808440eed33bf',
+    ],
+    EURA: [
+        'eip155:42161/erc20:0xfa5ed56a203466cbbc2430a43c66b9d8723528e7',
+        'eip155:137/erc20:0xe0b52e49357fd4daf2c15e02058dce6bc0057db4',
+    ],
+    EURC: [
+        'eip155:1/erc20:0x1abaea1f7c830bd89acc67ec4af516284b1bc33c',
+        'eip155:8453/erc20:0x60a3e35cc302bfa44cb288bc5a4f316fdb1adb42',
+        'eip155:43114/erc20:0xc891eb4cbdeff6e073e859e987815ed1505c2acd',
+    ],
+    EURS: [
+        'eip155:1/erc20:0xdb25f211ab05b1c97d595516f45794528a807ad8',
+        'eip155:137/erc20:0xe111178a87a3bff0c8d18decba5798827539ae99',
+    ],
+    FRAX: [
+        'eip155:1/erc20:0x853d955acef822db058eb8505911ed77f175b99e',
+        'eip155:137/erc20:0x45c32fa6df82ead1e2ef74d17b76547eddfaff89',
+        'eip155:43114/erc20:0xd24c2ad096400b6fbcd2ad8b24e7acbc21a1da64',
+    ],
+    GHO: ['eip155:1/erc20:0x40d16fc0246ad3160ccc09b8d0d3a2cd28ae6c2f'],
+    LUSD: [
+        'eip155:1/erc20:0x5f98805a4e8be255a32880fdec7f6728c6568ba0',
+        'eip155:10/erc20:0xc40f949f8a4e094d1b49a23ea9241d289b7b2819',
+    ],
+    PAXG: ['eip155:1/erc20:0x45804880de22913dafe09f4980848ece6ecbaf78'],
+    WETH: [
+        'eip155:56/erc20:0x2170ed0880ac9a755fd29b2688956bd959f933f8',
+        'eip155:100/erc20:0x6a023ccd1ff6f2045c3309768ead9e68f978f6e1',
+        'eip155:137/erc20:0x7ceb23fd6bc0add59e62ac25578270cff1b9f619',
+    ],
+    BTCB: ['eip155:56/erc20:0x7130d2a12b9bcbfae4f2634d864a1ee1ce3ead9c'],
+    crvUSD: ['eip155:1/erc20:0xf939e0a03fb07f59a73314e73794be0e57ac1b4e'],
+    XAUt: ['eip155:1/erc20:0x68749665ff8d2d112fa859aa293f07a622782f38'],
+    ZCHF: [
+        'eip155:1/erc20:0xb58e61c3098d85632df34eecfb899a1ed80921cb',
+        'eip155:100/erc20:0xd4dd9e2f021bb459d5a5f6c24c12fe09c5d45553',
+    ],
+};
+export const mtPelerinSymbolToAssetIds = (id) => MtPelerinSymbolToAssetIds[id];
+export const assetIdToMtPelerinSymbol = (assetId) => {
+    return Object.entries(MtPelerinSymbolToAssetIds)
+        .filter(([, assetIds]) => assetIds.includes(assetId))
+        .map(([key]) => key)[0];
+};
+/**
+ * map ChainIds to MtPelerin network,
+ * since some MtPelerin assets could be on multiple chains and their default
+ * chain won't be exactly the same as ours.
+ *
+ * https://developers.mtPelerin.com/integration-guides/options -> "net"
+ * source of truth per MtPelerin
+ */
+const chainIdToMtPelerinNetworkCodeMap = {
+    [ethChainId]: 'mainnet',
+    [btcChainId]: 'bitcoin_mainnet',
+    [avalancheChainId]: 'avalanche_mainnet',
+    [optimismChainId]: 'optimism_mainnet',
+    [polygonChainId]: 'matic_mainnet',
+    [gnosisChainId]: 'xdai_mainnet',
+    [bscChainId]: 'bsc_mainnet',
+    [arbitrumChainId]: 'arbitrum_mainnet',
+    [baseChainId]: 'base_mainnet',
+};
+/**
+ * Convert a mtPelerin asset identifier to a MtPelerin chain identifier for use in MtPelerin HTTP URLs
+ *
+ * @param {string} assetId - an assetId string referencing a specific asset; e.g., ethAssetId
+ * @returns {string} - a MtPelerin network identifier; e.g., 'mainnet'
+ */
+export const getMtPelerinNetFromAssetId = (assetId) => {
+    const { chainId } = fromAssetId(assetId);
+    return chainIdToMtPelerinNetworkCodeMap[chainId];
+};

package/dist/esm/adapters/onramper/index.d.ts

@@ -0,0 +1,6 @@
+import type { AssetId } from '../../assetId/assetId.js';
+type OnRamperTokenId = string;
+export declare const NativeAssetIdToOnRamperIdMap: Record<AssetId, OnRamperTokenId[]>;
+export declare const onRamperTokenIdToAssetId: (tokenId: OnRamperTokenId) => AssetId | undefined;
+export declare const assetIdToOnRamperTokenList: (assetId: AssetId) => OnRamperTokenId[] | undefined;
+export {};

package/dist/esm/adapters/onramper/index.js

@@ -0,0 +1,31 @@
+import entries from 'lodash/entries';
+import { arbitrumAssetId, avalancheAssetId, baseAssetId, bchAssetId, bscAssetId, btcAssetId, cosmosAssetId, dogeAssetId, ethAssetId, gnosisAssetId, ltcAssetId, optimismAssetId, polygonAssetId, solAssetId, thorchainAssetId, } from '../../constants.js';
+// Native assets only - tokens are fetched dynamically
+export const NativeAssetIdToOnRamperIdMap = {
+    [bscAssetId]: ['bnb_bsc'],
+    [dogeAssetId]: ['doge_dogecoin'],
+    [ethAssetId]: ['eth'],
+    [arbitrumAssetId]: ['eth_arbitrum'],
+    [optimismAssetId]: ['eth_optimism'],
+    [baseAssetId]: ['eth_base'],
+    [ltcAssetId]: ['ltc_litecoin'],
+    [polygonAssetId]: ['matic_polygon'],
+    [thorchainAssetId]: ['rune_thorchain'],
+    [avalancheAssetId]: ['avax_avaxc'],
+    [btcAssetId]: ['btc'],
+    [bchAssetId]: ['bch_bitcoincash'],
+    [cosmosAssetId]: ['atom_cosmos'],
+    [gnosisAssetId]: ['xdai_gnosis'],
+    [solAssetId]: ['sol'],
+};
+// explodes and inverts the assetId => tokenId[] map by creating a 1to1 token => assetId mapping
+const invertMap = () => {
+    const invertedMap = {};
+    entries(NativeAssetIdToOnRamperIdMap).flatMap(([assetId, idList]) => idList.forEach(id => {
+        invertedMap[id] = assetId;
+    }));
+    return invertedMap;
+};
+const OnRamperIdToAssetIdMap = invertMap();
+export const onRamperTokenIdToAssetId = (tokenId) => OnRamperIdToAssetIdMap[tokenId];
+export const assetIdToOnRamperTokenList = (assetId) => NativeAssetIdToOnRamperIdMap[assetId];

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

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