@monolythium/core-sdk 0.2.1 → 0.3.0

package/README.md

@@ -240,32 +240,18 @@ const backend = pqm1MnemonicToMlDsa65Backend(mnemonic);
 const signature = backend.sign(new Uint8Array([1, 2, 3]));
 ```
 
-### Legacy ethers.js v6 compat
-
-The package still ships an ethers v6 compat shim for legacy migration tooling:
-a `MonolythiumProvider` and `MonolythiumSigner` that drop in wherever ethers'
-`Provider` and `Signer` are expected. It is not the v4.1 no-EVM deployment path;
-new app work should use the MRV/RISC-V builders and `lyth_*` read surfaces.
-`ethers` is a peer dependency for this compatibility path.
-
-```ts
-import { Wallet } from "ethers";
-import {
-  MonolythiumProvider,
-  MonolythiumSigner,
-} from "@monolythium/core-sdk/ethers";
-
-const provider = new MonolythiumProvider("https://rpc.testnet.monolythium.com");
-const wallet = new Wallet(process.env.PRIVATE_KEY!);
-const signer = MonolythiumSigner.fromEthersWallet(wallet, provider);
-
-// Legacy-only adapter setup. Do not use this path for new v4.1 MRV deployments.
-console.log(await signer.getAddress());
-```
-
-For non-secp256k1 signing sources (OS keychain, hardware wallet, future
-ML-DSA-65 backends), implement `MonolythiumSignerBackend` and pass it to
-`new MonolythiumSigner(backend, provider)`.
+### ethers / viem compatibility
+
+The SDK does not ship an ethers-style provider or signer. The chain
+does not accept Ethereum-style ECDSA signatures at transaction
+admission, and there is no `eth_call` / `eth_estimateGas` /
+`eth_sendRawTransaction` on the dispatcher to translate to. Tooling
+that wants to read EVM-shaped block, balance, receipt, or log fields
+can keep using the curated `eth_*` read methods exposed by `RpcClient`
+directly (`ethBlockNumber`, `ethGetBalance`, `ethGetBlockByNumber`,
+`ethGetTransactionReceipt`, `ethGetLogs`, …). Submitting and signing
+transactions go through the native builders (`mesh_buildUnsignedTx` +
+ML-DSA-65 signer + `mesh_submitTx`, or `lyth_submitEncrypted`).
 
 ## Development
 

package/dist/crypto/index.d.cts

@@ -1,6 +1,5 @@
-import { a as MlDsa65Backend } from '../submission-BrsftNSl.cjs';
-export { A as ADDRESS_DERIVATION_DOMAIN, D as DKG_AEAD_TAG_LEN, b as DKG_NONCE_LEN, c as DecryptHint, d as ENUM_VARIANT_INDEX_ML_DSA_65, e as EncryptedEnvelope, f as EncryptedSubmission, E as EncryptionKey, g as ML_DSA_65_PUBLIC_KEY_LEN, h as ML_DSA_65_SEED_LEN, i as ML_DSA_65_SIGNATURE_LEN, j as ML_DSA_65_SIGNING_KEY_LEN, k as ML_KEM_768_CIPHERTEXT_LEN, l as ML_KEM_768_ENCAPSULATION_KEY_LEN, m as ML_KEM_768_SHARED_SECRET_LEN, M as MempoolClass, N as NativeEvmTxFields, n as NativeTxExtension, o as NativeTxExtensionDescriptor, p as NativeTxExtensionLike, q as NonceAad, S as STANDARD_ALGO_NUMBER_ML_DSA_65, r as bincodeDecryptHint, s as bincodeEncryptedEnvelope, t as bincodeNonceAad, u as bincodeSignedTransaction, v as buildEncryptedEnvelope, w as buildEncryptedSubmission, x as encodeMlDsa65Opaque, y as encodeTransactionForHash, z as encryptInnerTx, B as fetchEncryptionKey, C as mlDsa65AddressBytes, F as mlDsa65AddressFromPublicKey, G as outerSigDigest, H as submitEncryptedEnvelope } from '../submission-BrsftNSl.cjs';
-import '../native-events-BEkkGoak.cjs';
+import { H as MlDsa65Backend } from '../submission-D8xzCLNl.cjs';
+export { ej as ADDRESS_DERIVATION_DOMAIN, ek as DKG_AEAD_TAG_LEN, el as DKG_NONCE_LEN, em as DecryptHint, en as ENUM_VARIANT_INDEX_ML_DSA_65, eo as EncryptedEnvelope, ep as EncryptedSubmission, E as EncryptionKey, eq as ML_DSA_65_PUBLIC_KEY_LEN, er as ML_DSA_65_SEED_LEN, es as ML_DSA_65_SIGNATURE_LEN, et as ML_DSA_65_SIGNING_KEY_LEN, eu as ML_KEM_768_CIPHERTEXT_LEN, ev as ML_KEM_768_ENCAPSULATION_KEY_LEN, ew as ML_KEM_768_SHARED_SECRET_LEN, F as MempoolClass, D as NativeEvmTxFields, ex as NativeTxExtension, ey as NativeTxExtensionDescriptor, ez as NativeTxExtensionLike, eA as NonceAad, eB as STANDARD_ALGO_NUMBER_ML_DSA_65, eC as bincodeDecryptHint, eD as bincodeEncryptedEnvelope, eE as bincodeNonceAad, eF as bincodeSignedTransaction, eG as buildEncryptedEnvelope, eH as buildEncryptedSubmission, eI as encodeMlDsa65Opaque, eJ as encodeTransactionForHash, eK as encryptInnerTx, eL as fetchEncryptionKey, eM as mlDsa65AddressBytes, eN as mlDsa65AddressFromPublicKey, eO as outerSigDigest, eP as submitEncryptedEnvelope } from '../submission-D8xzCLNl.cjs';
 
 declare class BincodeWriter {
     #private;

package/dist/crypto/index.d.ts

@@ -1,6 +1,5 @@
-import { a as MlDsa65Backend } from '../submission-CelGfDRQ.js';
-export { A as ADDRESS_DERIVATION_DOMAIN, D as DKG_AEAD_TAG_LEN, b as DKG_NONCE_LEN, c as DecryptHint, d as ENUM_VARIANT_INDEX_ML_DSA_65, e as EncryptedEnvelope, f as EncryptedSubmission, E as EncryptionKey, g as ML_DSA_65_PUBLIC_KEY_LEN, h as ML_DSA_65_SEED_LEN, i as ML_DSA_65_SIGNATURE_LEN, j as ML_DSA_65_SIGNING_KEY_LEN, k as ML_KEM_768_CIPHERTEXT_LEN, l as ML_KEM_768_ENCAPSULATION_KEY_LEN, m as ML_KEM_768_SHARED_SECRET_LEN, M as MempoolClass, N as NativeEvmTxFields, n as NativeTxExtension, o as NativeTxExtensionDescriptor, p as NativeTxExtensionLike, q as NonceAad, S as STANDARD_ALGO_NUMBER_ML_DSA_65, r as bincodeDecryptHint, s as bincodeEncryptedEnvelope, t as bincodeNonceAad, u as bincodeSignedTransaction, v as buildEncryptedEnvelope, w as buildEncryptedSubmission, x as encodeMlDsa65Opaque, y as encodeTransactionForHash, z as encryptInnerTx, B as fetchEncryptionKey, C as mlDsa65AddressBytes, F as mlDsa65AddressFromPublicKey, G as outerSigDigest, H as submitEncryptedEnvelope } from '../submission-CelGfDRQ.js';
-import '../native-events-BEkkGoak.js';
+import { H as MlDsa65Backend } from '../submission-D8xzCLNl.js';
+export { ej as ADDRESS_DERIVATION_DOMAIN, ek as DKG_AEAD_TAG_LEN, el as DKG_NONCE_LEN, em as DecryptHint, en as ENUM_VARIANT_INDEX_ML_DSA_65, eo as EncryptedEnvelope, ep as EncryptedSubmission, E as EncryptionKey, eq as ML_DSA_65_PUBLIC_KEY_LEN, er as ML_DSA_65_SEED_LEN, es as ML_DSA_65_SIGNATURE_LEN, et as ML_DSA_65_SIGNING_KEY_LEN, eu as ML_KEM_768_CIPHERTEXT_LEN, ev as ML_KEM_768_ENCAPSULATION_KEY_LEN, ew as ML_KEM_768_SHARED_SECRET_LEN, F as MempoolClass, D as NativeEvmTxFields, ex as NativeTxExtension, ey as NativeTxExtensionDescriptor, ez as NativeTxExtensionLike, eA as NonceAad, eB as STANDARD_ALGO_NUMBER_ML_DSA_65, eC as bincodeDecryptHint, eD as bincodeEncryptedEnvelope, eE as bincodeNonceAad, eF as bincodeSignedTransaction, eG as buildEncryptedEnvelope, eH as buildEncryptedSubmission, eI as encodeMlDsa65Opaque, eJ as encodeTransactionForHash, eK as encryptInnerTx, eL as fetchEncryptionKey, eM as mlDsa65AddressBytes, eN as mlDsa65AddressFromPublicKey, eO as outerSigDigest, eP as submitEncryptedEnvelope } from '../submission-D8xzCLNl.js';
 
 declare class BincodeWriter {
     #private;

package/dist/index.cjs

@@ -349,23 +349,23 @@ 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",
-  /** 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",
   /** Cluster-name registry. */
   CLUSTER_NAME_REGISTRY: "0x0000000000000000000000000000000000001104",
@@ -383,11 +383,11 @@ 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. */
+  /** Primary ML-DSA-65 pubkey registry — gateable. */
   PUBKEY_REGISTRY: "0x000000000000000000000000000000000000110D",
-  /** Hierarchical name registry (Law §5.10, whitepaper §22.8) — gateable. */
+  /** Hierarchical name registry — gateable. */
   NAME_REGISTRY: "0x000000000000000000000000000000000000110E"
 };
 
@@ -2333,23 +2333,9 @@ var RpcClient = class _RpcClient {
   async ethGetTransactionReceipt(txHash) {
     return normalizeTransactionReceipt(await this.call("eth_getTransactionReceipt", [txHash]));
   }
-  /** `eth_sendRawTransaction` — submit a signed raw tx. */
-  async ethSendRawTransaction(rawTx) {
-    return this.call("eth_sendRawTransaction", [rawTx]);
-  }
-  /** `eth_call` — dry-run a transaction. */
-  async ethCall(request, block = "latest") {
-    return this.call("eth_call", [request, encodeBlockSelector(block)]);
-  }
-  /** `eth_estimateGas` — gas estimate for a dry-run. */
-  async ethEstimateGas(request, block = "latest") {
-    return parseQuantityBig(
-      await this.call("eth_estimateGas", [request, encodeBlockSelector(block)])
-    );
-  }
   /**
-   * `eth_gasPrice` — legacy compatibility fee quote for ethers/viem shims.
-   * Native v4.1 surfaces should use execution-unit and lythoshi fee fields.
+   * `eth_gasPrice` — passive compatibility fee quote for EVM-shaped read
+   * tooling. Native callers should prefer `lythExecutionUnitPrice`.
    */
   async ethGasPrice() {
     return parseQuantityBig(await this.call("eth_gasPrice", []));
@@ -2388,7 +2374,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]);
@@ -2620,14 +2606,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)]);
   }
@@ -2855,14 +2853,6 @@ var RpcClient = class _RpcClient {
   async debugTraceTransaction(txHash) {
     return this.call("debug_traceTransaction", [txHash]);
   }
-  /** `debug_traceCall` — legacy compatibility trace for a dry-run. */
-  async debugTraceCall(request, block = "latest") {
-    return this.call("debug_traceCall", [request, encodeBlockSelector(block)]);
-  }
-  /** `debug_traceBlockByNumber` — legacy compatibility traces for an entire block. */
-  async debugTraceBlockByNumber(block) {
-    return this.call("debug_traceBlockByNumber", [encodeBlockSelector(block)]);
-  }
   /** `debug_mempoolDump` — full mempool snapshot. */
   async debugMempoolDump() {
     return normalizeMempoolSnapshot(await this.call("debug_mempoolDump", []));
@@ -3552,6 +3542,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");
@@ -3568,6 +3586,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,
@@ -4072,6 +4103,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);
@@ -4130,9 +4163,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");
@@ -4374,8 +4416,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"),
@@ -4389,10 +4446,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`);
@@ -4403,6 +4461,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`);
   }
@@ -4444,7 +4505,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: {
@@ -4473,6 +4536,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];
@@ -4568,16 +4644,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") {
@@ -4591,6 +4679,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`);
@@ -4720,9 +4812,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";
@@ -5959,7 +6052,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}`
@@ -7882,12 +7975,18 @@ function normalizeNativeAgentAddressString(address, expectedKind, name) {
   }
 }
 
-// src/ethers/network.ts
+// src/network.ts
 var MONOLYTHIUM_TESTNET_CHAIN_ID = 69420n;
 var MONOLYTHIUM_TESTNET_NETWORK_NAME = "monolythium-testnet";
+var MONOLYTHIUM_NETWORKS = {
+  testnet: {
+    chainId: MONOLYTHIUM_TESTNET_CHAIN_ID,
+    name: MONOLYTHIUM_TESTNET_NETWORK_NAME
+  }
+};
 
 // src/index.ts
-var version = "0.2.1";
+var version = "0.2.2";
 
 exports.ADDRESS_HRP = ADDRESS_HRP;
 exports.ADDRESS_KIND_HRPS = ADDRESS_KIND_HRPS;
@@ -7915,6 +8014,7 @@ exports.MAX_NATIVE_CALL_FORWARDER_REQUEST_BYTES = MAX_NATIVE_CALL_FORWARDER_REQU
 exports.MAX_NATIVE_RECEIPT_EVENTS = MAX_NATIVE_RECEIPT_EVENTS;
 exports.ML_DSA_65_PUBLIC_KEY_LEN = ML_DSA_65_PUBLIC_KEY_LEN2;
 exports.ML_DSA_65_SIGNATURE_LEN = ML_DSA_65_SIGNATURE_LEN2;
+exports.MONOLYTHIUM_NETWORKS = MONOLYTHIUM_NETWORKS;
 exports.MONOLYTHIUM_TESTNET_CHAIN_ID = MONOLYTHIUM_TESTNET_CHAIN_ID;
 exports.MONOLYTHIUM_TESTNET_NETWORK_NAME = MONOLYTHIUM_TESTNET_NETWORK_NAME;
 exports.MRV_DEPLOY_PAYLOAD_VERSION = MRV_DEPLOY_PAYLOAD_VERSION;
@@ -7971,6 +8071,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;