@monolythium/core-sdk 0.2.0 → 0.2.2

package/dist/index.cjs

@@ -128,6 +128,41 @@ function parseAddress(address) {
   }
   return bech32ToAddressBytes(address);
 }
+function validateAddress(address) {
+  if (typeof address !== "string" || address.length === 0) {
+    return { valid: false, reason: "address cannot be empty" };
+  }
+  const trimmed = address.trim();
+  if (trimmed.length === 0) {
+    return { valid: false, reason: "address cannot be empty" };
+  }
+  if (trimmed.startsWith("0x") || trimmed.startsWith("0X")) {
+    try {
+      const bytes = hexToAddressBytes(trimmed);
+      return {
+        valid: true,
+        normalized: addressToBech32(bytes),
+        kind: null,
+        format: "hex",
+        bytes
+      };
+    } catch (err) {
+      return { valid: false, reason: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  try {
+    const typed = typedBech32ToAddress(trimmed);
+    return {
+      valid: true,
+      normalized: typed.address,
+      kind: typed.kind,
+      format: "bech32m",
+      bytes: typed.bytes
+    };
+  } catch (err) {
+    return { valid: false, reason: err instanceof Error ? err.message : String(err) };
+  }
+}
 function normalizeAddressHex(address) {
   return addressBytesToHex(parseAddress(address));
 }
@@ -314,28 +349,24 @@ var PRECOMPILE_ADDRESSES = {
   TOKEN_FACTORY: "0x0000000000000000000000000000000000001000",
   /** Native central-limit order book — gateable. */
   CLOB: "0x0000000000000000000000000000000000001001",
-  /** Agent execution surface (zkML-gated, ADR-0011/ADR-0020) — gateable. */
+  /** Agent execution surface — gateable. */
   AGENT: "0x0000000000000000000000000000000000001003",
   /** Account privacy policy + stealth/confidential ops — gateable. */
   PRIVACY: "0x0000000000000000000000000000000000001004",
   /** Operator + RPC node registry — non-gateable consensus invariant. */
   NODE_REGISTRY: "0x0000000000000000000000000000000000001005",
-  /** IBC light-client + packet routing — gateable. */
-  IBC: "0x0000000000000000000000000000000000001007",
-  /** Native zk-light-client bridge — gateable. */
+  /** Native bridge route-control surface — gateable. */
   BRIDGE: "0x0000000000000000000000000000000000001008",
-  /** Decentralized multi-signer oracle (OI-0036) — non-gateable. */
+  /** Decentralized multi-signer oracle — non-gateable. */
   ORACLE: "0x0000000000000000000000000000000000001009",
-  /** Distributed delegation primitive (Stage E.5a, Law §7.6) — gateable. */
+  /** Distributed delegation primitive — gateable. */
   DELEGATION: "0x000000000000000000000000000000000000100A",
-  /** One-time emergency-key registry (Law §5.4 / §2.9) — non-gateable. */
+  /** One-time emergency-key registry — non-gateable. */
   EMERGENCY_KEY: "0x0000000000000000000000000000000000001100",
-  /** VRF precompile (Law §5.4 / §5.6). */
+  /** VRF precompile. */
   VRF: "0x0000000000000000000000000000000000001101",
-  /** Streaming-payments primitive (Law §5.4 / §5.7) — gateable. */
+  /** Streaming-payments primitive — gateable. */
   STREAMING_PAYMENTS: "0x0000000000000000000000000000000000001102",
-  /** Human-readable name registry (Law §5.4 / §5.8) — gateable. */
-  NAME_REGISTRY: "0x0000000000000000000000000000000000001103",
   /** Cluster-name registry. */
   CLUSTER_NAME_REGISTRY: "0x0000000000000000000000000000000000001104",
   /** Agent-commerce attestation precompile. */
@@ -352,10 +383,12 @@ var PRECOMPILE_ADDRESSES = {
   ESCROW: "0x000000000000000000000000000000000000110A",
   /** Agent-commerce arbiter registry. */
   ARBITER_REGISTRY: "0x000000000000000000000000000000000000110B",
-  /** Agent spending policy — gateable, activated by Stage 7 milestones. */
+  /** Agent spending policy — gateable. */
   SPENDING_POLICY: "0x000000000000000000000000000000000000110C",
-  /** Primary ML-DSA-65 pubkey registry — gateable, ADR-0034. */
-  PUBKEY_REGISTRY: "0x000000000000000000000000000000000000110D"
+  /** Primary ML-DSA-65 pubkey registry — gateable. */
+  PUBKEY_REGISTRY: "0x000000000000000000000000000000000000110D",
+  /** Hierarchical name registry — gateable. */
+  NAME_REGISTRY: "0x000000000000000000000000000000000000110E"
 };
 
 // src/node-registry.ts
@@ -2355,7 +2388,7 @@ var RpcClient = class _RpcClient {
   async web3Sha3(data) {
     return this.call("web3_sha3", [data]);
   }
-  // ---- lyth_* (Law §13.2 native namespace) --------------------------
+  // ---- lyth_* native namespace --------------------------------------
   /** `lyth_listProviders` — paged registry enumeration. */
   async lythListProviders(capabilityMask, cursor = null, limit = 100) {
     return this.call("lyth_listProviders", [capabilityMask, cursor, limit]);
@@ -2587,14 +2620,26 @@ var RpcClient = class _RpcClient {
   async lythCurrentRound() {
     return normalizeRoundInfo(await this.call("lyth_currentRound", []));
   }
+  /** `lyth_getTransactionCount` — native sender nonce. */
+  async lythGetTransactionCount(address) {
+    return parseRpcBigint(
+      await this.call("lyth_getTransactionCount", [
+        sdkTypedAddress(address, "user", "address")
+      ]),
+      "lyth_getTransactionCount"
+    );
+  }
+  /** `lyth_executionUnitPrice` — native execution-unit price in lythoshi. */
+  async lythExecutionUnitPrice() {
+    return normalizeExecutionUnitPriceResponse(
+      await this.call("lyth_executionUnitPrice", [])
+    );
+  }
   /** `lyth_peerSummary` — public-safe aggregate peer-network diagnostics. */
   async lythPeerSummary() {
     return this.call("lyth_peerSummary", []);
   }
-  /**
-   * `lyth_listActivePrecompiles` — milestone-gated precompile catalogue
-   * (OI-0170 / ADR-0015 §5).
-   */
+  /** `lyth_listActivePrecompiles` — native precompile catalogue. */
   async lythListActivePrecompiles(block = "latest") {
     return this.call("lyth_listActivePrecompiles", [encodeBlockSelector(block)]);
   }
@@ -3519,6 +3564,34 @@ function normalizeRoundInfo(value) {
     height: parseRpcBigint(row["height"], "round height")
   };
 }
+function normalizeExecutionUnitPriceResponse(value) {
+  if (!value || typeof value !== "object") {
+    throw SdkError.malformed("execution unit price response must be an object");
+  }
+  const row = value;
+  return {
+    executionUnitPriceLythoshi: parseRpcBigint(
+      fieldAlias(row, ["executionUnitPriceLythoshi", "execution_unit_price_lythoshi"]),
+      "executionUnitPriceLythoshi"
+    ).toString(),
+    basePricePerExecutionUnitLythoshi: parseRpcBigint(
+      fieldAlias(row, [
+        "basePricePerExecutionUnitLythoshi",
+        "base_price_per_execution_unit_lythoshi"
+      ]),
+      "basePricePerExecutionUnitLythoshi"
+    ).toString(),
+    priorityTipLythoshi: parseRpcBigint(
+      fieldAlias(row, ["priorityTipLythoshi", "priority_tip_lythoshi"]),
+      "priorityTipLythoshi"
+    ).toString(),
+    blockNumber: parseRpcNumberNullable(
+      fieldAlias(row, ["blockNumber", "block_number"]),
+      "blockNumber"
+    ),
+    source: readStringField(row, ["source"], "execution unit price source")
+  };
+}
 function normalizeMempoolSnapshot(value) {
   if (!value || typeof value !== "object") {
     throw SdkError.malformed("mempool snapshot must be an object");
@@ -3535,6 +3608,19 @@ function normalizeMempoolSnapshot(value) {
     bytes_by_class: bytesByClass.map((v, i) => parseRpcBigint(v, `mempool bytes_by_class[${i}]`))
   };
 }
+function fieldAlias(record, keys) {
+  for (const key of keys) {
+    if (Object.prototype.hasOwnProperty.call(record, key)) return record[key];
+  }
+  return void 0;
+}
+function readStringField(record, keys, label) {
+  const value = fieldAlias(record, keys);
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw SdkError.malformed(`${label} must be a non-empty string`);
+  }
+  return value.trim();
+}
 function normalizeCapabilitiesResponse(value) {
   return {
     ...value,
@@ -4039,6 +4125,8 @@ var BRIDGE_REVERT_TAGS = {
 };
 var BRIDGE_QUOTE_API_BLOCKED_REASON = "bridge quote requires a mono-core live quote API/runtime primitive";
 var BRIDGE_SUBMIT_API_BLOCKED_REASON = "bridge submit requires a mono-core live submit API/runtime primitive";
+var V1_BRIDGE_ALLOWED_FEE_TOKEN = "LINK";
+var V1_BRIDGE_ALLOWED_PROTOCOL = "chainlink-ccip";
 var BridgePrecompileError = class extends Error {
   constructor(message) {
     super(message);
@@ -4097,9 +4185,18 @@ function isBridgeFinalityZeroRevert(data) {
 function assessBridgeRoute(route) {
   const blockedReasons = [];
   const warnings = [];
+  const feeToken = String(route.feeToken ?? "").trim();
   if (route.routeId.trim() === "") blockedReasons.push("route id missing");
   if (route.bridge.trim() === "") blockedReasons.push("bridge name missing");
+  if (!isChainlinkCcipRoute(route.protocol, route.bridge, route.verifier.model)) {
+    blockedReasons.push("bridge protocol must be Chainlink CCIP");
+  }
   if (route.asset.trim() === "") blockedReasons.push("asset disclosure missing");
+  if (feeToken === "") {
+    blockedReasons.push("route fee token missing");
+  } else if (feeToken.toUpperCase() !== V1_BRIDGE_ALLOWED_FEE_TOKEN) {
+    blockedReasons.push("CCIP route fee token must be LINK");
+  }
   if (route.verifier.model.trim() === "") blockedReasons.push("verifier model missing");
   if (route.verifier.threshold < 2 || route.verifier.participantCount < 2) {
     blockedReasons.push("verifier set must not be 1-of-1");
@@ -4341,8 +4438,23 @@ function validateBridgeRouteCatalogueRoute(idx, value, seen, blockedReasons) {
     20,
     blockedReasons
   );
-  validateTextField(`${prefix}.bridge`, value.bridge, 64, blockedReasons);
+  const bridge = validateTextField(`${prefix}.bridge`, value.bridge, 64, blockedReasons);
+  const protocol = validateOptionalTextField(
+    `${prefix}.protocol`,
+    field(value, "protocol", "routeProtocol", "route_protocol"),
+    64,
+    blockedReasons
+  );
   validateTextField(`${prefix}.asset`, value.asset, 64, blockedReasons);
+  const feeToken = validateTextField(
+    `${prefix}.feeToken`,
+    field(value, "feeToken", "fee_token"),
+    32,
+    blockedReasons
+  );
+  if (feeToken != null && feeToken.toUpperCase() !== V1_BRIDGE_ALLOWED_FEE_TOKEN) {
+    blockedReasons.push(`${prefix}.feeToken must be LINK for CCIP routes`);
+  }
   validateTextField(
     `${prefix}.sourceChain`,
     field(value, "sourceChain", "source_chain"),
@@ -4356,10 +4468,11 @@ function validateBridgeRouteCatalogueRoute(idx, value, seen, blockedReasons) {
     blockedReasons
   );
   const verifier = value.verifier;
+  let verifierModel = null;
   if (!isRecord2(verifier)) {
     blockedReasons.push(`${prefix}.verifier must be an object`);
   } else {
-    validateTextField(`${prefix}.verifier.model`, verifier.model, 64, blockedReasons);
+    verifierModel = validateTextField(`${prefix}.verifier.model`, verifier.model, 64, blockedReasons);
     const participantCount = field(verifier, "participantCount", "participant_count");
     if (!isU16(participantCount) || participantCount === 0) {
       blockedReasons.push(`${prefix}.verifier.participantCount must be non-zero`);
@@ -4370,6 +4483,9 @@ function validateBridgeRouteCatalogueRoute(idx, value, seen, blockedReasons) {
       blockedReasons.push(`${prefix}.verifier.threshold must be in 1..=participantCount`);
     }
   }
+  if (!isChainlinkCcipRoute(protocol, bridge ?? "", verifierModel ?? "")) {
+    blockedReasons.push(`${prefix}.protocol must be Chainlink CCIP`);
+  }
   if (!decimalStringIsPositiveU256(field(value, "drainCapAtomic", "drain_cap_atomic"))) {
     blockedReasons.push(`${prefix}.drainCapAtomic must be a non-zero decimal u256`);
   }
@@ -4411,7 +4527,9 @@ function coerceBridgeRouteCatalogueRoute(value) {
     bridgeId: stringField2(value, "bridgeId", "bridge_id"),
     wrappedAsset: stringField2(value, "wrappedAsset", "wrapped_asset"),
     bridge: stringField2(value, "bridge").trim(),
+    protocol: optionalStringField(value, "protocol", "routeProtocol", "route_protocol"),
     asset: stringField2(value, "asset").trim(),
+    feeToken: stringField2(value, "feeToken", "fee_token").trim(),
     sourceChain: stringField2(value, "sourceChain", "source_chain").trim(),
     destinationChain: stringField2(value, "destinationChain", "destination_chain").trim(),
     verifier: {
@@ -4440,6 +4558,19 @@ function cloneBridgeRouteCatalogueRoute(route) {
     verifier: { ...route.verifier }
   };
 }
+function isChainlinkCcipRoute(protocol, bridge, verifierModel) {
+  const normalizedProtocol = normalizeBridgeProtocol(protocol ?? "");
+  if (normalizedProtocol.length > 0) {
+    return normalizedProtocol === "chainlinkccip" || normalizedProtocol === "ccip";
+  }
+  return bridgeLabelLooksCcip(bridge) || bridgeLabelLooksCcip(verifierModel);
+}
+function bridgeLabelLooksCcip(value) {
+  return normalizeBridgeProtocol(value).includes("ccip");
+}
+function normalizeBridgeProtocol(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9]/g, "");
+}
 function bridgeRouteCandidate(intent, intentReasons, route) {
   const assessment = assessBridgeRoute(route);
   const blockedReasons = [...intentReasons, ...assessment.blockedReasons];
@@ -4535,16 +4666,28 @@ function trimmedEq(left, right) {
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function field(record, camel, snake) {
-  if (Object.prototype.hasOwnProperty.call(record, camel)) return record[camel];
-  if (snake != null && Object.prototype.hasOwnProperty.call(record, snake)) return record[snake];
+function field(record, ...keys) {
+  for (const key of keys) {
+    if (Object.prototype.hasOwnProperty.call(record, key)) return record[key];
+  }
   return void 0;
 }
-function stringField2(record, camel, snake) {
-  return field(record, camel, snake);
+function stringField2(record, ...keys) {
+  return field(record, ...keys);
+}
+function optionalStringField(record, ...keys) {
+  let raw;
+  for (const key of keys) {
+    if (Object.prototype.hasOwnProperty.call(record, key)) {
+      raw = record[key];
+      break;
+    }
+  }
+  if (raw === void 0 || raw === null) return null;
+  return typeof raw === "string" ? raw.trim() : "";
 }
-function numberField(record, camel, snake) {
-  return field(record, camel, snake);
+function numberField(record, ...keys) {
+  return field(record, ...keys);
 }
 function validateTextField(name, value, maxLen, blockedReasons) {
   if (typeof value !== "string") {
@@ -4558,6 +4701,10 @@ function validateTextField(name, value, maxLen, blockedReasons) {
   }
   return trimmed;
 }
+function validateOptionalTextField(name, value, maxLen, blockedReasons) {
+  if (value === void 0 || value === null) return null;
+  return validateTextField(name, value, maxLen, blockedReasons);
+}
 function validateHexBytes(name, value, expectedBytes, blockedReasons) {
   if (typeof value !== "string") {
     blockedReasons.push(`${name} must be ${expectedBytes} bytes of hex`);
@@ -4687,9 +4834,10 @@ function concatBytes4(...parts) {
 var NO_EVM_RECEIPT_PROOF_SCHEMA = "mono.no_evm_receipt_proof.v1";
 var NO_EVM_RECEIPT_PROOF_TYPE = "canonicalReceiptsTranscript";
 var NO_EVM_RECEIPT_INCLUSION_PROOF_TYPE = "canonicalReceiptInclusion";
-var NO_EVM_RECEIPT_ROOT_ALGORITHM = "keccak256(monolythium/v4.1/receipts_root_empty/1|receipt_leaf/1|receipt_node/1 binary Merkle)";
+var NO_EVM_RECEIPT_ROOT_ALGORITHM = "keccak256-binary-merkle(monolythium/v4.1/receipt_leaf/1, monolythium/v4.1/receipt_node/1, duplicate-last padding)";
+var NO_EVM_LEGACY_BINARY_RECEIPT_ROOT_ALGORITHM = "keccak256(monolythium/v4.1/receipts_root_empty/1|receipt_leaf/1|receipt_node/1 binary Merkle)";
 var NO_EVM_LEGACY_RECEIPT_ROOT_ALGORITHM = "keccak256(monolythium/v2/receipts_root/1 || len || indexed bincode receipts)";
-var NO_EVM_RECEIPT_CODEC = "bincode(protocore_evm::Receipt)";
+var NO_EVM_RECEIPT_CODEC = "bincode(protocore_execution_types::Receipt)";
 var NO_EVM_RECEIPTS_ROOT_DOMAIN = "monolythium/v4.1/receipts_root_empty/1";
 var NO_EVM_RECEIPT_LEAF_DOMAIN = "monolythium/v4.1/receipt_leaf/1";
 var NO_EVM_RECEIPT_NODE_DOMAIN = "monolythium/v4.1/receipt_node/1";
@@ -5926,7 +6074,7 @@ function getOptionalHistorySource(proof) {
   return value === void 0 ? void 0 : String(value);
 }
 function assertSupportedRootAlgorithm(actual) {
-  if (actual !== NO_EVM_RECEIPT_ROOT_ALGORITHM && actual !== NO_EVM_LEGACY_RECEIPT_ROOT_ALGORITHM && actual !== NO_EVM_COMPACT_INCLUSION_TREE_ALGORITHM) {
+  if (actual !== NO_EVM_RECEIPT_ROOT_ALGORITHM && actual !== NO_EVM_LEGACY_BINARY_RECEIPT_ROOT_ALGORITHM && actual !== NO_EVM_LEGACY_RECEIPT_ROOT_ALGORITHM && actual !== NO_EVM_COMPACT_INCLUSION_TREE_ALGORITHM) {
     throw new NoEvmReceiptProofError(
       "unsupported_root_algorithm",
       `unsupported no-EVM receipt proof rootAlgorithm: ${actual}`
@@ -7854,7 +8002,7 @@ var MONOLYTHIUM_TESTNET_CHAIN_ID = 69420n;
 var MONOLYTHIUM_TESTNET_NETWORK_NAME = "monolythium-testnet";
 
 // src/index.ts
-var version = "0.2.0";
+var version = "0.2.2";
 
 exports.ADDRESS_HRP = ADDRESS_HRP;
 exports.ADDRESS_KIND_HRPS = ADDRESS_KIND_HRPS;
@@ -7938,6 +8086,8 @@ exports.SPENDING_POLICY_SELECTORS = SPENDING_POLICY_SELECTORS;
 exports.SdkError = SdkError;
 exports.SpendingPolicyError = SpendingPolicyError;
 exports.TESTNET_69420 = TESTNET_69420;
+exports.V1_BRIDGE_ALLOWED_FEE_TOKEN = V1_BRIDGE_ALLOWED_FEE_TOKEN;
+exports.V1_BRIDGE_ALLOWED_PROTOCOL = V1_BRIDGE_ALLOWED_PROTOCOL;
 exports.addressBytesToHex = addressBytesToHex;
 exports.addressToBech32 = addressToBech32;
 exports.addressToTypedBech32 = addressToTypedBech32;
@@ -8149,6 +8299,7 @@ exports.submitMrvCallNativeTx = submitMrvCallNativeTx;
 exports.submitMrvDeployNativeTx = submitMrvDeployNativeTx;
 exports.submitMrvDeployPayloadNativeTx = submitMrvDeployPayloadNativeTx;
 exports.typedBech32ToAddress = typedBech32ToAddress;
+exports.validateAddress = validateAddress;
 exports.validateBridgeRouteCatalogue = validateBridgeRouteCatalogue;
 exports.validateMrvArtifactMetadata = validateMrvArtifactMetadata;
 exports.validateMrvCallRequest = validateMrvCallRequest;