@snowbridge/registry 0.3.3 → 0.4.0

package/dist/transfers.d.ts

@@ -1,9 +1,4 @@
-import { AssetRegistry, EthereumChain, Parachain, Path, Source, TransferLocation } from "@snowbridge/base-types";
-export declare function transferSourcesFor(env: "polkadot_mainnet" | "westend_sepolia" | "paseo_sepolia" | (string & {})): Source[];
-export declare function getEthereumTransferLocation(registry: AssetRegistry, ethChain: EthereumChain): TransferLocation;
-export declare function getSubstrateTransferLocation(parachain: Parachain): TransferLocation;
-export declare function getTransferLocation(registry: AssetRegistry, sourceType: string, sourceKey: string): TransferLocation;
-export declare function getTransferLocationKusama(registry: AssetRegistry, network: string, parachainId: string): TransferLocation;
-export declare function getTransferLocations(registry: AssetRegistry, filter?: (path: Path) => boolean): Source[];
-export declare function defaultPathFilter(envName: string): (_: Path) => boolean;
+import { AssetRegistry, TransferLocation, Source, ChainId, TransferRoute } from "@snowbridge/base-types";
+export declare function getTransferLocation(registry: AssetRegistry, chain: ChainId): TransferLocation;
+export declare function getTransferLocations(routes: readonly TransferRoute[]): Source[];
 //# sourceMappingURL=transfers.d.ts.map

package/dist/transfers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transfers.d.ts","sourceRoot":"","sources":["../src/transfers.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,aAAa,EAEb,aAAa,EACb,SAAS,EACT,IAAI,EACJ,MAAM,EAEN,gBAAgB,EACnB,MAAM,wBAAwB,CAAA;AAK/B,wBAAgB,kBAAkB,CAC9B,GAAG,EAAE,kBAAkB,GAAG,iBAAiB,GAAG,eAAe,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,GAC9E,MAAM,EAAE,CAKV;AAED,wBAAgB,2BAA2B,CACvC,QAAQ,EAAE,aAAa,EACvB,QAAQ,EAAE,aAAa,GACxB,gBAAgB,CAoBlB;AAED,wBAAgB,4BAA4B,CAAC,SAAS,EAAE,SAAS,GAAG,gBAAgB,CAQnF;AAED,wBAAgB,mBAAmB,CAC/B,QAAQ,EAAE,aAAa,EACvB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,GAClB,gBAAgB,CAMlB;AAED,wBAAgB,yBAAyB,CACrC,QAAQ,EAAE,aAAa,EACvB,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,GACpB,gBAAgB,CAMlB;AAED,wBAAgB,oBAAoB,CAChC,QAAQ,EAAE,aAAa,EACvB,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,GACjC,MAAM,EAAE,CA2HV;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,CAAC,CAAC,EAAE,IAAI,KAAK,OAAO,CA+EvE"}
+{"version":3,"file":"transfers.d.ts","sourceRoot":"","sources":["../src/transfers.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,aAAa,EACb,gBAAgB,EAChB,MAAM,EAGN,OAAO,EACP,aAAa,EAChB,MAAM,wBAAwB,CAAA;AAE/B,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,aAAa,EAAE,KAAK,EAAE,OAAO,GAAG,gBAAgB,CA8C7F;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,aAAa,EAAE,GAAG,MAAM,EAAE,CAuB/E"}

package/dist/transfers.js

@@ -1,238 +1,77 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transferSourcesFor = transferSourcesFor;
-exports.getEthereumTransferLocation = getEthereumTransferLocation;
-exports.getSubstrateTransferLocation = getSubstrateTransferLocation;
 exports.getTransferLocation = getTransferLocation;
-exports.getTransferLocationKusama = getTransferLocationKusama;
 exports.getTransferLocations = getTransferLocations;
-exports.defaultPathFilter = defaultPathFilter;
-const registry_1 = require("./registry");
-const cache = {};
-function transferSourcesFor(env) {
-    if (env in cache) {
-        return cache[env];
-    }
-    return getTransferLocations((0, registry_1.assetRegistryFor)(env));
-}
-function getEthereumTransferLocation(registry, ethChain) {
-    if (!ethChain.evmParachainId) {
-        return {
-            id: "ethereum",
-            name: "Ethereum",
-            type: "ethereum",
-            key: ethChain.chainId.toString(),
-            ethChain,
+function getTransferLocation(registry, chain) {
+    let location = null;
+    if (chain.kind === "kusama" && registry.kusama) {
+        const parachain = registry.kusama.parachains[`${chain.kind}_${chain.id}`];
+        location = {
+            id: parachain.id,
+            kind: parachain.kind,
+            name: parachain.info.name,
+            key: parachain.key,
+            parachain,
         };
     }
-    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,
+    else if (chain.kind === "polkadot") {
+        const parachain = registry.parachains[`${chain.kind}_${chain.id}`];
+        location = {
+            id: parachain.id,
+            kind: parachain.kind,
+            name: parachain.info.name,
+            key: parachain.key,
+            parachain,
         };
     }
-}
-function getSubstrateTransferLocation(parachain) {
-    return {
-        id: parachain.info.specName,
-        name: parachain.info.name,
-        key: parachain.parachainId.toString(),
-        type: "substrate",
-        parachain,
-    };
-}
-function getTransferLocation(registry, sourceType, sourceKey) {
-    if (sourceType === "ethereum") {
-        return getEthereumTransferLocation(registry, registry.ethereumChains[sourceKey]);
-    }
-    else {
-        return getSubstrateTransferLocation(registry.parachains[sourceKey]);
-    }
-}
-function getTransferLocationKusama(registry, network, parachainId) {
-    if (network === "kusama" && registry.kusama) {
-        return getSubstrateTransferLocation(registry.kusama?.parachains[parachainId]);
-    }
-    else {
-        return getSubstrateTransferLocation(registry.parachains[parachainId]);
-    }
-}
-function getTransferLocations(registry, filter) {
-    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 = [];
-    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 = {
-                type: "ethereum",
-                id: "ethereum",
-                source: ethChain.chainId,
-                destinationType: "substrate",
-                destination: parachain.parachainId,
-                asset,
+    else if (chain.kind === "ethereum") {
+        const ethChain = registry.ethereumChains[`${chain.kind}_${chain.id}`];
+        if (!ethChain.evmParachainId) {
+            location = {
+                kind: ethChain.kind,
+                id: ethChain.id,
+                key: ethChain.key,
+                name: "Ethereum",
+                ethChain,
             };
-            if (pathFilter(p1)) {
-                locations.push(p1);
-            }
-            const p2 = {
-                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 = {
-                    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 = {
-                type: "substrate",
-                id: assetHub.info.specName,
-                source: assetHub.parachainId,
-                destinationType: "substrate",
-                destination: parachain.parachainId,
-                asset,
-            };
-            if (pathFilter(p1)) {
-                locations.push(p1);
-            }
-            const p2 = {
-                type: "substrate",
-                id: parachain.info.specName,
-                source: parachain.parachainId,
-                destinationType: "substrate",
-                destination: assetHub.parachainId,
-                asset,
+        else {
+            const evmChain = registry.parachains[`polkadot_${ethChain.evmParachainId}`];
+            location = {
+                kind: ethChain.kind,
+                id: ethChain.id,
+                key: ethChain.key,
+                name: `${evmChain.info.name} (EVM)`,
+                ethChain,
+                parachain: evmChain,
             };
-            if (pathFilter(p2)) {
-                locations.push(p2);
-            }
         }
     }
-    const results = [];
-    for (const location of locations) {
-        let source = results.find((s) => s.type === location.type &&
-            s.id === location.id &&
-            s.key === location.source.toString());
+    if (location === null)
+        throw Error(`Unknown ${chain.kind} chain ${chain.id}.`);
+    return location;
+}
+function getTransferLocations(routes) {
+    let sources = [];
+    for (const route of routes) {
+        let source = sources.find((s) => s.id === route.from.id && s.kind === route.from.kind);
         if (!source) {
             source = {
-                type: location.type,
-                id: location.id,
-                key: location.source.toString(),
+                key: `${route.from.kind}_${route.from.id}`,
+                ...route.from,
                 destinations: {},
             };
-            results.push(source);
+            sources.push(source);
         }
-        let destination = source.destinations[location.destination];
+        const destId = `${route.to.kind}_${route.to.id}`;
+        let destination = source.destinations[destId];
         if (!destination) {
-            destination = { type: location.destinationType, assets: [] };
-            source.destinations[location.destination] = destination;
-        }
-        destination.assets.push(location.asset);
-    }
-    return results;
-}
-function defaultPathFilter(envName) {
-    switch (envName) {
-        case "westend_sepolia": {
-            return (path) => {
-                // Frequency
-                if (path.asset === "0x72c610e05eaafcdf1fa7a2da15374ee90edb1620") {
-                    return false;
-                }
-                // Disable para to para transfers
-                if (path.type === "substrate" && path.destinationType === "substrate") {
-                    return false;
-                }
-                return true;
+            source.destinations[destId] = {
+                key: destId,
+                ...route.to,
+                assets: [...route.assets],
             };
         }
-        case "paseo_sepolia":
-            return (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) => {
-                // 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 (_) => true;
     }
+    return sources;
 }

package/dist/westend_sepolia_bridge_info.g.d.ts

@@ -0,0 +1,344 @@
+declare const registry: {
+    readonly environment: {
+        readonly name: "westend_sepolia";
+        readonly ethChainId: 11155111;
+        readonly beaconApiUrl: "https://lodestar-sepolia.chainsafe.io";
+        readonly ethereumChains: {
+            readonly "84532": "https://base-sepolia-rpc.publicnode.com";
+            readonly "11155111": "https://ethereum-sepolia-rpc.publicnode.com";
+        };
+        readonly relaychainUrl: "wss://westend-rpc.n.dwellir.com";
+        readonly parachains: {
+            readonly "1000": "wss://asset-hub-westend-rpc.n.dwellir.com";
+            readonly "1002": "wss://bridge-hub-westend-rpc.n.dwellir.com";
+        };
+        readonly gatewayContract: "0x9ed8b47bc3417e3bd0507adc06e56e2fa360a4e9";
+        readonly beefyContract: "0xA04460B1D8bBef33F54edB2C3115e3E4D41237A6";
+        readonly assetHubParaId: 1000;
+        readonly bridgeHubParaId: 1002;
+        readonly v2_parachains: readonly [1000];
+        readonly indexerGraphQlUrl: "https://snowbridge.squids.live/snowbridge-subsquid-westend@v1/api/graphql";
+        readonly l2Bridge: {
+            readonly acrossAPIUrl: "https://testnet.across.to/api";
+            readonly l1AdapterAddress: "0xA5B8589bD534701be49916c4d2e634aB1c765Cbf";
+            readonly l1HandlerAddress: "0x924a9f036260DdD5808007E1AA95f08eD08aA569";
+            readonly l1FeeTokenAddress: "0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14";
+            readonly l1SwapRouterAddress: "0x3bFA4769FB09eefC5a80d6E87c3B9C650f7Ae48E";
+            readonly l1SwapQuoterAddress: "0xEd1f6473345F45b75F8179591dd5bA1888cf2FB3";
+            readonly l2Chains: {
+                readonly "84532": {
+                    readonly adapterAddress: "0xf06939613A3838Af11104c898758220dB9093679";
+                    readonly feeTokenAddress: "0x4200000000000000000000000000000000000006";
+                    readonly swapRoutes: readonly [{
+                        readonly inputToken: "0x4200000000000000000000000000000000000006";
+                        readonly outputToken: "0xfff9976782d46cc05630d1f6ebab18b2324d6b14";
+                        readonly swapFee: 0;
+                    }, {
+                        readonly inputToken: "0x036cbd53842c5426634e7929541ec2318f3dcf7e";
+                        readonly outputToken: "0x1c7d4b196cb0c7b01d743fbc6116a902379c7238";
+                        readonly swapFee: 500;
+                    }];
+                };
+            };
+        };
+    };
+    readonly routes: readonly [{
+        readonly from: {
+            readonly kind: "ethereum";
+            readonly id: 11155111;
+        };
+        readonly to: {
+            readonly kind: "polkadot";
+            readonly id: 1000;
+        };
+        readonly assets: readonly ["0x0000000000000000000000000000000000000000", "0x1c7d4b196cb0c7b01d743fbc6116a902379c7238", "0xfff9976782d46cc05630d1f6ebab18b2324d6b14", "0x23838b1bb57cecf4422a57dd8e7f8a087b30d54f", "0xb8a0f2703ac6bdd352096c90c2945a097e8f4055", "0xf50fb50d65c8c1f6c72e4d8397c984933afc8f7e"];
+    }, {
+        readonly from: {
+            readonly kind: "polkadot";
+            readonly id: 1000;
+        };
+        readonly to: {
+            readonly kind: "ethereum";
+            readonly id: 11155111;
+        };
+        readonly assets: readonly ["0x0000000000000000000000000000000000000000", "0x1c7d4b196cb0c7b01d743fbc6116a902379c7238", "0xfff9976782d46cc05630d1f6ebab18b2324d6b14", "0x23838b1bb57cecf4422a57dd8e7f8a087b30d54f", "0xb8a0f2703ac6bdd352096c90c2945a097e8f4055", "0xf50fb50d65c8c1f6c72e4d8397c984933afc8f7e"];
+    }];
+    readonly registry: {
+        readonly timestamp: "2026-01-28T21:33:34.219Z";
+        readonly environment: "westend_sepolia";
+        readonly ethChainId: 11155111;
+        readonly gatewayAddress: "0x9ed8b47bc3417e3bd0507adc06e56e2fa360a4e9";
+        readonly assetHubParaId: 1000;
+        readonly bridgeHubParaId: 1002;
+        readonly relaychain: {
+            readonly tokenSymbols: "WND";
+            readonly tokenDecimals: 12;
+            readonly ss58Format: 42;
+            readonly isEthereum: false;
+            readonly accountType: "AccountId32";
+            readonly name: "Westend";
+            readonly specName: "westend";
+            readonly specVersion: 1021001;
+        };
+        readonly bridgeHub: {
+            readonly tokenSymbols: "WND";
+            readonly tokenDecimals: 12;
+            readonly ss58Format: 42;
+            readonly isEthereum: false;
+            readonly accountType: "AccountId32";
+            readonly name: "Westend BridgeHub";
+            readonly specName: "bridge-hub-westend";
+            readonly specVersion: 1021000;
+        };
+        readonly ethereumChains: {
+            readonly ethereum_l2_84532: {
+                readonly kind: "ethereum_l2";
+                readonly id: 84532;
+                readonly assets: {
+                    readonly "0x4200000000000000000000000000000000000006": {
+                        readonly token: "0x4200000000000000000000000000000000000006";
+                        readonly name: "Wrapped Ether";
+                        readonly symbol: "WETH";
+                        readonly decimals: 18;
+                        readonly swapTokenAddress: "0xfff9976782d46cc05630d1f6ebab18b2324d6b14";
+                        readonly swapFee: 0;
+                    };
+                    readonly "0x036cbd53842c5426634e7929541ec2318f3dcf7e": {
+                        readonly token: "0x036cbd53842c5426634e7929541ec2318f3dcf7e";
+                        readonly name: "USDC";
+                        readonly symbol: "USDC";
+                        readonly decimals: 6;
+                        readonly swapTokenAddress: "0x1c7d4b196cb0c7b01d743fbc6116a902379c7238";
+                        readonly swapFee: 500;
+                    };
+                    readonly "0x0000000000000000000000000000000000000000": {
+                        readonly token: "0x0000000000000000000000000000000000000000";
+                        readonly name: "Ether";
+                        readonly symbol: "Ether";
+                        readonly decimals: 18;
+                        readonly swapTokenAddress: "0x0000000000000000000000000000000000000000";
+                        readonly swapFee: 0;
+                    };
+                };
+                readonly key: "ethereum_l2_84532";
+            };
+            readonly ethereum_11155111: {
+                readonly kind: "ethereum";
+                readonly id: 11155111;
+                readonly assets: {
+                    readonly "0x0000000000000000000000000000000000000000": {
+                        readonly token: "0x0000000000000000000000000000000000000000";
+                        readonly name: "Ether";
+                        readonly symbol: "Ether";
+                        readonly decimals: 18;
+                    };
+                    readonly "0x1c7d4b196cb0c7b01d743fbc6116a902379c7238": {
+                        readonly token: "0x1c7d4b196cb0c7b01d743fbc6116a902379c7238";
+                        readonly name: "USDC";
+                        readonly symbol: "USDC";
+                        readonly decimals: 6;
+                        readonly deliveryGas: 80000n;
+                    };
+                    readonly "0x72c610e05eaafcdf1fa7a2da15374ee90edb1620": {
+                        readonly token: "0x72c610e05eaafcdf1fa7a2da15374ee90edb1620";
+                        readonly name: "Frequency";
+                        readonly symbol: "eFRQCY";
+                        readonly decimals: 12;
+                        readonly deliveryGas: 80000n;
+                    };
+                    readonly "0xfff9976782d46cc05630d1f6ebab18b2324d6b14": {
+                        readonly token: "0xfff9976782d46cc05630d1f6ebab18b2324d6b14";
+                        readonly name: "Wrapped Ether";
+                        readonly symbol: "WETH";
+                        readonly decimals: 18;
+                        readonly deliveryGas: 80000n;
+                    };
+                    readonly "0x23838b1bb57cecf4422a57dd8e7f8a087b30d54f": {
+                        readonly token: "0x23838b1bb57cecf4422a57dd8e7f8a087b30d54f";
+                        readonly name: "Frequency";
+                        readonly symbol: "XRQCY";
+                        readonly decimals: 8;
+                        readonly foreignId: "0xaf13384cf9612ef1ff4b87470ab247d6f8d8110d4f5af2fe290ce6767818712c";
+                        readonly deliveryGas: 80000n;
+                    };
+                    readonly "0xb8a0f2703ac6bdd352096c90c2945a097e8f4055": {
+                        readonly token: "0xb8a0f2703ac6bdd352096c90c2945a097e8f4055";
+                        readonly name: "WND";
+                        readonly symbol: "WND";
+                        readonly decimals: 12;
+                        readonly foreignId: "0x2121cfe35065c0c33465fbada265f08e9613428a4b9eb4bb717cd7db2abf622e";
+                        readonly deliveryGas: 80000n;
+                    };
+                    readonly "0xf50fb50d65c8c1f6c72e4d8397c984933afc8f7e": {
+                        readonly token: "0xf50fb50d65c8c1f6c72e4d8397c984933afc8f7e";
+                        readonly name: "WND";
+                        readonly symbol: "WND";
+                        readonly decimals: 12;
+                        readonly foreignId: "0x9441dceeeffa7e032eedaccf9b7632e60e86711551a82ffbbb0dda8afd9e4ef7";
+                        readonly deliveryGas: 80000n;
+                    };
+                };
+                readonly key: "ethereum_11155111";
+                readonly baseDeliveryGas: 120000n;
+            };
+        };
+        readonly parachains: {
+            readonly polkadot_1000: {
+                readonly id: 1000;
+                readonly kind: "polkadot";
+                readonly key: "polkadot_1000";
+                readonly features: {
+                    readonly hasPalletXcm: true;
+                    readonly hasDryRunApi: true;
+                    readonly hasTxPaymentApi: true;
+                    readonly hasDryRunRpc: true;
+                    readonly hasDotBalance: true;
+                    readonly hasEthBalance: true;
+                    readonly hasXcmPaymentApi: true;
+                    readonly supportsAliasOrigin: true;
+                    readonly xcmVersion: "v5";
+                    readonly supportsV2: true;
+                };
+                readonly info: {
+                    readonly tokenSymbols: "WND";
+                    readonly tokenDecimals: 12;
+                    readonly ss58Format: 42;
+                    readonly isEthereum: false;
+                    readonly accountType: "AccountId32";
+                    readonly name: "Westend Asset Hub";
+                    readonly specName: "westmint";
+                    readonly specVersion: 1021000;
+                };
+                readonly assets: {
+                    readonly "0x0000000000000000000000000000000000000000": {
+                        readonly token: "0x0000000000000000000000000000000000000000";
+                        readonly name: "Ether";
+                        readonly minimumBalance: 15000n;
+                        readonly symbol: "Ether";
+                        readonly decimals: 18;
+                        readonly isSufficient: true;
+                    };
+                    readonly "0x1c7d4b196cb0c7b01d743fbc6116a902379c7238": {
+                        readonly token: "0x1c7d4b196cb0c7b01d743fbc6116a902379c7238";
+                        readonly name: "";
+                        readonly minimumBalance: 1n;
+                        readonly symbol: "";
+                        readonly decimals: 0;
+                        readonly isSufficient: false;
+                    };
+                    readonly "0x72c610e05eaafcdf1fa7a2da15374ee90edb1620": {
+                        readonly token: "0x72c610e05eaafcdf1fa7a2da15374ee90edb1620";
+                        readonly name: "";
+                        readonly minimumBalance: 1n;
+                        readonly symbol: "";
+                        readonly decimals: 0;
+                        readonly isSufficient: false;
+                    };
+                    readonly "0xfff9976782d46cc05630d1f6ebab18b2324d6b14": {
+                        readonly token: "0xfff9976782d46cc05630d1f6ebab18b2324d6b14";
+                        readonly name: "Wrapped Ether";
+                        readonly minimumBalance: 15000000000000n;
+                        readonly symbol: "WETH";
+                        readonly decimals: 18;
+                        readonly isSufficient: true;
+                    };
+                    readonly "0x23838b1bb57cecf4422a57dd8e7f8a087b30d54f": {
+                        readonly token: "0x23838b1bb57cecf4422a57dd8e7f8a087b30d54f";
+                        readonly name: "";
+                        readonly symbol: "";
+                        readonly decimals: 0;
+                        readonly locationOnEthereum: {
+                            readonly parents: 1;
+                            readonly interior: {
+                                readonly x2: readonly [{
+                                    readonly globalConsensus: {
+                                        readonly byGenesis: "0xe143f23803ac50e8f6f8e62695d1ce9e4e1d68aa36c1cd2cfd15340213f3423e";
+                                    };
+                                }, {
+                                    readonly parachain: 2313;
+                                }];
+                            };
+                        };
+                        readonly location: {
+                            readonly parents: 1;
+                            readonly interior: {
+                                readonly x1: readonly [{
+                                    readonly parachain: 2313;
+                                }];
+                            };
+                        };
+                        readonly locationOnAH: {
+                            readonly parents: 1;
+                            readonly interior: {
+                                readonly x1: readonly [{
+                                    readonly parachain: 2313;
+                                }];
+                            };
+                        };
+                        readonly foreignId: "0xaf13384cf9612ef1ff4b87470ab247d6f8d8110d4f5af2fe290ce6767818712c";
+                        readonly minimumBalance: 1n;
+                        readonly isSufficient: false;
+                    };
+                    readonly "0xb8a0f2703ac6bdd352096c90c2945a097e8f4055": {
+                        readonly token: "0xb8a0f2703ac6bdd352096c90c2945a097e8f4055";
+                        readonly name: "";
+                        readonly symbol: "WND";
+                        readonly decimals: 12;
+                        readonly locationOnEthereum: {
+                            readonly parents: 1;
+                            readonly interior: {
+                                readonly x1: readonly [{
+                                    readonly globalConsensus: {
+                                        readonly byGenesis: "0xe143f23803ac50e8f6f8e62695d1ce9e4e1d68aa36c1cd2cfd15340213f3423e";
+                                    };
+                                }];
+                            };
+                        };
+                        readonly location: {
+                            readonly parents: 1;
+                            readonly interior: "Here";
+                        };
+                        readonly locationOnAH: {
+                            readonly parents: 1;
+                            readonly interior: "Here";
+                        };
+                        readonly foreignId: "0x2121cfe35065c0c33465fbada265f08e9613428a4b9eb4bb717cd7db2abf622e";
+                        readonly minimumBalance: 1000000000n;
+                        readonly isSufficient: true;
+                    };
+                    readonly "0xf50fb50d65c8c1f6c72e4d8397c984933afc8f7e": {
+                        readonly token: "0xf50fb50d65c8c1f6c72e4d8397c984933afc8f7e";
+                        readonly name: "";
+                        readonly symbol: "WND";
+                        readonly decimals: 12;
+                        readonly locationOnEthereum: {
+                            readonly parents: 1;
+                            readonly interior: {
+                                readonly x1: readonly [{
+                                    readonly globalConsensus: {
+                                        readonly byGenesis: "0xe143f23803ac50e8f6f8e62695d1ce9e4e1d68aa36c1cd2cfd15340213f3423e";
+                                    };
+                                }];
+                            };
+                        };
+                        readonly location: {
+                            readonly parents: 1;
+                            readonly interior: "Here";
+                        };
+                        readonly locationOnAH: {
+                            readonly parents: 1;
+                            readonly interior: "Here";
+                        };
+                        readonly foreignId: "0x9441dceeeffa7e032eedaccf9b7632e60e86711551a82ffbbb0dda8afd9e4ef7";
+                        readonly minimumBalance: 1000000000n;
+                        readonly isSufficient: true;
+                    };
+                };
+                readonly estimatedExecutionFeeDOT: 0n;
+                readonly estimatedDeliveryFeeDOT: 0n;
+            };
+        };
+    };
+};
+export default registry;
+//# sourceMappingURL=westend_sepolia_bridge_info.g.d.ts.map

package/dist/westend_sepolia_bridge_info.g.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"westend_sepolia_bridge_info.g.d.ts","sourceRoot":"","sources":["../src/westend_sepolia_bridge_info.g.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8XJ,CAAA;AACV,eAAe,QAAQ,CAAA"}