@snowbridge/registry 0.2.20 → 0.3.0-pre

package/src/environment.ts

@@ -0,0 +1,123 @@
+import { Environment } from "@snowbridge/base-types"
+
+export function environmentFor(
+    env: "polkadot_mainnet" | "westend_sepolia" | "paseo_sepolia" | (string & {}),
+): Environment {
+    if (!(env in SNOWBRIDGE_ENV)) throw Error(`Unknown env '${env}'`)
+    return SNOWBRIDGE_ENV[env]
+}
+
+const SNOWBRIDGE_ENV: { [env: string]: Environment } = {
+    local_e2e: {
+        name: "local_e2e",
+        ethChainId: 11155111,
+        beaconApiUrl: "http://127.0.0.1:9596",
+        ethereumChains: {
+            "11155111": "ws://127.0.0.1:8546",
+        },
+        relaychainUrl: "ws://127.0.0.1:9944",
+        parachains: {
+            "1000": "ws://127.0.0.1:12144",
+            "1002": "ws://127.0.0.1:11144",
+            "2000": "ws://127.0.0.1:13144",
+        },
+        gatewayContract: "0xb1185ede04202fe62d38f5db72f71e38ff3e8305",
+        beefyContract: "0x83428c7db9815f482a39a1715684dcf755021997",
+        assetHubParaId: 1000,
+        bridgeHubParaId: 1002,
+        indexerGraphQlUrl: "http://127.0.0.1/does/not/exist",
+    },
+    paseo_sepolia: {
+        name: "paseo_sepolia",
+        ethChainId: 11155111,
+        beaconApiUrl: "https://lodestar-sepolia.chainsafe.io",
+        ethereumChains: {
+            "11155111": "https://ethereum-sepolia-rpc.publicnode.com",
+        },
+        relaychainUrl: "wss://paseo-rpc.dwellir.com",
+        parachains: {
+            "1000": "wss://asset-hub-paseo-rpc.dwellir.com",
+            "1002": "wss://bridge-hub-paseo.dotters.network",
+            "3369": "wss://paseo-muse-rpc.polkadot.io",
+            "2043": `wss://parachain-testnet-rpc.origin-trail.network`,
+        },
+        gatewayContract: "0x1607C1368bc943130258318c91bBd8cFf3D063E6",
+        beefyContract: "0x2c780945beb1241fE9c645800110cb9C4bBbb639",
+        assetHubParaId: 1000,
+        bridgeHubParaId: 1002,
+        indexerGraphQlUrl:
+            "https://snowbridge.squids.live/snowbridge-subsquid-paseo@v1/api/graphql",
+        metadataOverrides: {
+            // Change the name of TRAC
+            "0xef32abea56beff54f61da319a7311098d6fbcea9": {
+                name: "OriginTrail TRAC",
+                symbol: "TRAC",
+            },
+        },
+    },
+    polkadot_mainnet: {
+        name: "polkadot_mainnet",
+        ethChainId: 1,
+        beaconApiUrl: "https://lodestar-mainnet.chainsafe.io",
+        ethereumChains: {
+            "1": "https://ethereum-rpc.publicnode.com",
+            "1284": "https://rpc.api.moonbeam.network",
+        },
+        relaychainUrl: "https://polkadot-rpc.n.dwellir.com",
+        parachains: {
+            "1000": "wss://asset-hub-polkadot-rpc.n.dwellir.com",
+            "1002": "https://bridge-hub-polkadot-rpc.n.dwellir.com",
+            "3369": "wss://polkadot-mythos-rpc.polkadot.io",
+            "2034": "wss://hydration-rpc.n.dwellir.com",
+            "2030": "wss://bifrost-polkadot.ibp.network",
+            "2004": "wss://moonbeam.ibp.network",
+            "2000": "wss://acala-rpc-0.aca-api.network",
+            "2043": "wss://parachain-rpc.origin-trail.network",
+            // TODO: Add back in jampton once we have an indexer in place.
+            //"3397": "wss://rpc.jamton.network",
+        },
+        gatewayContract: "0x27ca963c279c93801941e1eb8799c23f407d68e7",
+        beefyContract: "0x1817874feAb3ce053d0F40AbC23870DB35C2AFfc",
+        assetHubParaId: 1000,
+        bridgeHubParaId: 1002,
+        indexerGraphQlUrl:
+            "https://snowbridge.squids.live/snowbridge-subsquid-polkadot:production/api/graphql",
+        kusama: {
+            assetHubParaId: 1000,
+            bridgeHubParaId: 1002,
+            parachains: {
+                "1000": "wss://asset-hub-kusama-rpc.n.dwellir.com",
+                "1002": "https://bridge-hub-kusama-rpc.n.dwellir.com",
+            },
+        },
+        precompiles: {
+            // Add override for mythos token and add precompile for moonbeam
+            "2004": "0x000000000000000000000000000000000000081a",
+        },
+        metadataOverrides: {
+            // Change the name of TRAC
+            "0xaa7a9ca87d3694b5755f213b5d04094b8d0f0a6f": {
+                name: "OriginTrail TRAC",
+            },
+        },
+    },
+    westend_sepolia: {
+        name: "westend_sepolia",
+        ethChainId: 11155111,
+        beaconApiUrl: "https://lodestar-sepolia.chainsafe.io",
+        ethereumChains: {
+            "11155111": "https://ethereum-sepolia-rpc.publicnode.com",
+        },
+        relaychainUrl: "wss://westend-rpc.n.dwellir.com",
+        parachains: {
+            "1000": "wss://asset-hub-westend-rpc.n.dwellir.com",
+            "1002": "wss://bridge-hub-westend-rpc.n.dwellir.com",
+        },
+        gatewayContract: "0x9ed8b47bc3417e3bd0507adc06e56e2fa360a4e9",
+        beefyContract: "0x6DFaD3D73A28c48E4F4c616ECda80885b415283a",
+        assetHubParaId: 1000,
+        bridgeHubParaId: 1002,
+        indexerGraphQlUrl:
+            "https://snowbridge.squids.live/snowbridge-subsquid-westend@v1/api/graphql",
+    },
+}

package/src/index.ts

@@ -1,63 +1,3 @@
-import { AssetRegistry } from "@snowbridge/base-types"
-import polkadot_mainnet from "./polkadot_mainnet.registry.json"
-import westend_sepolia from "./westend_sepolia.registry.json"
-import paseo_sepolia from "./paseo_sepolia.registry.json"
-import local_e2e from "./local_e2e.registry.json"
-
-function transformBigInt(obj: any): any {
-    // Regex to match strings like "bigint:123"
-    const bigintPattern = /^bigint:(\d+)$/
-
-    // Handle null or non-object/non-array values
-    if (obj === null || typeof obj !== "object") {
-        if (typeof obj === "string") {
-            const match = obj.match(bigintPattern)
-            if (match) {
-                return Object.freeze(BigInt(match[1]))
-            }
-        }
-        return Object.freeze(obj)
-    }
-
-    // Handle arrays
-    if (Array.isArray(obj)) {
-        return Object.freeze(obj.map((item) => transformBigInt(item)))
-    }
-
-    // Handle objects
-    const result: { [key: string]: any } = {}
-    for (const key in obj) {
-        if (Object.prototype.hasOwnProperty.call(obj, key)) {
-            result[key] = transformBigInt(obj[key])
-        }
-    }
-    return Object.freeze(result)
-}
-
-const cache: { [env: string]: AssetRegistry } = {}
-export function assetRegistryFor(
-    env: "polkadot_mainnet" | "westend_sepolia" | "paseo_sepolia" | (string & {}),
-): AssetRegistry {
-    if (env in cache) {
-        return cache[env]
-    }
-    let json
-    switch (env) {
-        case "polkadot_mainnet":
-            json = polkadot_mainnet
-            break
-        case "westend_sepolia":
-            json = westend_sepolia
-            break
-        case "paseo_sepolia":
-            json = paseo_sepolia
-            break
-        case "local_e2e":
-            json = local_e2e
-            break
-        default:
-            throw Error(`Unknown env '${env}'`)
-    }
-    cache[env] = transformBigInt(json)
-    return cache[env]
-}
+export * from "./environment"
+export * from "./registry"
+export * from "./transfers"

package/src/polkadot_mainnet.registry.json

@@ -1,5 +1,5 @@
 {
-  "timestamp": "2025-11-24T11:57:28.867Z",
+  "timestamp": "2025-12-19T00:24:34.223Z",
   "environment": "polkadot_mainnet",
   "ethChainId": 1,
   "gatewayAddress": "0x27ca963c279c93801941e1eb8799c23f407d68e7",
@@ -23,7 +23,7 @@
     "accountType": "AccountId32",
     "name": "Polkadot BridgeHub",
     "specName": "bridge-hub-polkadot",
-    "specVersion": 2000000
+    "specVersion": 2000003
   },
   "ethereumChains": {
     "1": {
@@ -387,7 +387,7 @@
         "accountType": "AccountId32",
         "name": "Polkadot Asset Hub",
         "specName": "statemint",
-        "specVersion": 2000002
+        "specVersion": 2000003
       },
       "assets": {
         "0x9d39a5de30e57443bff2a8307a4256c8797a3497": {
@@ -1001,7 +1001,7 @@
         "accountType": "AccountId32",
         "name": "Acala",
         "specName": "acala",
-        "specVersion": 2320
+        "specVersion": 2330
       },
       "assets": {
         "0x0000000000000000000000000000000000000000": {
@@ -1038,7 +1038,7 @@
         "evmChainId": 1284,
         "name": "Moonbeam",
         "specName": "moonbeam",
-        "specVersion": 3901
+        "specVersion": 4001
       },
       "xcDOT": "0xffffffff1fcacbd218edc0eba20fc2308c778080",
       "assets": {
@@ -1106,7 +1106,7 @@
           "xc20": "0xffffffff7bc304425217b49e9598415c514ae81b"
         }
       },
-      "estimatedExecutionFeeDOT": "bigint:104787198",
+      "estimatedExecutionFeeDOT": "bigint:105696134",
       "estimatedDeliveryFeeDOT": "bigint:306500000"
     },
     "2030": {
@@ -1151,7 +1151,7 @@
           "isSufficient": false
         }
       },
-      "estimatedExecutionFeeDOT": "bigint:91177752",
+      "estimatedExecutionFeeDOT": "bigint:125952027",
       "estimatedDeliveryFeeDOT": "bigint:307100000"
     },
     "2034": {
@@ -1332,7 +1332,7 @@
           "isSufficient": true
         }
       },
-      "estimatedExecutionFeeDOT": "bigint:1740820",
+      "estimatedExecutionFeeDOT": "bigint:1934280",
       "estimatedDeliveryFeeDOT": "bigint:307100000"
     },
     "2043": {
@@ -1356,7 +1356,7 @@
         "accountType": "AccountId32",
         "name": "NeuroWeb",
         "specName": "origintrail-parachain",
-        "specVersion": 149
+        "specVersion": 151
       },
       "assets": {
         "0xaa7a9ca87d3694b5755f213b5d04094b8d0f0a6f": {
@@ -1431,7 +1431,7 @@
           "accountType": "AccountId32",
           "name": "Kusama Asset Hub",
           "specName": "statemine",
-          "specVersion": 2000002
+          "specVersion": 2000003
         },
         "assets": {
           "0x9d39a5de30e57443bff2a8307a4256c8797a3497": {

package/src/registry.ts

@@ -0,0 +1,63 @@
+import { AssetRegistry } from "@snowbridge/base-types"
+import polkadot_mainnet from "./polkadot_mainnet.registry.json"
+import westend_sepolia from "./westend_sepolia.registry.json"
+import paseo_sepolia from "./paseo_sepolia.registry.json"
+import local_e2e from "./local_e2e.registry.json"
+
+function transformBigInt(obj: any): any {
+    // Regex to match strings like "bigint:123"
+    const bigintPattern = /^bigint:(\d+)$/
+
+    // Handle null or non-object/non-array values
+    if (obj === null || typeof obj !== "object") {
+        if (typeof obj === "string") {
+            const match = obj.match(bigintPattern)
+            if (match) {
+                return Object.freeze(BigInt(match[1]))
+            }
+        }
+        return Object.freeze(obj)
+    }
+
+    // Handle arrays
+    if (Array.isArray(obj)) {
+        return Object.freeze(obj.map((item) => transformBigInt(item)))
+    }
+
+    // Handle objects
+    const result: { [key: string]: any } = {}
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            result[key] = transformBigInt(obj[key])
+        }
+    }
+    return Object.freeze(result)
+}
+
+const cache: { [env: string]: AssetRegistry } = {}
+export function assetRegistryFor(
+    env: "polkadot_mainnet" | "westend_sepolia" | "paseo_sepolia" | (string & {}),
+): AssetRegistry {
+    if (env in cache) {
+        return cache[env]
+    }
+    let json
+    switch (env) {
+        case "polkadot_mainnet":
+            json = polkadot_mainnet
+            break
+        case "westend_sepolia":
+            json = westend_sepolia
+            break
+        case "paseo_sepolia":
+            json = paseo_sepolia
+            break
+        case "local_e2e":
+            json = local_e2e
+            break
+        default:
+            throw Error(`Unknown env '${env}'`)
+    }
+    cache[env] = transformBigInt(json)
+    return cache[env]
+}

package/src/transfers.ts

@@ -0,0 +1,290 @@
+import {
+    AssetRegistry,
+    Environment,
+    EthereumChain,
+    Parachain,
+    Path,
+    Source,
+    SourceType,
+    TransferLocation,
+} from "@snowbridge/base-types"
+import { environmentFor } from "./environment"
+import { assetRegistryFor } from "./registry"
+
+const cache: { [env: string]: Source[] } = {}
+export function transferSourcesFor(
+    env: "polkadot_mainnet" | "westend_sepolia" | "paseo_sepolia" | (string & {}),
+): Source[] {
+    if (env in cache) {
+        return cache[env]
+    }
+    return getTransferLocations(assetRegistryFor(env))
+}
+
+export function getEthereumTransferLocation(
+    registry: AssetRegistry,
+    ethChain: EthereumChain,
+): TransferLocation {
+    if (!ethChain.evmParachainId) {
+        return {
+            id: "ethereum",
+            name: "Ethereum",
+            type: "ethereum",
+            key: ethChain.chainId.toString(),
+            ethChain,
+        }
+    } else {
+        const evmChain = registry.parachains[ethChain.evmParachainId]
+        return {
+            id: ethChain.id,
+            name: `${evmChain.info.name} (EVM)`,
+            key: ethChain.chainId.toString(),
+            type: "ethereum",
+            ethChain,
+            parachain: evmChain,
+        }
+    }
+}
+
+export function getSubstrateTransferLocation(parachain: Parachain): TransferLocation {
+    return {
+        id: parachain.info.specName,
+        name: parachain.info.name,
+        key: parachain.parachainId.toString(),
+        type: "substrate",
+        parachain,
+    }
+}
+
+export function getTransferLocation(
+    registry: AssetRegistry,
+    sourceType: string,
+    sourceKey: string,
+): TransferLocation {
+    if (sourceType === "ethereum") {
+        return getEthereumTransferLocation(registry, registry.ethereumChains[sourceKey])
+    } else {
+        return getSubstrateTransferLocation(registry.parachains[sourceKey])
+    }
+}
+
+export function getTransferLocationKusama(
+    registry: AssetRegistry,
+    network: string,
+    parachainId: string,
+): TransferLocation {
+    if (network === "kusama" && registry.kusama) {
+        return getSubstrateTransferLocation(registry.kusama?.parachains[parachainId])
+    } else {
+        return getSubstrateTransferLocation(registry.parachains[parachainId])
+    }
+}
+
+export function getTransferLocations(
+    registry: AssetRegistry,
+    filter?: (path: Path) => boolean,
+): Source[] {
+    const ethChain = registry.ethereumChains[registry.ethChainId]
+    const parachains = Object.keys(registry.parachains)
+        .filter((p) => p !== registry.bridgeHubParaId.toString())
+        .map((p) => registry.parachains[p])
+
+    const pathFilter = filter ?? defaultPathFilter(registry.environment)
+
+    const locations: Path[] = []
+
+    const ethAssets = Object.keys(ethChain.assets)
+    // Bridged paths
+    for (const parachain of parachains) {
+        const destinationAssets = Object.keys(parachain.assets)
+        const commonAssets = new Set(
+            ethAssets.filter((sa) => destinationAssets.find((da) => da === sa)),
+        )
+        for (const asset of commonAssets) {
+            const p1: Path = {
+                type: "ethereum",
+                id: "ethereum",
+                source: ethChain.chainId,
+                destinationType: "substrate",
+                destination: parachain.parachainId,
+                asset,
+            }
+            if (pathFilter(p1)) {
+                locations.push(p1)
+            }
+            const p2: Path = {
+                type: "substrate",
+                id: parachain.info.specName,
+                source: parachain.parachainId,
+                destinationType: "ethereum",
+                destination: ethChain.chainId,
+                asset,
+            }
+            if (pathFilter(p2)) {
+                locations.push(p2)
+            }
+            if (parachain.info.evmChainId && registry.ethereumChains[parachain.info.evmChainId]) {
+                const p3: Path = {
+                    type: "ethereum",
+                    id: `${parachain.info.specName}_evm`,
+                    source: parachain.info.evmChainId,
+                    destinationType: "ethereum",
+                    destination: ethChain.chainId,
+                    asset,
+                }
+                if (pathFilter(p3)) {
+                    locations.push(p3)
+                }
+            }
+        }
+    }
+
+    // Local paths
+    const assetHub = registry.parachains[registry.assetHubParaId]
+    for (const parachain of parachains) {
+        if (parachain.parachainId === assetHub.parachainId) continue
+        const assetHubAssets = Object.keys(assetHub.assets)
+        const destinationAssets = Object.keys(parachain.assets)
+
+        // The asset exists on ethereum, parachain and asset hub
+        const commonAssets = new Set(
+            ethAssets.filter(
+                (sa) =>
+                    assetHubAssets.find((da) => da === sa) &&
+                    destinationAssets.find((da) => da === sa),
+            ),
+        )
+        for (const asset of commonAssets) {
+            const p1: Path = {
+                type: "substrate",
+                id: assetHub.info.specName,
+                source: assetHub.parachainId,
+                destinationType: "substrate",
+                destination: parachain.parachainId,
+                asset,
+            }
+            if (pathFilter(p1)) {
+                locations.push(p1)
+            }
+            const p2: Path = {
+                type: "substrate",
+                id: parachain.info.specName,
+                source: parachain.parachainId,
+                destinationType: "substrate",
+                destination: assetHub.parachainId,
+                asset,
+            }
+            if (pathFilter(p2)) {
+                locations.push(p2)
+            }
+        }
+    }
+
+    const results: Source[] = []
+    for (const location of locations) {
+        let source = results.find(
+            (s) =>
+                s.type === location.type &&
+                s.id === location.id &&
+                s.key === location.source.toString(),
+        )
+        if (!source) {
+            source = {
+                type: location.type,
+                id: location.id,
+                key: location.source.toString(),
+                destinations: {},
+            }
+            results.push(source)
+        }
+        let destination: { type: SourceType; assets: string[] } =
+            source.destinations[location.destination]
+        if (!destination) {
+            destination = { type: location.destinationType, assets: [] }
+            source.destinations[location.destination] = destination
+        }
+        destination.assets.push(location.asset)
+    }
+    return results
+}
+
+export function defaultPathFilter(envName: string): (_: Path) => boolean {
+    switch (envName) {
+        case "westend_sepolia": {
+            return (path: Path) => {
+                // Frequency
+                if (path.asset === "0x72c610e05eaafcdf1fa7a2da15374ee90edb1620") {
+                    return false
+                }
+                // Disable para to para transfers
+                if (path.type === "substrate" && path.destinationType === "substrate") {
+                    return false
+                }
+                return true
+            }
+        }
+        case "paseo_sepolia":
+            return (path: Path) => {
+                // Disallow MUSE to any location but 3369
+                if (
+                    path.asset === "0xb34a6924a02100ba6ef12af1c798285e8f7a16ee" &&
+                    ((path.destination !== 3369 && path.type === "ethereum") ||
+                        (path.source !== 3369 && path.type === "substrate"))
+                ) {
+                    return false
+                }
+                // Disable para to para transfers
+                if (path.type === "substrate" && path.destinationType === "substrate") {
+                    return false
+                }
+                return true
+            }
+        case "polkadot_mainnet":
+            return (path: Path) => {
+                // Disallow MYTH to any location but 3369
+                if (
+                    path.asset === "0xba41ddf06b7ffd89d1267b5a93bfef2424eb2003" &&
+                    ((path.destination !== 3369 && path.type === "ethereum") ||
+                        (path.source !== 3369 && path.type === "substrate"))
+                ) {
+                    return false
+                }
+
+                // Allow TRAC to go to Hydration (2034) and Neuroweb (2043) only
+                if (
+                    path.asset === "0xaa7a9ca87d3694b5755f213b5d04094b8d0f0a6f" &&
+                    ((path.destination !== 2034 &&
+                        path.destination !== 2043 &&
+                        path.type === "ethereum") ||
+                        (path.source !== 2034 && path.source !== 2043 && path.type === "substrate"))
+                ) {
+                    return false
+                }
+
+                // Disable stable coins in the UI from Ethereum to Polkadot
+                if (
+                    (path.asset === "0x9d39a5de30e57443bff2a8307a4256c8797a3497" || // Staked USDe
+                        path.asset === "0xa3931d71877c0e7a3148cb7eb4463524fec27fbd" || // Savings USD
+                        path.asset === "0x6b175474e89094c44da98b954eedeac495271d0f") && // DAI
+                    path.destination === 2034 // Hydration
+                ) {
+                    return false
+                }
+                // Disable para to para transfers except for hydration
+                if (
+                    path.type === "substrate" &&
+                    path.destinationType === "substrate" &&
+                    !(
+                        (path.source === 2034 && path.destination == 1000) ||
+                        (path.source === 1000 && path.destination === 2034)
+                    )
+                ) {
+                    return false
+                }
+                return true
+            }
+
+        default:
+            return (_: Path) => true
+    }
+}

package/tsconfig.json

@@ -20,7 +20,7 @@
   "ts-node": {
     "require": ["tsconfig-paths/register"]
   },
-  "exclude": ["node_modules", "dist"],
   "include": ["src/**/*.ts", "src/**/*.json"],
+  "exclude": ["node_modules", "dist", "scripts"],
   "references": []
 }

package/tsconfig.scripts.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "noEmit": true,
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "ES2022",
+    "moduleResolution": "node",
+    "composite": true,
+    "module": "commonjs",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "noEmitOnError": true,
+    "skipLibCheck": true,
+    "allowJs": true,
+  },
+  "exclude": [
+    "node_modules",
+    "dist",
+  ],
+}

package/build.ts

@@ -1,28 +0,0 @@
-import { assetsV2, environment } from "@snowbridge/api"
-import { writeFile } from "fs/promises"
-
-async function buildRegistry(env: string, options: assetsV2.RegistryOptions) {
-    const registry = await assetsV2.buildRegistry(options)
-    const json = JSON.stringify(
-        registry,
-        (key, value) => {
-            if (typeof value === "bigint") {
-                return `bigint:${value.toString()}`
-            }
-            return value
-        },
-        2
-    )
-
-    const filepath = `src/${env}.registry.json`
-    await writeFile(filepath, json)
-}
-
-;(async () => {
-    let env = "local_e2e"
-    if (process.env.NODE_ENV !== undefined) {
-        env = process.env.NODE_ENV
-    }
-    const options = assetsV2.fromEnvironment(environment.SNOWBRIDGE_ENV[env])
-    await buildRegistry(env, options)
-})()