Draft: Generate Mintscan Assets (#1941)

* Update Mintscan Asset generation

* update generate code

* update mintscan assets

* update counter_party -> counterparty

* update generated file

.github/workflows/utility/assetlist_functions.mjs

@@ -32,6 +32,7 @@ export const generatedDirectoryName = "generated";
 export const chainRegAssetlist = path.join(generatedDirectoryName, "chain_registry");
 export const zoneConfigAssetlist = path.join(generatedDirectoryName, "frontend");
 export const zoneConfigChainlist = path.join(generatedDirectoryName, "frontend");
+export const externalDir = path.join(generatedDirectoryName, "external");
 export const zoneAssetDetail = path.join(generatedDirectoryName, "asset_detail");
 
 //- Chain Names --

.github/workflows/utility/generateMintscanAssets.mjs

@@ -0,0 +1,234 @@
+
+// Purpose:
+// to generate the assets file for Mintscan asset recognition
+
+
+//-- Imports --
+
+import * as zone from "./assetlist_functions.mjs";
+import * as chain_reg from '../../../chain-registry/.github/workflows/utility/chain_registry.mjs';
+import * as path from 'path';
+
+const mintscanAssetsFileName = "assets.json";
+const mintscanDirName = "mintscan";
+const mintscanDir = path.join(zone.externalDir, mintscanDirName);
+
+
+// Function to map the source "coinMinimalDenom" to the target "denom"
+const mapAssets = (sourceAssets) => {
+ return sourceAssets.map(asset => {
+ return {
+ denom: asset.coinMinimalDenom
+ };
+ });
+};
+
+function isStaking(chainName, baseDenom) {
+
+ let stakingAssetDenom = chain_reg.getFileProperty(chainName, "chain", "staking")?.staking_tokens?.[0].denom;
+ if (baseDenom === stakingAssetDenom) {
+ return true;
+ } else {
+ return false;
+ }
+
+}
+
+function getAssetType(asset) {
+
+ const ibc_type = "ics20";
+ if (asset.type_asset === ibc_type) {
+ return "ibc";
+ }
+
+ const bridge_type = "bridge";
+ if (Array.isArray(asset.traces) && asset.traces.length > 0) {
+ const typeOfLastTrace = asset.traces[asset.traces.length - 1]?.type;
+ if (typeOfLastTrace === bridge_type) {
+ return "bridge";
+ }
+ }
+
+ return "native";
+
+}
+
+function getAssetDecimals(chainName, asset) {
+
+ return chain_reg.getAssetDecimals(chainName, asset.base);
+
+}
+
+function getAssetPath(chainName, asset) {
+
+ if (Array.isArray(asset.traces) && asset.traces.length > 0) {
+ const traces = asset.traces;
+ let path = "";
+ for (let i = traces.length - 1; i >= 0; i--) {
+ if (traces[i].type === "bridge") {
+ path = getCosmoStationChainName(traces[i].counterparty.chain_name) + ">" + path;
+ break;
+ }
+ if (
+ traces[i].type === "ibc" ||
+ traces[i].type === "ibc-cw20"
+ ) {
+ path = getCosmoStationChainName(traces[i].counterparty.chain_name) + ">" + path;
+ } else { break; }
+ }
+ if (path) {
+ path += chainName;
+ }
+ return path;
+ }
+
+}
+
+function getIbcInfo(chainName, asset) {
+
+ const transferPort = "transfer";
+ const trace = asset.traces[asset.traces.length - 1];
+ let ibc_info = {};
+ ibc_info.path = getAssetPath(chainName, asset);
+ ibc_info.client = {
+ channel: trace.chain.channel_id,
+ port: trace.chain.port ?? transferPort
+ };
+ ibc_info.counterparty = {
+ channel: trace.counterparty.channel_id,
+ port: trace.counterparty.port ?? transferPort,
+ chain: getCosmoStationChainName(trace.counterparty.chain_name),
+ denom: trace.counterparty.base_denom
+ };
+ return ibc_info;
+
+}
+
+function getBridgeInfo(chainName, asset) {
+
+ let bridge_info = {};
+ bridge_info.path = getAssetPath(chainName, asset);
+ return bridge_info;
+
+}
+
+function getAssetCoinGeckoId(chainName, asset) {
+
+ const traceTypes = [
+ "ibc",
+ "ibc-cw20",
+ "additional-mintage"
+ ];
+
+ let coinGeckoId = chain_reg.getAssetPropertyWithTraceCustom(chainName, asset.base, "coingecko_id", traceTypes);
+ //find a way to make it return the canonical cgid when it's canonical
+ return coinGeckoId;
+
+}
+
+
+//Global Var
+const cosmoStationChainsMap = new Map();
+
+async function saveCosmoStationChainNames() {
+
+ const cosmoStationApiUrl = "https://front.api.mintscan.io/v10/meta/support/chains";
+
+ try {
+ // Fetch data from the API
+ const response = await fetch(cosmoStationApiUrl);
+ if (!response.ok) {
+ throw new Error(`Error fetching data: ${response.statusText}`);
+ }
+
+ const cosmoStationData = await response.json();
+ const cosmoStationChains = cosmoStationData.chains;
+
+ // Populate the map with chainId as key and cosmoStationChainName as value
+ if (Array.isArray(cosmoStationChains)) {
+ cosmoStationChains.forEach(chainObject => {
+ cosmoStationChainsMap.set(chainObject.chain_id, chainObject.chain);
+ });
+ }
+
+ console.log("Map initialized with chain ID to Cosmo Station chain name pairs.");
+ } catch (error) {
+ console.error('Error initializing Cosmo Station chains map:', error);
+ }
+
+}
+
+function getCosmoStationChainName(chainRegistryChainName) {
+
+ // Get chain-id from chain name
+ const chainId = chain_reg.getFileProperty(chainRegistryChainName, "chain", "chain_id");
+ if (!chainId) {
+ return chainRegistryChainName;
+ }
+
+ //Get the chain name from the map
+ return cosmoStationChainsMap.get(chainId) || chainRegistryChainName;
+
+}
+
+function getAssetImage(asset) {
+
+ //Use CosmoStation's custom 3D logo if it's OSMO
+ if (asset.base === "uosmo") {
+ return "https://raw.githubusercontent.com/cosmostation/chainlist/master/chain/osmosis/asset/osmo.png";
+ }
+ //Otherwise, may use the Chain Registry logo
+ return asset.images?.[0].svg ?? asset.images?.[0].png;
+
+}
+
+
+const processAsset = (chainName, asset) => {
+
+ let assetObject = {};
+ assetObject.type = getAssetType(asset);
+ assetObject.denom = asset.base;
+ assetObject.name = asset.name;
+ assetObject.symbol = asset.symbol;
+ assetObject.decimals = getAssetDecimals(chainName, asset);
+ assetObject.description = asset.description;
+ assetObject.image = getAssetImage(asset);
+ assetObject.color = asset.images?.[0].theme?.primary_color_hex;
+ assetObject.coinGeckoId = getAssetCoinGeckoId(chainName, asset);
+ if (assetObject.type === "ibc") {
+ assetObject.ibc_info = getIbcInfo(chainName, asset);
+ }
+ if (assetObject.type === "bridge") {
+ assetObject.bridge_info = getBridgeInfo(chainName, asset);
+ }
+ return assetObject;
+};
+
+
+// Main function to convert one JSON file to another
+const generateMintscanAssets = (chainName) => {
+
+ // Read the source file
+ const sourceData = zone.readFromFile(chainName, zone.chainRegAssetlist, zone.assetlistFileName);
+ const transformedAssets = [];
+ for (const asset of sourceData.assets) {
+ // Process each asset using the custom processing function
+ const transformedAsset = processAsset(chainName, asset);
+
+ // Add the transformed asset to the resultant array
+ transformedAssets.push(transformedAsset);
+ }
+
+ // Write the transformed data to the target file
+ zone.writeToFile(chainName, mintscanDir, mintscanAssetsFileName, transformedAssets);
+ console.log(`Conversion completed. Data saved.`);
+};
+
+// Convert JSON
+async function main() {
+ await saveCosmoStationChainNames();
+ let chainName = "osmosis";
+ generateMintscanAssets(chainName);
+}
+
+main();