@hyperlane-xyz/cli 29.0.0 → 29.0.1

package/bundle/index.js

@@ -620629,7 +620629,7 @@ __webpack_async_result__();
 /* harmony export */ __nccwpck_require__.d(__webpack_exports__, {
 /* harmony export */   x: () => (/* binding */ VERSION)
 /* harmony export */ });
-const VERSION = '29.0.0';
+const VERSION = '29.0.1';
 //# sourceMappingURL=version.js.map
 
 /***/ }),
@@ -695064,7 +695064,7 @@ class RebalancerContextFactory {
         const intentStore = new _tracking_store_index_js__WEBPACK_IMPORTED_MODULE_16__/* .InMemoryStore */ .A();
         const actionStore = new _tracking_store_index_js__WEBPACK_IMPORTED_MODULE_16__/* .InMemoryStore */ .A();
         const explorerClient = typeof explorerUrlOrClient === 'string'
-            ? new _utils_ExplorerClient_js__WEBPACK_IMPORTED_MODULE_17__/* .ExplorerClient */ .x(explorerUrlOrClient)
+            ? new _utils_ExplorerClient_js__WEBPACK_IMPORTED_MODULE_17__/* .ExplorerClient */ .x(explorerUrlOrClient, (domain) => this.multiProvider.getProtocol(domain))
             : explorerUrlOrClient;
         // 3. Get MultiProtocolCore from registry (supports all VM types)
         // Only fetch/validate addresses for warp route chains (not all registry chains)
@@ -697834,12 +697834,30 @@ class InMemoryStore {
 /* harmony export */ __nccwpck_require__.d(__webpack_exports__, {
 /* harmony export */   x: () => (/* binding */ ExplorerClient)
 /* harmony export */ });
+/* harmony import */ var _hyperlane_xyz_utils__WEBPACK_IMPORTED_MODULE_0__ = __nccwpck_require__(16639);
+/* harmony import */ var _hyperlane_xyz_utils__WEBPACK_IMPORTED_MODULE_1__ = __nccwpck_require__(93142);
+
 class ExplorerClient {
     baseUrl;
-    constructor(baseUrl) {
+    getProtocol;
+    constructor(baseUrl, getProtocol) {
         this.baseUrl = baseUrl;
+        this.getProtocol = getProtocol;
     }
-    toBytea(addr) {
+    /**
+     * Convert an address to PostgreSQL bytea format (\\x-prefixed hex).
+     * When `domain` is provided, resolves the chain's protocol to encode
+     * non-EVM addresses (e.g. base58 Solana, 32-byte Starknet) correctly
+     * via `addressToByteHexString`. Without `domain`, assumes the address
+     * is already EVM-format hex (used for bridges, txSender, etc. which
+     * are always EVM addresses).
+     */
+    toBytea(addr, domain) {
+        const protocol = domain !== undefined ? this.getProtocol(domain) : undefined;
+        if (protocol && !(0,_hyperlane_xyz_utils__WEBPACK_IMPORTED_MODULE_0__/* .isEVMLike */ .Us)(protocol)) {
+            const hex = (0,_hyperlane_xyz_utils__WEBPACK_IMPORTED_MODULE_1__/* .addressToByteHexString */ .a2)(addr, protocol);
+            return hex.replace(/^0x/i, '\\x').toLowerCase();
+        }
         return addr.replace(/^0x/i, '\\x').toLowerCase();
     }
     /**
@@ -697868,14 +697886,17 @@ class ExplorerClient {
     async hasUndeliveredRebalance(params, logger) {
         const { bridges, routersByDomain, txSender, limit = 5 } = params;
         // Derive routers and domains from routersByDomain
-        const routers = Object.values(routersByDomain);
+        const routerEntries = Object.entries(routersByDomain);
         const domains = Object.keys(routersByDomain).map(Number);
         const variables = {
+            // NOTE: bridges are always EVM addresses; pass domain here if non-EVM bridges are added
             senders: bridges.map((a) => this.toBytea(a)),
+            // NOTE: bridges are always EVM addresses; pass domain here if non-EVM bridges are added
             recipients: bridges.map((a) => this.toBytea(a)),
-            originTxRecipients: routers.map((a) => this.toBytea(a)),
+            originTxRecipients: routerEntries.map(([domain, addr]) => this.toBytea(addr, Number(domain))),
             originDomains: domains,
             destDomains: domains,
+            // NOTE: txSender is always an EVM address (rebalancer signer)
             txSenders: [this.toBytea(txSender)],
             limit,
         };
@@ -697948,9 +697969,14 @@ class ExplorerClient {
             const expectedRouter = routersByDomain[msg.origin_domain_id];
             if (!expectedRouter)
                 return false;
+            const protocol = this.getProtocol(msg.origin_domain_id);
             const normalizedMsgRouter = msg.origin_tx_recipient?.startsWith('\\x')
                 ? '0x' + msg.origin_tx_recipient.slice(2)
                 : msg.origin_tx_recipient;
+            if (protocol && !(0,_hyperlane_xyz_utils__WEBPACK_IMPORTED_MODULE_0__/* .isEVMLike */ .Us)(protocol)) {
+                const expectedHex = (0,_hyperlane_xyz_utils__WEBPACK_IMPORTED_MODULE_1__/* .addressToByteHexString */ .a2)(expectedRouter, protocol).toLowerCase();
+                return normalizedMsgRouter?.toLowerCase() === expectedHex;
+            }
             return (normalizedMsgRouter?.toLowerCase() === expectedRouter.toLowerCase());
         });
         logger.debug({ totalRows: rows.length, validatedRows: validatedRows.length }, 'Post-query validation results');
@@ -697963,13 +697989,14 @@ class ExplorerClient {
     async getInflightUserTransfers(params, logger) {
         const { routersByDomain, excludeTxSenders, limit = 100 } = params;
         // Derive routers and domains from routersByDomain
-        const routers = Object.values(routersByDomain);
+        const routerEntries = Object.entries(routersByDomain);
         const domains = Object.keys(routersByDomain).map(Number);
         const variables = {
-            senders: routers.map((a) => this.toBytea(a)),
-            recipients: routers.map((a) => this.toBytea(a)),
+            senders: routerEntries.map(([domain, addr]) => this.toBytea(addr, Number(domain))),
+            recipients: routerEntries.map(([domain, addr]) => this.toBytea(addr, Number(domain))),
             originDomains: domains,
             destDomains: domains,
+            // NOTE: excludeTxSenders are always EVM addresses
             excludeTxSenders: excludeTxSenders.map((a) => this.toBytea(a)),
             limit,
         };
@@ -698044,19 +698071,23 @@ class ExplorerClient {
     async getInflightRebalanceActions(params, logger) {
         const { bridges, routersByDomain, rebalancerAddress, inventorySignerAddresses, limit = 100, } = params;
         // Derive routers and domains from routersByDomain
-        const routers = Object.values(routersByDomain);
+        const routerEntries = Object.entries(routersByDomain);
         const domains = Object.keys(routersByDomain).map(Number);
         // Build list of tx senders to include (rebalancer + optional inventory signer)
+        // NOTE: rebalancerAddress is always an EVM address (rebalancer signer)
         const txSenders = [this.toBytea(rebalancerAddress)];
         if (inventorySignerAddresses) {
             for (const addr of inventorySignerAddresses) {
+                // NOTE: inventorySignerAddresses are filtered to ProtocolType.Ethereum
                 txSenders.push(this.toBytea(addr));
             }
         }
         const variables = {
+            // NOTE: bridges are always EVM addresses; pass domain here if non-EVM bridges are added
             senders: bridges.map((a) => this.toBytea(a)),
+            // NOTE: bridges are always EVM addresses; pass domain here if non-EVM bridges are added
             recipients: bridges.map((a) => this.toBytea(a)),
-            originTxRecipients: routers.map((a) => this.toBytea(a)),
+            originTxRecipients: routerEntries.map(([domain, addr]) => this.toBytea(addr, Number(domain))),
             originDomains: domains,
             destDomains: domains,
             txSenders,
@@ -767725,8 +767756,8 @@ const TokenMetadataSchema = zod__WEBPACK_IMPORTED_MODULE_3__/* .object */ .Ik({
             denominator: zod__WEBPACK_IMPORTED_MODULE_3__/* .number */ .ai().int().gt(0),
         }),
         zod__WEBPACK_IMPORTED_MODULE_3__/* .object */ .Ik({
-            numerator: zod__WEBPACK_IMPORTED_MODULE_3__/* .coerce */ .au.bigint(),
-            denominator: zod__WEBPACK_IMPORTED_MODULE_3__/* .coerce */ .au.bigint(),
+            numerator: zod__WEBPACK_IMPORTED_MODULE_3__/* .coerce */ .au.bigint().positive(),
+            denominator: zod__WEBPACK_IMPORTED_MODULE_3__/* .coerce */ .au.bigint().positive(),
         }),
     ])
         .optional(),
@@ -768807,26 +768838,51 @@ function scalesEqual(a, b) {
     const nb = normalizeScale(b);
     return na.numerator * nb.denominator === nb.numerator * na.denominator;
 }
+/**
+ * Verifies that scale configs across chains are mutually consistent.
+ *
+ * A warp route may use either convention:
+ *   - Scale-up: 6-decimal chains carry scale > 1, max-decimal chain carries no scale
+ *   - Scale-down: max-decimal chain carries scale < 1 ({num:1, den:N}), others carry no scale
+ *
+ * Both are valid as long as the effective message amount is identical for every chain:
+ *   scale_A / scale_B == 10^(dec_B - dec_A)  for any pair (A, B)
+ *
+ * Equivalently (avoiding floating point): for a fixed reference chain R,
+ *   scale_A.num * 10^dec_A * scale_R.den  ==  scale_R.num * 10^dec_R * scale_A.den
+ *
+ * This accepts precision loss from scale-down (e.g., BSC 18-decimal USDT
+ * scaled to 6-decimal message encoding loses 12 digits of sub-unit precision).
+ */
 function verifyScale(configMap) {
     const chainDecimalConfigPairs = configMap instanceof Map
         ? Object.fromEntries(configMap.entries())
         : configMap;
-    const decimalsByChain = (0,_hyperlane_xyz_utils__WEBPACK_IMPORTED_MODULE_0__/* .objMap */ .Yp)(chainDecimalConfigPairs, (chain, config) => {
-        (0,_hyperlane_xyz_utils__WEBPACK_IMPORTED_MODULE_1__/* .assert */ .v)(config.decimals, `Decimals must be defined for token config on chain ${chain}`);
+    const entries = Object.entries((0,_hyperlane_xyz_utils__WEBPACK_IMPORTED_MODULE_0__/* .objMap */ .Yp)(chainDecimalConfigPairs, (chain, config) => {
+        (0,_hyperlane_xyz_utils__WEBPACK_IMPORTED_MODULE_1__/* .assert */ .v)(config.decimals != null, `Decimals must be defined for token config on chain ${chain}`);
         return { decimals: config.decimals, scale: config.scale };
-    });
-    if (!areDecimalsUniform(decimalsByChain)) {
-        const maxDecimals = Math.max(...Object.values(decimalsByChain).map((config) => config.decimals));
-        for (const [_, config] of Object.entries(decimalsByChain)) {
-            if (config.decimals) {
-                const calculatedScale = {
-                    numerator: 10n ** BigInt(maxDecimals - config.decimals),
-                    denominator: 1n,
-                };
-                if (!scalesEqual(calculatedScale, config.scale)) {
-                    return false;
-                }
-            }
+    }));
+    if (entries.length <= 1)
+        return true;
+    if (areDecimalsUniform(Object.fromEntries(entries))) {
+        const [, refConfig] = entries[0];
+        return entries.every(([, config]) => scalesEqual(refConfig.scale, config.scale));
+    }
+    // Pick the first chain as reference. For every other chain, verify pairwise:
+    //   ref.scale.num * 10^ref.dec * chain.scale.den
+    //     == chain.scale.num * 10^chain.dec * ref.scale.den
+    const [, refConfig] = entries[0];
+    const refNorm = normalizeScale(refConfig.scale);
+    const refEffective = refNorm.numerator * 10n ** BigInt(refConfig.decimals);
+    for (let i = 1; i < entries.length; i++) {
+        const [, config] = entries[i];
+        const norm = normalizeScale(config.scale);
+        const effective = norm.numerator * 10n ** BigInt(config.decimals);
+        // Cross-multiply to compare ratios without division:
+        //   refEffective / refNorm.denominator == effective / norm.denominator
+        //   => refEffective * norm.denominator == effective * refNorm.denominator
+        if (refEffective * norm.denominator !== effective * refNorm.denominator) {
+            return false;
         }
     }
     return true;
@@ -911250,7 +911306,7 @@ module.exports = /*#__PURE__*/JSON.parse('[{"type":"function","name":"proveL2Lea
 /***/ 99468:
 /***/ ((module) => {
 
-module.exports = {"rE":"29.0.0"};
+module.exports = {"rE":"29.0.1"};
 
 /***/ })
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperlane-xyz/cli",
-  "version": "29.0.0",
+  "version": "29.0.1",
   "description": "A command-line utility for common Hyperlane operations",
   "keywords": [
     "CLI",
@@ -79,21 +79,21 @@
     "zod": "^3.21.2",
     "zod-validation-error": "^3.3.0",
     "zx": "^8.1.4",
-    "@hyperlane-xyz/aleo-sdk": "29.0.0",
+    "@hyperlane-xyz/aleo-sdk": "29.0.1",
+    "@hyperlane-xyz/eslint-config": "29.0.1",
+    "@hyperlane-xyz/http-registry-server": "29.0.1",
+    "@hyperlane-xyz/deploy-sdk": "4.2.1",
     "@hyperlane-xyz/core": "11.1.0",
-    "@hyperlane-xyz/eslint-config": "29.0.0",
-    "@hyperlane-xyz/deploy-sdk": "4.2.0",
-    "@hyperlane-xyz/cosmos-sdk": "29.0.0",
-    "@hyperlane-xyz/http-registry-server": "29.0.0",
-    "@hyperlane-xyz/provider-sdk": "4.2.0",
-    "@hyperlane-xyz/rebalancer": "27.1.3",
-    "@hyperlane-xyz/radix-sdk": "29.0.0",
-    "@hyperlane-xyz/relayer": "1.1.12",
-    "@hyperlane-xyz/sdk": "29.0.0",
-    "@hyperlane-xyz/tron-sdk": "22.1.4",
-    "@hyperlane-xyz/tsconfig": "^29.0.0",
-    "@hyperlane-xyz/sealevel-sdk": "29.0.0",
-    "@hyperlane-xyz/utils": "29.0.0"
+    "@hyperlane-xyz/cosmos-sdk": "29.0.1",
+    "@hyperlane-xyz/provider-sdk": "4.2.1",
+    "@hyperlane-xyz/radix-sdk": "29.0.1",
+    "@hyperlane-xyz/rebalancer": "27.2.0",
+    "@hyperlane-xyz/relayer": "1.1.13",
+    "@hyperlane-xyz/sealevel-sdk": "29.0.1",
+    "@hyperlane-xyz/tron-sdk": "22.1.5",
+    "@hyperlane-xyz/tsconfig": "^29.0.1",
+    "@hyperlane-xyz/utils": "29.0.1",
+    "@hyperlane-xyz/sdk": "29.0.1"
   },
   "engines": {
     "node": ">=16"