Fix moonbeam asset registry (#1482)

* fix moonbeam asset registry

* revert fmt changes

* up versions

* fix get token balance

* fix metadata for moonbeam assets

* moonbeam assets are sufficient

* soft block MYTH to ETH

---------

Co-authored-by: Alistair Singh <[email protected]>

Author: claravanstaden

web/packages/api/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowbridge/api",
-  "version": "0.1.54",
+  "version": "0.1.55",
   "description": "Snowbridge API client",
   "license": "Apache-2.0",
   "repository": {

web/packages/api/src/assets_v2.ts

@@ -9,7 +9,11 @@ import {
     erc20Location,
 } from "./xcmBuilder"
 import { IGatewayV1__factory as IGateway__factory } from "@snowbridge/contract-types"
-import { convertToXcmV3X1, getMoonbeamLocationBalance, toMoonbeamXC20 } from "./parachains/moonbeam"
+import {
+    convertToXcmV3X1, getMoonbeamEvmAssetMetadata,
+    getMoonbeamLocationBalance,
+    toMoonbeamXC20
+} from "./parachains/moonbeam"
 import { MUSE_TOKEN_ID, MYTHOS_TOKEN_ID, getMythosLocationBalance } from "./parachains/mythos"
 
 export type ERC20Metadata = {
@@ -879,41 +883,16 @@ async function indexParachainAssets(provider: ApiPromise, ethChainId: number, sp
         }
         case "moonriver":
         case "moonbeam": {
-            const entries = await provider.query.assetManager.assetIdType.entries()
-            for (const [key, value] of entries) {
-                const location = (value.toJSON() as any).xcm
-
-                const assetId = BigInt(key.args.at(0)?.toPrimitive() as any)
-                const xc20 = toMoonbeamXC20(assetId)
-
-                if (location.parents === 1 && location.interior.here !== undefined) {
-                    xcDOT = xc20
-                }
-                const token = getTokenFromLocation(location, ethChainId)
-                if (!token) {
-                    continue
-                }
-
-                const asset: any = (await provider.query.assets.asset(assetId)).toPrimitive()
-                const metadata: any = (await provider.query.assets.metadata(assetId)).toPrimitive()
-
-                assets[token] = {
-                    token,
-                    name: String(metadata.name),
-                    minimumBalance: BigInt(asset.minBalance),
-                    symbol: String(metadata.symbol),
-                    decimals: Number(metadata.decimals),
-                    isSufficient: Boolean(asset.isSufficient),
-                    xc20,
-                }
-            }
             const foreignEntries = await provider.query.evmForeignAssets.assetsById.entries()
             for (const [key, value] of foreignEntries) {
                 const location = value.toJSON() as any
 
                 const assetId = BigInt(key.args.at(0)?.toPrimitive() as any)
                 const xc20 = toMoonbeamXC20(assetId)
 
+                if (location.parents === 1 && location.interior.here !== undefined) {
+                    xcDOT = xc20
+                }
                 const token = getTokenFromLocation(location, ethChainId)
                 if (!token) {
                     continue
@@ -923,16 +902,17 @@ async function indexParachainAssets(provider: ApiPromise, ethChainId: number, sp
                     continue
                 }
 
-                const asset: any = (await provider.query.assets.asset(assetId)).toPrimitive()
-                const metadata: any = (await provider.query.assets.metadata(assetId)).toPrimitive()
+                const symbol = await getMoonbeamEvmAssetMetadata(provider, "symbol", xc20)
+                const name = await getMoonbeamEvmAssetMetadata(provider, "name", xc20)
+                const decimals = await getMoonbeamEvmAssetMetadata(provider, "decimals", xc20)
 
                 assets[token] = {
                     token,
-                    name: String(metadata.name),
-                    minimumBalance: BigInt(asset?.minBalance ?? 1),
-                    symbol: String(metadata.symbol),
-                    decimals: Number(metadata.decimals),
-                    isSufficient: Boolean(asset?.isSufficient ?? false),
+                    name: String(name),
+                    minimumBalance: 1n,
+                    symbol: String(symbol),
+                    decimals: Number(decimals),
+                    isSufficient: true,
                     xc20,
                 }
             }
@@ -1121,7 +1101,7 @@ async function indexEthChain(
             )
         }
         if (!evmParachainChain.xcDOT) {
-            throw Error(`Could not DOT XC20 address for evm chain ${networkChainId}.`)
+            throw Error(`Could not find DOT XC20 address for evm chain ${networkChainId}.`)
         }
         const xc20DOTAsset: ERC20Metadata = await assetErc20Metadata(
             provider,
@@ -1380,7 +1360,7 @@ function defaultPathFilter(envName: string): (_: Path) => boolean {
                 if (
                     path.asset === MUSE_TOKEN_ID &&
                     (
-                        (path.destination !== 3369 && path.type === "ethereum") || 
+                        (path.destination !== 3369 && path.type === "ethereum") ||
                         (path.source !== 3369 && path.type === "substrate")
                     )
                 ) {
@@ -1398,8 +1378,8 @@ function defaultPathFilter(envName: string): (_: Path) => boolean {
                 if (
                     path.asset === MYTHOS_TOKEN_ID &&
                     (
-                        (path.destination !== 3369 && path.type === "ethereum") || 
-                        (path.source !== 3369 && path.type === "substrate")
+                        // TODO: Disable Mythos to Eth until mythos is ready to enable
+                        (path.destination !== 3369)
                     )
                 ) {
                     return false
@@ -1595,5 +1575,5 @@ export async function getAssetHubConversationPalletSwap(assetHub: ApiPromise, as
     if (asset1Balance == null) {
         throw Error(`No pool set up in asset conversion pallet for '${JSON.stringify(asset1)}' and '${JSON.stringify(asset2)}'.`)
     }
-    return BigInt(asset1Balance) 
+    return BigInt(asset1Balance)
 }

web/packages/api/src/parachains/moonbeam.ts

@@ -32,33 +32,20 @@ export async function getMoonbeamLocationBalance(
 ) {
     // For PNA, use assetId directly; for ENA, query assetId by Multilocation
     let paraAssetId = pnaAssetId
-    if (!paraAssetId) {
-        // Moonbeam only supports v3 xcm locations on asset Manager. Deep clone the location because
-        // we might modify it.
-        const assetManagerLocation = convertToXcmV3X1(location)
-        paraAssetId = (
-            await provider.query.assetManager.assetTypeId({ xcm: assetManagerLocation })
-        ).toPrimitive()
-    }
-
     // If we cannot find the asset in asset manager look in foreign assets.
     if (!paraAssetId) {
         // evmForeignAssets uses xcm v4 so we use the original location.
         paraAssetId = (
             (await provider.query.evmForeignAssets.assetsByLocation(location)).toPrimitive() as any
         )[0]
-        const xc20 = toMoonbeamXC20(BigInt(paraAssetId))
-        return await getMoonbeamEvmForeignAssetBalance(provider, xc20, account)
     }
 
     if (!paraAssetId) {
         throw Error(`Asset not registered for spec ${specName}.`)
     }
 
-    const accountData = (
-        await provider.query.assets.account(paraAssetId, account)
-    ).toPrimitive() as any
-    return BigInt(accountData?.balance ?? 0n)
+    const xc20 = toMoonbeamXC20(BigInt(paraAssetId))
+    return await getMoonbeamEvmForeignAssetBalance(provider, xc20, account)
 }
 
 async function getMoonbeamEvmForeignAssetBalance(api: ApiPromise, token: string, account: string) {
@@ -86,3 +73,28 @@ async function getMoonbeamEvmForeignAssetBalance(api: ApiPromise, token: string,
     const retVal = MOONBEAM_ERC20.decodeFunctionResult(method, resultJson?.ok?.value)
     return BigInt(retVal[0])
 }
+
+export async function getMoonbeamEvmAssetMetadata(api: ApiPromise, method: string, token: string) {
+    const data = MOONBEAM_ERC20.encodeFunctionData(method, [])
+    const result = await api.call.ethereumRuntimeRPCApi.call(
+        "0x0000000000000000000000000000000000000000",
+        token,
+        data,
+        0n,
+        500_000n,
+        null,
+        null,
+        null,
+        false,
+        null
+    )
+    const resultJson = result.toPrimitive() as any
+    if (!(resultJson?.ok?.exitReason?.succeed === "Returned")) {
+        console.error(resultJson)
+        throw Error(
+            `Could not fetch metadata for ${token}: ${JSON.stringify(resultJson?.ok?.exitReason)}`
+        )
+    }
+    const retVal = MOONBEAM_ERC20.decodeFunctionResult(method, resultJson?.ok?.value)
+    return retVal[0]
+}

web/packages/contract-types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowbridge/contract-types",
-  "version": "0.1.54",
+  "version": "0.1.55",
   "description": "Snowbridge contract type bindings",
   "license": "Apache-2.0",
   "repository": {

web/packages/contracts/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowbridge/contracts",
-  "version": "0.1.54",
+  "version": "0.1.55",
   "description": "Snowbridge contract source and abi.",
   "license": "Apache-2.0",
   "repository": {