@monolythium/core-sdk 0.4.5 → 0.4.9

package/dist/index.cjs

@@ -451,7 +451,13 @@ var NODE_REGISTRY_SELECTORS = {
   /** `getClusterJoinRequest(uint32,bytes32)` — CJ-1 request status view. */
   getClusterJoinRequest: "0x" + selectorHex("getClusterJoinRequest(uint32,bytes32)"),
   /** `formCluster(bytes,bytes,bytes)` — no-foundation cluster formation by roster consent. */
-  formCluster: "0x" + selectorHex("formCluster(bytes,bytes,bytes)")
+  formCluster: "0x" + selectorHex("formCluster(bytes,bytes,bytes)"),
+  /** `setOperatorDisplay(bytes32,string,string)` — owner-callable public display metadata. */
+  setOperatorDisplay: "0x" + selectorHex("setOperatorDisplay(bytes32,string,string)"),
+  /** `publishOperatorSealKey(bytes32,bytes)` — owner-callable LythiumSeal EK publication. */
+  publishOperatorSealKey: "0x" + selectorHex("publishOperatorSealKey(bytes32,bytes)"),
+  /** `getOperatorSealKey(bytes32)` view — returns the operator's published LythiumSeal EK. */
+  getOperatorSealKey: "0x" + selectorHex("getOperatorSealKey(bytes32)")
 };
 var NODE_REGISTRY_CLUSTER_MEMBER_REF_BYTES = 48;
 var NODE_REGISTRY_LEGACY_CLUSTER_MEMBER_PUBKEY_BYTES = NODE_REGISTRY_CLUSTER_MEMBER_REF_BYTES;
@@ -459,6 +465,7 @@ var NODE_REGISTRY_BLS_PUBKEY_BYTES = NODE_REGISTRY_CLUSTER_MEMBER_REF_BYTES;
 var NODE_REGISTRY_CONSENSUS_PUBKEY_BYTES = 1952;
 var NODE_REGISTRY_CONSENSUS_SIGNATURE_BYTES = 3309;
 var NODE_REGISTRY_CONSENSUS_POP_BYTES = 3309;
+var NODE_REGISTRY_OPERATOR_SEAL_EK_BYTES = 1184;
 var NODE_REGISTRY_DKG_ATTESTATION_SIG_BYTES = 96;
 var NODE_REGISTRY_DKG_THRESHOLD_SIG_BYTES = NODE_REGISTRY_DKG_ATTESTATION_SIG_BYTES;
 var NODE_REGISTRY_DKG_RESHARE_MIN_SIGNERS = 5;
@@ -469,6 +476,8 @@ var NODE_REGISTRY_FORM_CLUSTER_STANDBY_COUNT = 3;
 var NODE_REGISTRY_FORM_CLUSTER_MEMBER_COUNT = NODE_REGISTRY_FORM_CLUSTER_ACTIVE_COUNT + NODE_REGISTRY_FORM_CLUSTER_STANDBY_COUNT;
 var NODE_REGISTRY_FORM_CLUSTER_THRESHOLD = 7;
 var NODE_REGISTRY_FORM_CLUSTER_MESSAGE_DOMAIN = "PROTOCORE_NODE_REGISTRY_CLUSTER_FORM_V1\0";
+var NODE_REGISTRY_OPERATOR_MONIKER_MAX_BYTES = 128;
+var NODE_REGISTRY_OPERATOR_ALIAS_MAX_BYTES = 64;
 var PENDING_CHANGE_KIND_CODES = {
   add: 1,
   remove: 2,
@@ -677,6 +686,68 @@ function encodeVoteClusterAdmitCalldata(args) {
     )
   );
 }
+function encodeSetOperatorDisplayCalldata(args) {
+  const peerId = expectLength2(toBytes(args.peerId), 32, "peerId");
+  const moniker = displayTextBytes(
+    args.moniker,
+    NODE_REGISTRY_OPERATOR_MONIKER_MAX_BYTES,
+    "moniker"
+  );
+  const alias = displayTextBytes(args.alias, NODE_REGISTRY_OPERATOR_ALIAS_MAX_BYTES, "alias");
+  const monikerPadded = padToWord(moniker);
+  const aliasPadded = padToWord(alias);
+  const monikerOffset = 3n * 32n;
+  const aliasOffset = monikerOffset + 32n + BigInt(monikerPadded.length);
+  return bytesToHex(
+    concatBytes(
+      hexToBytes(NODE_REGISTRY_SELECTORS.setOperatorDisplay),
+      peerId,
+      uint64Word(monikerOffset, "monikerOffset"),
+      uint64Word(aliasOffset, "aliasOffset"),
+      uint64Word(BigInt(moniker.length), "monikerLength"),
+      monikerPadded,
+      uint64Word(BigInt(alias.length), "aliasLength"),
+      aliasPadded
+    )
+  );
+}
+function encodePublishOperatorSealKeyCalldata(args) {
+  const peerId = expectLength2(toBytes(args.peerId), 32, "peerId");
+  const sealEk = expectNonZeroBytes(
+    expectLength2(toBytes(args.sealEk), NODE_REGISTRY_OPERATOR_SEAL_EK_BYTES, "sealEk"),
+    "sealEk"
+  );
+  const sealEkPadded = padToWord(sealEk);
+  return bytesToHex(
+    concatBytes(
+      hexToBytes(NODE_REGISTRY_SELECTORS.publishOperatorSealKey),
+      peerId,
+      uint64Word(2n * 32n, "sealEkOffset"),
+      uint64Word(BigInt(sealEk.length), "sealEkLength"),
+      sealEkPadded
+    )
+  );
+}
+function encodeGetOperatorSealKeyCalldata(args) {
+  return bytesToHex(
+    concatBytes(
+      hexToBytes(NODE_REGISTRY_SELECTORS.getOperatorSealKey),
+      expectLength2(toBytes(args.operatorId), 32, "operatorId")
+    )
+  );
+}
+function decodeOperatorSealKey(returnData) {
+  const bytes = toBytes(returnData);
+  if (bytes.length === NODE_REGISTRY_OPERATOR_SEAL_EK_BYTES) {
+    return bytesToHex(expectNonZeroBytes(bytes, "operatorSealKey"));
+  }
+  const sealEk = decodeDynamicBytesResult(
+    bytes,
+    NODE_REGISTRY_OPERATOR_SEAL_EK_BYTES,
+    "operatorSealKey"
+  );
+  return bytesToHex(expectNonZeroBytes(sealEk, "operatorSealKey"));
+}
 function encodeCancelClusterJoinCalldata(args) {
   return bytesToHex(
     concatBytes(
@@ -1050,6 +1121,19 @@ function toBytes(value) {
   }
   return value instanceof Uint8Array ? value : Uint8Array.from(value);
 }
+function displayTextBytes(value, maxBytes, name) {
+  for (const ch of value) {
+    const code = ch.codePointAt(0);
+    if (code !== void 0 && (code >= 0 && code <= 31 || code >= 127 && code <= 159)) {
+      throw new NodeRegistryError(`${name} must not contain control characters`);
+    }
+  }
+  const bytes = new TextEncoder().encode(value);
+  if (bytes.length > maxBytes) {
+    throw new NodeRegistryError(`${name} must be <= ${maxBytes} UTF-8 bytes`);
+  }
+  return bytes;
+}
 function hexToBytes(hex) {
   const body = hex.startsWith("0x") || hex.startsWith("0X") ? hex.slice(2) : hex;
   if (body.length % 2 !== 0 || !/^[0-9a-fA-F]*$/.test(body)) {
@@ -1079,6 +1163,30 @@ function expectLength2(value, len, name) {
   }
   return value;
 }
+function expectNonZeroBytes(value, name) {
+  if (value.every((byte) => byte === 0)) {
+    throw new NodeRegistryError(`${name} must not be all-zero`);
+  }
+  return value;
+}
+function decodeDynamicBytesResult(bytes, expectedLength, label) {
+  if (bytes.length < 64) {
+    throw new NodeRegistryError(`${label} return must be ABI-encoded dynamic bytes`);
+  }
+  const offset = uintFromWord(bytes.slice(0, 32));
+  if (offset !== 32n) {
+    throw new NodeRegistryError(`${label} return offset must be 0x20`);
+  }
+  const len = uintFromWord(bytes.slice(32, 64));
+  if (len !== BigInt(expectedLength)) {
+    throw new NodeRegistryError(`${label} must be ${expectedLength} bytes, got ${len}`);
+  }
+  const paddedLen = Math.ceil(expectedLength / 32) * 32;
+  if (bytes.length < 64 + paddedLen) {
+    throw new NodeRegistryError(`${label} body is truncated`);
+  }
+  return bytes.slice(64, 64 + expectedLength);
+}
 
 // src/crypto/bytes.ts
 function concatBytes2(...chunks) {
@@ -1324,6 +1432,7 @@ var MlDsa65Backend = class _MlDsa65Backend {
   #secretKey;
   #publicKey;
   #addressBytes;
+  #disposed = false;
   constructor(secretKey, publicKey) {
     this.#secretKey = expectBytes(secretKey, ML_DSA_65_SIGNING_KEY_LEN, "ML-DSA-65 secret key").slice();
     this.#publicKey = expectBytes(publicKey, ML_DSA_65_PUBLIC_KEY_LEN, "ML-DSA-65 public key").slice();
@@ -1343,8 +1452,35 @@ var MlDsa65Backend = class _MlDsa65Backend {
     return bytesToHex2(this.#addressBytes);
   }
   sign(message) {
+    if (this.#disposed) {
+      throw new Error("MlDsa65Backend disposed");
+    }
     return mlDsa_js.ml_dsa65.sign(message, this.#secretKey, { extraEntropy: false });
   }
+  /**
+   * Best-effort deterministic wipe of the in-memory secret key. Zeroes the
+   * SDK-held `#secretKey` copy and makes any subsequent `sign()` /
+   * `signPrehash()` / `signEvmTx()` throw `"MlDsa65Backend disposed"` rather
+   * than signing with a zeroed key. Idempotent. Public material
+   * (`publicKey()` / `getAddress()` / `verify()`) stays usable.
+   *
+   * Defense-in-depth (S1-01): narrows the post-lock residency window of the
+   * ML-DSA-65 secret in the JS heap. `@noble/post-quantum`'s internal
+   * transient keygen/sign buffers are out of scope; the SDK-held copy is the
+   * meaningful residency win.
+   */
+  dispose() {
+    this.#secretKey.fill(0);
+    this.#disposed = true;
+  }
+  /** Alias for {@link dispose}. */
+  zeroize() {
+    this.dispose();
+  }
+  /** Whether {@link dispose} has been called (the secret key is wiped). */
+  get disposed() {
+    return this.#disposed;
+  }
   signPrehash(digest) {
     return this.sign(expectBytes(digest, 32, "prehash"));
   }
@@ -2706,8 +2842,8 @@ var TESTNET_69420 = {
   network: "testnet-69420",
   display_name: "Monolythium Testnet",
   description: "Public Monolythium testnet. Testnet state may reset without notice; do not store value on this network.",
-  genesis_hash: "0x6a2bb3c8a6701bedcddc0447583bb24f34b77310e3aa77c62ca303a453e9f7ba",
-  binary_sha: "c283c75d",
+  genesis_hash: "0x4327b7e8d1c06eed00194152f8235acaec5ba84a01487c885d9933840dc36fa5",
+  binary_sha: "898cf29081ec",
   rpc: [
     {
       url: "http://178.105.12.9:8545",
@@ -2768,7 +2904,7 @@ var TESTNET_69420 = {
     {
       url: "http://162.55.54.198:8545",
       provider: "monolythium-foundation",
-      region: "nbg1",
+      region: "fsn1",
       tier: "official",
       notes: "operator-9"
     },
@@ -2779,24 +2915,10 @@ var TESTNET_69420 = {
       tier: "official",
       notes: "operator-10"
     },
-    {
-      url: "http://5.223.65.201:8545",
-      provider: "monolythium-foundation",
-      region: "sin",
-      tier: "official",
-      notes: "operator-11; APAC"
-    },
-    {
-      url: "http://128.140.125.5:8545",
-      provider: "monolythium-foundation",
-      region: "fsn1",
-      tier: "official",
-      notes: "operator-12"
-    },
     {
       url: "http://178.105.45.210:8545",
       provider: "monolythium-foundation",
-      region: "nbg1",
+      region: "fsn1",
       tier: "official",
       notes: "relay-1"
     },
@@ -2810,52 +2932,52 @@ var TESTNET_69420 = {
   ],
   p2p: [
     {
-      multiaddr: "/ip4/178.105.12.9/tcp/29898/p2p/12D3KooWPv4ctqZX9faHicr8dJifyBwrpPA4oBev7w2WZStejMKa",
+      multiaddr: "/ip4/178.105.12.9/tcp/29898/p2p/12D3KooWGgh9vYbNSqYbci8w7bg2AAaFWx7umN1ADjjcUoUTF2Za",
       region: "fsn1"
     },
     {
-      multiaddr: "/ip4/178.105.15.216/tcp/29898/p2p/12D3KooWFZqKgAbve2dsAm9kKomychF4dyhtJYHL13mzh3D62d1r",
+      multiaddr: "/ip4/178.105.15.216/tcp/29898/p2p/12D3KooWPUMj4vt1ee1Ug2QMJQwbDHSJ936JVaqw3iLXtAqPrq7R",
       region: "fsn1"
     },
     {
-      multiaddr: "/ip4/178.104.233.182/tcp/29898/p2p/12D3KooWMG1tbP4hcvqdPP8QmnnPjaJCs4M1GUskzAJsL15ZFcVX",
+      multiaddr: "/ip4/178.104.233.182/tcp/29898/p2p/12D3KooWLPNJFUZhXyc1S7YvjMiKXyrNKCN3eFegDFF5UZAio7NJ",
       region: "nbg1"
     },
     {
-      multiaddr: "/ip4/65.108.94.1/tcp/29898/p2p/12D3KooWR5cz3fR4YkDDoPmQ6Qe7fmsXA7zo5AqdHY5Enmk5bKyT",
+      multiaddr: "/ip4/65.108.94.1/tcp/29898/p2p/12D3KooWRAuuQa5iEAzLUpLnyZ9VM53dvZMt3FPj7smDcwXn3oxz",
       region: "hel1"
     },
     {
-      multiaddr: "/ip4/95.216.154.155/tcp/29898/p2p/12D3KooWFJHH3zgAaPtSBXPkCEKeGNCWQTn1QYcm4YCr5VFT3GbC",
+      multiaddr: "/ip4/95.216.154.155/tcp/29898/p2p/12D3KooWFc9sVuCAuLxFTVy8KN5KXhyDvPjKkU98ySK81dFyStN8",
       region: "hel1"
     },
     {
-      multiaddr: "/ip4/87.99.145.48/tcp/29898/p2p/12D3KooWSDQdjgoiEbvsLErphM52u8tETdBtgyr4mbHQC5pT6HQz",
+      multiaddr: "/ip4/87.99.145.48/tcp/29898/p2p/12D3KooWL2KLRUHybGLd736nusDRTF2V1a9waeTsxKPwF78HDCmb",
       region: "ash"
     },
     {
-      multiaddr: "/ip4/5.223.85.76/tcp/29898/p2p/12D3KooWKHgMQnBtSfZqUknJdhGK8niKKbLXy81ifHV2khRgAYFX",
+      multiaddr: "/ip4/5.223.85.76/tcp/29898/p2p/12D3KooWHvobdzzEAiKcFkgdkRfr8vWGyWYfBoWS3jnPycvfwGrK",
       region: "sin"
     },
     {
-      multiaddr: "/ip4/142.132.180.99/tcp/29898/p2p/12D3KooWBx29V8iNQL22jk2CSVbvhodtXy4uTXVG7AgobxNcUuyP",
+      multiaddr: "/ip4/142.132.180.99/tcp/29898/p2p/12D3KooWBcAeWScYmDWPTjNM47CkKR4vEf44CNhDCcWuGpyY7Hko",
       region: "fsn1"
     },
     {
-      multiaddr: "/ip4/162.55.54.198/tcp/29898/p2p/12D3KooWJK2w6xzRFJMHWMxVuXpBHZE7PtDNGahEp9rq86AuhNRk",
-      region: "nbg1"
+      multiaddr: "/ip4/162.55.54.198/tcp/29898/p2p/12D3KooWRBA5Wzs619GuMY2NrDD6fGoLYCK2tkXff2JAZyXn7RvR",
+      region: "fsn1"
     },
     {
-      multiaddr: "/ip4/95.217.156.190/tcp/29898/p2p/12D3KooWLD8kzKHPVexZv2pMTvpjcEPTVZxr5qMxCeVB2QR6NNa6",
+      multiaddr: "/ip4/95.217.156.190/tcp/29898/p2p/12D3KooWPBr8guuWoZT59AobZEBHDZqKgwHWAP3aKUzKWeGTa7Z6",
       region: "hel1"
     },
     {
-      multiaddr: "/ip4/5.223.65.201/tcp/29898/p2p/12D3KooWAHC1cCiVsyVqrg4ofS2EQmu6Pv6G9Rc1t5btmoW6YicJ",
-      region: "sin"
+      multiaddr: "/ip4/178.105.45.210/tcp/29898/p2p/12D3KooWQRpCMLezJmvqqpbpEu8ixGHgonqianG1aVZjw6GiStbd",
+      region: "fsn1"
     },
     {
-      multiaddr: "/ip4/128.140.125.5/tcp/29898/p2p/12D3KooWNAc4EWkWWprKvqoF5aiq1ByqsLQjSN7r9ZTwYgGW365r",
-      region: "fsn1"
+      multiaddr: "/ip4/65.21.252.34/tcp/29898/p2p/12D3KooWRGzTwPX21Nee2c39RWuT2ayNWb6NMX19jCx8recrNeXL",
+      region: "hel1"
     }
   ]
 };
@@ -3652,6 +3774,16 @@ var RpcClient = class _RpcClient {
   async ethGetCode(address, block = "latest") {
     return this.call("eth_getCode", [address, encodeBlockSelector(block)]);
   }
+  /** `eth_call` — read-only execution against committed state. */
+  async ethCall(request, block = "latest") {
+    return this.call("eth_call", [request, encodeBlockSelector(block)]);
+  }
+  /** `eth_estimateGas` — read-only execution-unit estimate for a call object. */
+  async ethEstimateGas(request, block = "latest") {
+    return parseQuantityBig(
+      await this.call("eth_estimateGas", [request, encodeBlockSelector(block)])
+    );
+  }
   /** Compatibility block-header read by height/tag. */
   async ethGetBlockByNumber(block = "latest") {
     return normalizeBlockHeader(await this.call(ethCompatMethod("getBlockByNumber"), [encodeBlockSelector(block)]));
@@ -8350,6 +8482,7 @@ function pqm1MnemonicToMlDsa65Backend(mnemonic) {
 
 // src/cluster-join.ts
 var DEFAULT_CLUSTER_JOIN_EXECUTION_UNIT_LIMIT = REGISTRY_DEFAULT_EXECUTION_UNIT_LIMIT;
+var DEFAULT_OPERATOR_SEAL_KEY_EXECUTION_UNIT_LIMIT = REGISTRY_DEFAULT_EXECUTION_UNIT_LIMIT;
 var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
 var MAX_UINT32 = (1n << 32n) - 1n;
 function deriveClusterJoinOperatorId(operatorPubkey) {
@@ -8457,6 +8590,24 @@ function buildVoteClusterAdmitTxFields(args) {
     })
   };
 }
+function buildPublishOperatorSealKeyTxFields(args) {
+  return {
+    chainId: args.chainId,
+    nonce: args.nonce,
+    maxFeePerGas: parseBigint(args.fee.maxFeePerGas, "maxFeePerGas"),
+    maxPriorityFeePerGas: parseBigint(args.fee.maxPriorityFeePerGas, "maxPriorityFeePerGas"),
+    gasLimit: parseBigint(
+      args.fee.gasLimit ?? DEFAULT_OPERATOR_SEAL_KEY_EXECUTION_UNIT_LIMIT,
+      "gasLimit"
+    ),
+    to: nodeRegistryAddressHex(),
+    value: 0n,
+    input: encodePublishOperatorSealKeyCalldata({
+      peerId: normalizeOperatorId(args.peerId),
+      sealEk: normalizeOperatorSealEk(args.sealEk)
+    })
+  };
+}
 async function submitRequestClusterJoin(args) {
   const clusterId = parseUint32(args.clusterId, "clusterId");
   const operatorPubkey = normalizeConsensusPubkey(args.operatorPubkey, "operatorPubkey");
@@ -8512,6 +8663,39 @@ async function submitVoteClusterAdmit(args) {
   });
   return submitClusterJoinTx(args.client, backend, tx, clusterId, operatorIdHex, args);
 }
+async function submitPublishOperatorSealKey(args) {
+  const operatorIdHex = normalizeOperatorId(args.peerId);
+  const sealEk = normalizeOperatorSealEk(args.sealEk);
+  const backend = pqm1MnemonicToMlDsa65Backend(args.mnemonic);
+  const senderAddress = addressToTypedBech32("user", backend.addressBytes());
+  const [chainId, nonce, quote] = await Promise.all([
+    args.client.ethChainId(),
+    args.client.lythGetTransactionCount(senderAddress),
+    args.client.lythExecutionUnitPrice()
+  ]);
+  const tx = buildPublishOperatorSealKeyTxFields({
+    chainId,
+    nonce,
+    fee: resolveClusterJoinExecutionFee(quote, {
+      ...args,
+      executionUnitLimit: args.executionUnitLimit ?? DEFAULT_OPERATOR_SEAL_KEY_EXECUTION_UNIT_LIMIT
+    }),
+    peerId: operatorIdHex,
+    sealEk
+  });
+  const plaintext = buildPlaintextSubmission({ backend, tx });
+  const txHash = await submitPlaintextTransaction(
+    args.client,
+    plaintext.signedTxWireHex,
+    plaintext.innerTxHashHex
+  );
+  return {
+    txHash,
+    operatorIdHex,
+    innerSighashHex: plaintext.innerSighashHex,
+    signedTxWireBytes: plaintext.innerWireBytes
+  };
+}
 async function submitClusterJoinTx(client, backend, tx, clusterId, operatorIdHex, options) {
   if (options.private !== false) {
     const encrypted = await buildEncryptedSubmission({
@@ -8599,6 +8783,10 @@ function normalizeOperatorId(value) {
   const bytes = typeof value === "string" ? hexToBytes2(value, "operatorId") : value;
   return bytesToHex2(expectBytes(bytes, 32, "operatorId"));
 }
+function normalizeOperatorSealEk(value) {
+  const bytes = typeof value === "string" ? hexToBytes2(value, "sealEk") : value;
+  return expectBytes(bytes, NODE_REGISTRY_OPERATOR_SEAL_EK_BYTES, "sealEk").slice();
+}
 function parseUint32(value, label) {
   const parsed = parseBigint(value, label);
   if (parsed < 0n || parsed > MAX_UINT32) {
@@ -8813,15 +9001,405 @@ function expectLength4(value, len, name) {
   }
   return value;
 }
+var TokenFactoryError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TokenFactoryError";
+  }
+};
+var TOKEN_FACTORY_CREATE_DEPOSIT_LYTHOSHI = 3000000000000000n;
+var TOKEN_FACTORY_NAME_MAX_BYTES = 256;
+var TOKEN_FACTORY_SYMBOL_MAX_BYTES = 256;
+var TOKEN_FACTORY_MAX_DECIMALS = 30;
+var TOKEN_FACTORY_MAX_CREATOR_FEE_BPS = 1e4;
+var TOKEN_FACTORY_TOKEN_ID_DOMAIN_TAG = 250;
+var TOKEN_FACTORY_FLAGS = {
+  MINTABLE: 1 << 0,
+  BURNABLE: 1 << 1,
+  PAUSABLE: 1 << 2,
+  FIXED_SUPPLY: 1 << 3,
+  CREATOR_FEE_OPT_IN: 1 << 4,
+  DESTRUCTIBLE: 1 << 5
+};
+var TOKEN_FACTORY_KNOWN_FLAG_MASK = TOKEN_FACTORY_FLAGS.MINTABLE | TOKEN_FACTORY_FLAGS.BURNABLE | TOKEN_FACTORY_FLAGS.PAUSABLE | TOKEN_FACTORY_FLAGS.FIXED_SUPPLY | TOKEN_FACTORY_FLAGS.CREATOR_FEE_OPT_IN | TOKEN_FACTORY_FLAGS.DESTRUCTIBLE;
+var TOKEN_FACTORY_SIGS = {
+  createToken: "createToken(string,string,uint8,uint256,uint256,uint32,uint16)",
+  transfer: "transfer(bytes32,address,uint256)",
+  transferFrom: "transferFrom(bytes32,address,address,uint256)",
+  approve: "approve(bytes32,address,uint256)",
+  increaseAllowance: "increaseAllowance(bytes32,address,uint256)",
+  decreaseAllowance: "decreaseAllowance(bytes32,address,uint256)",
+  balanceOf: "balanceOf(bytes32,address)",
+  allowance: "allowance(bytes32,address,address)",
+  totalSupply: "totalSupply(bytes32)",
+  metadata: "metadata(bytes32)",
+  mint: "mint(bytes32,address,uint256)",
+  burn: "burn(bytes32,uint256)",
+  setPaused: "setPaused(bytes32,bool)",
+  transferOwnership: "transferOwnership(bytes32,address)",
+  destroyToken: "destroyToken(bytes32)"
+};
+var TOKEN_FACTORY_SELECTORS = {
+  createToken: selectorHex3(TOKEN_FACTORY_SIGS.createToken),
+  transfer: selectorHex3(TOKEN_FACTORY_SIGS.transfer),
+  transferFrom: selectorHex3(TOKEN_FACTORY_SIGS.transferFrom),
+  approve: selectorHex3(TOKEN_FACTORY_SIGS.approve),
+  increaseAllowance: selectorHex3(TOKEN_FACTORY_SIGS.increaseAllowance),
+  decreaseAllowance: selectorHex3(TOKEN_FACTORY_SIGS.decreaseAllowance),
+  balanceOf: selectorHex3(TOKEN_FACTORY_SIGS.balanceOf),
+  allowance: selectorHex3(TOKEN_FACTORY_SIGS.allowance),
+  totalSupply: selectorHex3(TOKEN_FACTORY_SIGS.totalSupply),
+  metadata: selectorHex3(TOKEN_FACTORY_SIGS.metadata),
+  mint: selectorHex3(TOKEN_FACTORY_SIGS.mint),
+  burn: selectorHex3(TOKEN_FACTORY_SIGS.burn),
+  setPaused: selectorHex3(TOKEN_FACTORY_SIGS.setPaused),
+  transferOwnership: selectorHex3(TOKEN_FACTORY_SIGS.transferOwnership),
+  destroyToken: selectorHex3(TOKEN_FACTORY_SIGS.destroyToken)
+};
+function tokenFactoryAddressHex() {
+  return PRECOMPILE_ADDRESSES.TOKEN_FACTORY.toLowerCase();
+}
+function deriveTokenFactoryTokenId(creator, creatorTokenNonce) {
+  const nonce = parseUint(creatorTokenNonce, "creatorTokenNonce", 64);
+  return bytesToHex2(
+    sha3_js.keccak_256(
+      concatBytes2(
+        new Uint8Array([TOKEN_FACTORY_TOKEN_ID_DOMAIN_TAG]),
+        addressBytes(creator, "creator"),
+        uint64Be(nonce)
+      )
+    )
+  );
+}
+function encodeCreateTokenCalldata(args) {
+  const name = textBytes(args.name, "name", TOKEN_FACTORY_NAME_MAX_BYTES);
+  const symbol = textBytes(args.symbol, "symbol", TOKEN_FACTORY_SYMBOL_MAX_BYTES);
+  const decimals = parseSmallUint(args.decimals, "decimals", TOKEN_FACTORY_MAX_DECIMALS);
+  const initialSupply = parseUint(args.initialSupply, "initialSupply");
+  const maxSupply = parseUint(args.maxSupply, "maxSupply");
+  const flags = args.flags ?? 0;
+  validateTokenFactoryFlags(flags, args.creatorFeeBps ?? 0);
+  const creatorFeeBps = parseSmallUint(
+    args.creatorFeeBps ?? 0,
+    "creatorFeeBps",
+    TOKEN_FACTORY_MAX_CREATOR_FEE_BPS
+  );
+  const headLen = 7 * 32;
+  const nameTail = dynamicBytesTail(name);
+  const symbolOffset = BigInt(headLen + nameTail.length);
+  return bytesToHex2(
+    concatBytes2(
+      hexToBytes2(TOKEN_FACTORY_SELECTORS.createToken, "createToken selector"),
+      uint256Word2(BigInt(headLen), "nameOffset"),
+      uint256Word2(symbolOffset, "symbolOffset"),
+      uint256Word2(BigInt(decimals), "decimals"),
+      uint256Word2(initialSupply, "initialSupply"),
+      uint256Word2(maxSupply, "maxSupply"),
+      uint256Word2(BigInt(flags), "flags"),
+      uint256Word2(BigInt(creatorFeeBps), "creatorFeeBps"),
+      nameTail,
+      dynamicBytesTail(symbol)
+    )
+  );
+}
+function encodeCreateFixedSupplyMrc20Calldata(args) {
+  let flags = TOKEN_FACTORY_FLAGS.FIXED_SUPPLY;
+  if (args.burnable) flags |= TOKEN_FACTORY_FLAGS.BURNABLE;
+  if (args.pausable) flags |= TOKEN_FACTORY_FLAGS.PAUSABLE;
+  if (args.destructible) flags |= TOKEN_FACTORY_FLAGS.DESTRUCTIBLE;
+  return encodeCreateTokenCalldata({
+    name: args.name,
+    symbol: args.symbol,
+    decimals: args.decimals,
+    initialSupply: args.supply,
+    maxSupply: args.supply,
+    flags,
+    creatorFeeBps: 0
+  });
+}
+function encodeTokenFactoryTransferCalldata(tokenId, to, amount) {
+  return encodeBytes32AddressUint(TOKEN_FACTORY_SELECTORS.transfer, tokenId, to, amount);
+}
+function encodeTokenFactoryTransferFromCalldata(tokenId, from, to, amount) {
+  return bytesToHex2(
+    concatBytes2(
+      hexToBytes2(TOKEN_FACTORY_SELECTORS.transferFrom, "transferFrom selector"),
+      bytes32(tokenId, "tokenId"),
+      addressWord3(from, "from"),
+      addressWord3(to, "to"),
+      uint256Word2(parseUint(amount, "amount"), "amount")
+    )
+  );
+}
+function encodeTokenFactoryApproveCalldata(tokenId, spender, amount) {
+  return encodeBytes32AddressUint(TOKEN_FACTORY_SELECTORS.approve, tokenId, spender, amount);
+}
+function encodeTokenFactoryIncreaseAllowanceCalldata(tokenId, spender, delta) {
+  return encodeBytes32AddressUint(TOKEN_FACTORY_SELECTORS.increaseAllowance, tokenId, spender, delta);
+}
+function encodeTokenFactoryDecreaseAllowanceCalldata(tokenId, spender, delta) {
+  return encodeBytes32AddressUint(TOKEN_FACTORY_SELECTORS.decreaseAllowance, tokenId, spender, delta);
+}
+function encodeTokenFactoryBalanceOfCalldata(tokenId, holder) {
+  return encodeBytes32Address(TOKEN_FACTORY_SELECTORS.balanceOf, tokenId, holder);
+}
+function encodeTokenFactoryAllowanceCalldata(tokenId, owner, spender) {
+  return bytesToHex2(
+    concatBytes2(
+      hexToBytes2(TOKEN_FACTORY_SELECTORS.allowance, "allowance selector"),
+      bytes32(tokenId, "tokenId"),
+      addressWord3(owner, "owner"),
+      addressWord3(spender, "spender")
+    )
+  );
+}
+function encodeTokenFactoryTotalSupplyCalldata(tokenId) {
+  return encodeBytes32(TOKEN_FACTORY_SELECTORS.totalSupply, tokenId);
+}
+function encodeTokenFactoryMetadataCalldata(tokenId) {
+  return encodeBytes32(TOKEN_FACTORY_SELECTORS.metadata, tokenId);
+}
+function encodeTokenFactoryMintCalldata(tokenId, to, amount) {
+  return encodeBytes32AddressUint(TOKEN_FACTORY_SELECTORS.mint, tokenId, to, amount);
+}
+function encodeTokenFactoryBurnCalldata(tokenId, amount) {
+  return encodeBytes32Uint(TOKEN_FACTORY_SELECTORS.burn, tokenId, amount);
+}
+function encodeTokenFactorySetPausedCalldata(tokenId, paused) {
+  return bytesToHex2(
+    concatBytes2(
+      hexToBytes2(TOKEN_FACTORY_SELECTORS.setPaused, "setPaused selector"),
+      bytes32(tokenId, "tokenId"),
+      boolWord(paused)
+    )
+  );
+}
+function encodeTokenFactoryTransferOwnershipCalldata(tokenId, newOwner) {
+  return encodeBytes32Address(TOKEN_FACTORY_SELECTORS.transferOwnership, tokenId, newOwner);
+}
+function encodeTokenFactoryDestroyCalldata(tokenId) {
+  return encodeBytes32(TOKEN_FACTORY_SELECTORS.destroyToken, tokenId);
+}
+function decodeTokenFactoryTokenId(output) {
+  return bytesToHex2(bytes32(output, "output"));
+}
+function validateTokenFactoryFlags(flags, creatorFeeBps = 0) {
+  if (!Number.isInteger(flags) || flags < 0 || flags > 4294967295) {
+    throw new TokenFactoryError("flags must be a uint32");
+  }
+  if ((flags & ~TOKEN_FACTORY_KNOWN_FLAG_MASK) !== 0) {
+    throw new TokenFactoryError("flags contain an unknown bit");
+  }
+  if ((flags & TOKEN_FACTORY_FLAGS.MINTABLE) !== 0 && (flags & TOKEN_FACTORY_FLAGS.FIXED_SUPPLY) !== 0) {
+    throw new TokenFactoryError("MINTABLE and FIXED_SUPPLY are mutually exclusive");
+  }
+  if ((flags & TOKEN_FACTORY_FLAGS.CREATOR_FEE_OPT_IN) !== 0) {
+    if (creatorFeeBps <= 0) throw new TokenFactoryError("CREATOR_FEE_OPT_IN requires non-zero creatorFeeBps");
+  } else if (creatorFeeBps !== 0) {
+    throw new TokenFactoryError("creatorFeeBps must be 0 when CREATOR_FEE_OPT_IN is unset");
+  }
+}
+function encodeBytes32(selector, value) {
+  return bytesToHex2(concatBytes2(hexToBytes2(selector, "selector"), bytes32(value, "tokenId")));
+}
+function encodeBytes32Uint(selector, tokenId, amount) {
+  return bytesToHex2(
+    concatBytes2(
+      hexToBytes2(selector, "selector"),
+      bytes32(tokenId, "tokenId"),
+      uint256Word2(parseUint(amount, "amount"), "amount")
+    )
+  );
+}
+function encodeBytes32Address(selector, tokenId, address) {
+  return bytesToHex2(
+    concatBytes2(
+      hexToBytes2(selector, "selector"),
+      bytes32(tokenId, "tokenId"),
+      addressWord3(address, "address")
+    )
+  );
+}
+function encodeBytes32AddressUint(selector, tokenId, address, amount) {
+  return bytesToHex2(
+    concatBytes2(
+      hexToBytes2(selector, "selector"),
+      bytes32(tokenId, "tokenId"),
+      addressWord3(address, "address"),
+      uint256Word2(parseUint(amount, "amount"), "amount")
+    )
+  );
+}
+function selectorHex3(signature) {
+  const sel = sha3_js.keccak_256(new TextEncoder().encode(signature)).slice(0, 4);
+  return bytesToHex2(sel);
+}
+function textBytes(value, label, maxBytes) {
+  const bytes = new TextEncoder().encode(value);
+  if (bytes.length === 0 || bytes.length > maxBytes) {
+    throw new TokenFactoryError(`${label} must be 1..=${maxBytes} UTF-8 bytes`);
+  }
+  return bytes;
+}
+function dynamicBytesTail(bytes) {
+  return concatBytes2(uint256Word2(BigInt(bytes.length), "length"), padTo323(bytes));
+}
+function padTo323(bytes) {
+  const padded = Math.ceil(bytes.length / 32) * 32;
+  if (padded === bytes.length) return bytes;
+  const out = new Uint8Array(padded);
+  out.set(bytes);
+  return out;
+}
+function addressWord3(value, label) {
+  const out = new Uint8Array(32);
+  out.set(addressBytes(value, label), 12);
+  return out;
+}
+function addressBytes(value, label) {
+  const bytes = toBytes5(value, label);
+  if (bytes.length !== 20) {
+    throw new TokenFactoryError(`${label} must be 20 bytes, got ${bytes.length}`);
+  }
+  return bytes;
+}
+function bytes32(value, label) {
+  const bytes = toBytes5(value, label);
+  if (bytes.length !== 32) {
+    throw new TokenFactoryError(`${label} must be 32 bytes, got ${bytes.length}`);
+  }
+  return bytes;
+}
+function boolWord(value) {
+  const out = new Uint8Array(32);
+  out[31] = value ? 1 : 0;
+  return out;
+}
+function uint256Word2(value, label) {
+  if (value < 0n || value > (1n << 256n) - 1n) {
+    throw new TokenFactoryError(`${label} out of uint256 range`);
+  }
+  const out = new Uint8Array(32);
+  let rest = value;
+  for (let i = 31; i >= 0 && rest > 0n; i--) {
+    out[i] = Number(rest & 0xffn);
+    rest >>= 8n;
+  }
+  return out;
+}
+function uint64Be(value) {
+  const out = new Uint8Array(8);
+  let rest = value;
+  for (let i = 7; i >= 0; i--) {
+    out[i] = Number(rest & 0xffn);
+    rest >>= 8n;
+  }
+  return out;
+}
+function parseSmallUint(value, label, max) {
+  if (!Number.isInteger(value) || value < 0 || value > max) {
+    throw new TokenFactoryError(`${label} must be an integer in 0..=${max}`);
+  }
+  return value;
+}
+function parseUint(value, label, bits = 256) {
+  let parsed;
+  if (typeof value === "bigint") {
+    parsed = value;
+  } else if (typeof value === "number") {
+    if (!Number.isSafeInteger(value)) throw new TokenFactoryError(`${label} must be a safe integer`);
+    parsed = BigInt(value);
+  } else if (value.startsWith("0x") || value.startsWith("0X")) {
+    parsed = BigInt(value);
+  } else {
+    if (!/^[0-9]+$/.test(value)) throw new TokenFactoryError(`${label} must be a non-negative integer`);
+    parsed = BigInt(value);
+  }
+  if (parsed < 0n || parsed > (1n << BigInt(bits)) - 1n) {
+    throw new TokenFactoryError(`${label} out of uint${bits} range`);
+  }
+  return parsed;
+}
+function toBytes5(value, label) {
+  if (typeof value === "string") return hexToBytes2(value, label);
+  return value instanceof Uint8Array ? value : Uint8Array.from(value);
+}
+
+// src/vrf.ts
+var VrfCallError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "VrfCallError";
+  }
+};
+var VRF_OUTPUT_BYTES = 32;
+var VRF_DOMAIN_TAG_MAX_BYTES = 256;
+var VRF_HEIGHT_NOT_FINALIZED_REVERT = "vrf: height not finalized";
+function vrfAddressHex() {
+  return PRECOMPILE_ADDRESSES.VRF.toLowerCase();
+}
+function encodeVrfEvaluateCalldata(blockHeight, domainTag = new Uint8Array()) {
+  const height = parseUint64(blockHeight, "blockHeight");
+  const tag = normalizeDomainTag(domainTag);
+  if (tag.length > VRF_DOMAIN_TAG_MAX_BYTES) {
+    throw new VrfCallError(`domainTag exceeds ${VRF_DOMAIN_TAG_MAX_BYTES} bytes`);
+  }
+  return bytesToHex2(concatBytes2(uint256Word3(height), tag));
+}
+function decodeVrfOutput(output) {
+  const bytes = toBytes6(output, "output");
+  if (bytes.length !== VRF_OUTPUT_BYTES) {
+    throw new VrfCallError(`VRF output must be ${VRF_OUTPUT_BYTES} bytes, got ${bytes.length}`);
+  }
+  return bytes;
+}
+function normalizeDomainTag(value) {
+  if (typeof value === "string") {
+    if (value.startsWith("0x") || value.startsWith("0X")) return hexToBytes2(value, "domainTag");
+    return new TextEncoder().encode(value);
+  }
+  return value instanceof Uint8Array ? value : Uint8Array.from(value);
+}
+function parseUint64(value, label) {
+  let parsed;
+  if (typeof value === "bigint") {
+    parsed = value;
+  } else if (typeof value === "number") {
+    if (!Number.isSafeInteger(value)) throw new VrfCallError(`${label} must be a safe integer`);
+    parsed = BigInt(value);
+  } else if (value.startsWith("0x") || value.startsWith("0X")) {
+    parsed = BigInt(value);
+  } else {
+    if (!/^[0-9]+$/.test(value)) throw new VrfCallError(`${label} must be a non-negative integer`);
+    parsed = BigInt(value);
+  }
+  if (parsed < 0n || parsed > (1n << 64n) - 1n) {
+    throw new VrfCallError(`${label} out of uint64 range`);
+  }
+  return parsed;
+}
+function uint256Word3(value) {
+  const out = new Uint8Array(32);
+  let rest = value;
+  for (let i = 31; i >= 0 && rest > 0n; i--) {
+    out[i] = Number(rest & 0xffn);
+    rest >>= 8n;
+  }
+  return out;
+}
+function toBytes6(value, label) {
+  if (typeof value === "string") return hexToBytes2(value, label);
+  return value instanceof Uint8Array ? value : Uint8Array.from(value);
+}
 var PROVER_MARKET_ADDRESS = PRECOMPILE_ADDRESSES.PROVER_MARKET;
 var SERVES_GPU_PROVE = 512;
 var PROVER_MARKET_SELECTORS = {
-  createRequest: "0x" + selectorHex3("createRequest(bytes)"),
-  submitBid: "0x" + selectorHex3("submitBid(bytes)"),
-  closeRequest: "0x" + selectorHex3("closeRequest(bytes)"),
-  submitProof: "0x" + selectorHex3("submitProof(bytes)"),
-  settle: "0x" + selectorHex3("settle(bytes)"),
-  slash: "0x" + selectorHex3("slash(bytes)")
+  createRequest: "0x" + selectorHex4("createRequest(bytes)"),
+  submitBid: "0x" + selectorHex4("submitBid(bytes)"),
+  closeRequest: "0x" + selectorHex4("closeRequest(bytes)"),
+  submitProof: "0x" + selectorHex4("submitProof(bytes)"),
+  settle: "0x" + selectorHex4("settle(bytes)"),
+  slash: "0x" + selectorHex4("slash(bytes)")
 };
 var PROVER_MARKET_EVENT_SIGS = {
   proofRequested: "ProofRequested(bytes32,address,bytes32,uint128,uint64)",
@@ -8863,8 +9441,8 @@ function requestSighash(vkeyHash, inputsHash, maxFee, deadline, nonce) {
     sha3_js.keccak_256(
       concatBytes7(
         new TextEncoder().encode(PROVER_MARKET_REQUEST_DOMAIN),
-        expectLength5(toBytes5(vkeyHash), 32, "vkeyHash"),
-        expectLength5(toBytes5(inputsHash), 32, "inputsHash"),
+        expectLength5(toBytes7(vkeyHash), 32, "vkeyHash"),
+        expectLength5(toBytes7(inputsHash), 32, "inputsHash"),
         u128Bytes(maxFee, "maxFee"),
         u64Bytes(deadline, "deadline"),
         u64Bytes(nonce, "nonce")
@@ -8877,7 +9455,7 @@ function bidSighash(requestId, fee) {
     sha3_js.keccak_256(
       concatBytes7(
         new TextEncoder().encode(PROVER_MARKET_BID_DOMAIN),
-        expectLength5(toBytes5(requestId), 32, "requestId"),
+        expectLength5(toBytes7(requestId), 32, "requestId"),
         u128Bytes(fee, "fee")
       )
     )
@@ -8888,16 +9466,16 @@ function submitSighash(requestId, proofHash) {
     sha3_js.keccak_256(
       concatBytes7(
         new TextEncoder().encode(PROVER_MARKET_SUBMIT_DOMAIN),
-        expectLength5(toBytes5(requestId), 32, "requestId"),
-        expectLength5(toBytes5(proofHash), 32, "proofHash")
+        expectLength5(toBytes7(requestId), 32, "requestId"),
+        expectLength5(toBytes7(proofHash), 32, "proofHash")
       )
     )
   );
 }
 function encodeCreateRequestCanonical(args) {
-  const buyer = expectLength5(toBytes5(args.buyer), 20, "buyer");
-  const buyerPubkey = toBytes5(args.buyerPubkey);
-  const sig = toBytes5(args.sig);
+  const buyer = expectLength5(toBytes7(args.buyer), 20, "buyer");
+  const buyerPubkey = toBytes7(args.buyerPubkey);
+  const sig = toBytes7(args.sig);
   if (buyerPubkey.length === 0 || buyerPubkey.length > 65535) {
     throw new ProverMarketError("buyerPubkey length out of range (1..=65535)");
   }
@@ -8909,8 +9487,8 @@ function encodeCreateRequestCanonical(args) {
       buyer,
       u16Bytes(buyerPubkey.length),
       buyerPubkey,
-      expectLength5(toBytes5(args.vkeyHash), 32, "vkeyHash"),
-      expectLength5(toBytes5(args.inputsHash), 32, "inputsHash"),
+      expectLength5(toBytes7(args.vkeyHash), 32, "vkeyHash"),
+      expectLength5(toBytes7(args.inputsHash), 32, "inputsHash"),
       u128Bytes(args.maxFee, "maxFee"),
       u64Bytes(args.deadline, "deadline"),
       u64Bytes(args.nonce, "nonce"),
@@ -8920,7 +9498,7 @@ function encodeCreateRequestCanonical(args) {
   );
 }
 function encodeCreateRequestCalldata(args) {
-  const canonical = toBytes5(encodeCreateRequestCanonical(args));
+  const canonical = toBytes7(encodeCreateRequestCanonical(args));
   const offset = new Uint8Array(32);
   offset[31] = 32;
   const lenWord = new Uint8Array(32);
@@ -8934,10 +9512,10 @@ function encodeCreateRequestCalldata(args) {
     concatBytes7(hexToBytes7(PROVER_MARKET_SELECTORS.createRequest), offset, lenWord, canonical, new Uint8Array(pad))
   );
 }
-function selectorHex3(sig) {
+function selectorHex4(sig) {
   return [...sha3_js.keccak_256(new TextEncoder().encode(sig)).slice(0, 4)].map((b) => b.toString(16).padStart(2, "0")).join("");
 }
-function toBytes5(value) {
+function toBytes7(value) {
   if (typeof value === "string") return hexToBytes7(value);
   return value instanceof Uint8Array ? value : Uint8Array.from(value);
 }
@@ -9075,7 +9653,7 @@ function encodeSetAutoCompoundCalldata(enabled) {
   );
 }
 function isRedemptionPrincipalUnavailableRevert(data) {
-  return bytesToHex9(toBytes6(data)).toLowerCase() === DELEGATION_REVERT_TAGS.redemptionPrincipalUnavailable;
+  return bytesToHex9(toBytes8(data)).toLowerCase() === DELEGATION_REVERT_TAGS.redemptionPrincipalUnavailable;
 }
 function uint64Word3(value, name) {
   const n = toBigint3(value, name);
@@ -9129,7 +9707,7 @@ function toBigint3(value, name) {
   }
   return BigInt(value);
 }
-function toBytes6(value) {
+function toBytes8(value) {
   if (typeof value === "string") {
     return hexToBytes8(value);
   }
@@ -9243,8 +9821,8 @@ function encodeSetPolicyCalldata(args) {
 }
 function encodeSetPolicyClaimCalldata(args, subAccountPubkey, subAccountSig) {
   const normalized = normalizeArgs(args);
-  const pubkey = toBytes7(subAccountPubkey);
-  const sig = toBytes7(subAccountSig);
+  const pubkey = toBytes9(subAccountPubkey);
+  const sig = toBytes9(subAccountSig);
   if (pubkey.length !== ML_DSA_65_PUBLIC_KEY_LEN2) {
     throw new SpendingPolicyError(
       `subAccountPubkey must be ${ML_DSA_65_PUBLIC_KEY_LEN2} bytes, got ${pubkey.length}`
@@ -9266,7 +9844,7 @@ function encodeSetPolicyClaimCalldata(args, subAccountPubkey, subAccountSig) {
 }
 function encodeClaimPolicyByAddressCalldata(args, subAccountSig) {
   const normalized = normalizeArgs(args);
-  const sig = toBytes7(subAccountSig);
+  const sig = toBytes9(subAccountSig);
   if (sig.length !== ML_DSA_65_SIGNATURE_LEN2) {
     throw new SpendingPolicyError(
       `subAccountSig must be ${ML_DSA_65_SIGNATURE_LEN2} bytes, got ${sig.length}`
@@ -9293,12 +9871,12 @@ function normalizeArgs(args) {
     principal: toUserAddressBytes(args.principal, "principal"),
     dailyCapLythoshi: toBigint4(args.dailyCapLythoshi, "dailyCapLythoshi"),
     perTxCapLythoshi: toBigint4(args.perTxCapLythoshi, "perTxCapLythoshi"),
-    allowRoot: expectLength6(toBytes7(args.allowRoot), 32, "allowRoot"),
-    denyRoot: expectLength6(toBytes7(args.denyRoot), 32, "denyRoot"),
+    allowRoot: expectLength6(toBytes9(args.allowRoot), 32, "allowRoot"),
+    denyRoot: expectLength6(toBytes9(args.denyRoot), 32, "denyRoot"),
     weeklyCapLythoshi: toBigint4(args.weeklyCapLythoshi ?? 0n, "weeklyCapLythoshi"),
     monthlyCapLythoshi: toBigint4(args.monthlyCapLythoshi ?? 0n, "monthlyCapLythoshi"),
-    categoryAllowRoot: args.categoryAllowRoot == null ? ZERO_WORD : expectLength6(toBytes7(args.categoryAllowRoot), 32, "categoryAllowRoot"),
-    timeWindow: args.timeWindow == null ? ZERO_WORD : expectLength6(toBytes7(args.timeWindow), 32, "timeWindow"),
+    categoryAllowRoot: args.categoryAllowRoot == null ? ZERO_WORD : expectLength6(toBytes9(args.categoryAllowRoot), 32, "categoryAllowRoot"),
+    timeWindow: args.timeWindow == null ? ZERO_WORD : expectLength6(toBytes9(args.timeWindow), 32, "timeWindow"),
     policyExpiry: toBigint4(args.policyExpiry ?? 0n, "policyExpiry")
   };
 }
@@ -9328,7 +9906,7 @@ function packTimeWindow(enabled, startHour, endHour) {
   return out;
 }
 function decodeTimeWindow(word) {
-  const bytes = expectLength6(toBytes7(word), 32, "timeWindow");
+  const bytes = expectLength6(toBytes9(word), 32, "timeWindow");
   if (bytes.every((b) => b === 0)) return null;
   if (bytes[29] === 0) return null;
   return [Math.min(bytes[30], 23), Math.min(bytes[31], 23)];
@@ -9371,7 +9949,7 @@ function toRawAddressBytes(value) {
   }
   return expectLength6(value instanceof Uint8Array ? value : Uint8Array.from(value), 20, "address");
 }
-function toBytes7(value) {
+function toBytes9(value) {
   if (typeof value === "string") {
     return hexToBytes9(value);
   }
@@ -9453,7 +10031,7 @@ function pubkeyRegistryAddressHex() {
   return PRECOMPILE_ADDRESSES.PUBKEY_REGISTRY.toLowerCase();
 }
 function encodeRegisterPubkeyCalldata(pubkey) {
-  const bytes = toBytes8(pubkey);
+  const bytes = toBytes10(pubkey);
   if (bytes.length !== PUBKEY_REGISTRY_ML_DSA_65_PUBLIC_KEY_LEN) {
     throw new PubkeyRegistryError(
       `pubkey must be ${PUBKEY_REGISTRY_ML_DSA_65_PUBLIC_KEY_LEN} bytes, got ${bytes.length}`
@@ -9462,8 +10040,8 @@ function encodeRegisterPubkeyCalldata(pubkey) {
   return bytesToHex11(
     concatBytes10(
       hexToBytes10(PUBKEY_REGISTRY_SELECTORS.registerPubkey),
-      uint256Word2(32n),
-      uint256Word2(BigInt(bytes.length)),
+      uint256Word4(32n),
+      uint256Word4(BigInt(bytes.length)),
       bytes
     )
   );
@@ -9475,7 +10053,7 @@ function encodeHasPubkeyCalldata(address) {
   return encodeSingleAddressCall2(PUBKEY_REGISTRY_SELECTORS.hasPubkey, address);
 }
 function decodeLookupPubkeyReturn(data) {
-  const bytes = toBytes8(data);
+  const bytes = toBytes10(data);
   if (bytes.length < 96) {
     throw new PubkeyRegistryError("lookup return must be at least 96 bytes");
   }
@@ -9500,7 +10078,7 @@ function decodeLookupPubkeyReturn(data) {
   };
 }
 function decodeHasPubkeyReturn(data) {
-  const bytes = toBytes8(data);
+  const bytes = toBytes10(data);
   if (bytes.length !== 32) {
     throw new PubkeyRegistryError("hasPubkey return must be 32 bytes");
   }
@@ -9514,9 +10092,9 @@ function decodeHasPubkeyReturn(data) {
   throw new PubkeyRegistryError("hasPubkey bool must be 0 or 1");
 }
 function encodeSingleAddressCall2(selector, address) {
-  return bytesToHex11(concatBytes10(hexToBytes10(selector), addressWord3(toAddressBytes(address))));
+  return bytesToHex11(concatBytes10(hexToBytes10(selector), addressWord4(toAddressBytes(address))));
 }
-function addressWord3(address) {
+function addressWord4(address) {
   return concatBytes10(new Uint8Array(12), address);
 }
 function toAddressBytes(value) {
@@ -9533,7 +10111,7 @@ function toAddressBytes(value) {
     throw new PubkeyRegistryError(`address must be a typed mono bech32m address${detail}`);
   }
 }
-function toBytes8(value) {
+function toBytes10(value) {
   if (typeof value === "string") {
     return hexToBytes10(value);
   }
@@ -9562,7 +10140,7 @@ function concatBytes10(...parts) {
   }
   return out;
 }
-function uint256Word2(value) {
+function uint256Word4(value) {
   if (value < 0n || value > (1n << 256n) - 1n) {
     throw new PubkeyRegistryError("uint256 value out of range");
   }
@@ -9710,8 +10288,8 @@ function encodePlaceLimitOrderCalldata(args) {
       normalized.baseTokenId,
       normalized.quoteTokenId,
       uint8Word2(normalized.side),
-      uint256Word3(normalized.price, "price"),
-      uint256Word3(normalized.quantity, "quantity"),
+      uint256Word5(normalized.price, "price"),
+      uint256Word5(normalized.quantity, "quantity"),
       uint64Word4(normalized.expiryBlock, "expiryBlock")
     )
   );
@@ -9724,7 +10302,7 @@ function encodePlaceMarketOrderCalldata(args) {
       normalized.baseTokenId,
       normalized.quoteTokenId,
       uint8Word2(normalized.side),
-      uint256Word3(normalized.quantity, "quantity"),
+      uint256Word5(normalized.quantity, "quantity"),
       uint16Word2(normalized.maxSlippageBps, "maxSlippageBps")
     )
   );
@@ -9737,7 +10315,7 @@ function encodePlaceMarketOrderExCalldata(args) {
       normalized.baseTokenId,
       normalized.quoteTokenId,
       uint8Word2(normalized.side),
-      uint256Word3(normalized.quantity, "quantity"),
+      uint256Word5(normalized.quantity, "quantity"),
       uint16Word2(normalized.maxSlippageBps, "maxSlippageBps"),
       uint8Word2(normalized.mode)
     )
@@ -9757,7 +10335,7 @@ function encodeMarketGridTuneCalldata(selector, label, args) {
       hexToBytes2(selector, `${label} selector`),
       bytes32FromHex(args.baseTokenId, "baseTokenId"),
       bytes32FromHex(args.quoteTokenId, "quoteTokenId"),
-      uint256Word3(BigInt(args.newValue), "newValue")
+      uint256Word5(BigInt(args.newValue), "newValue")
     )
   );
 }
@@ -10045,12 +10623,12 @@ function encodePlaceLimitOrderViaCalldata(args) {
   return bytesToHex2(
     concatBytes2(
       hexToBytes2(OPERATOR_ROUTER_SELECTORS.placeLimitOrderVia, "placeLimitOrderVia selector"),
-      addressWord4(operator.bytes),
+      addressWord5(operator.bytes),
       bytes32FromHex(args.base, "base"),
       bytes32FromHex(args.quote, "quote"),
       uint8Word2(side),
-      uint256Word3(price, "price"),
-      uint256Word3(amount, "amount"),
+      uint256Word5(price, "price"),
+      uint256Word5(amount, "amount"),
       uint64Word4(expiresAtBlock, "expiresAtBlock")
     )
   );
@@ -10362,7 +10940,7 @@ function uint16Word2(value, name) {
   out[31] = Number(value & 0xffn);
   return out;
 }
-function uint256Word3(value, name) {
+function uint256Word5(value, name) {
   if (value < 0n || value >= 1n << 256n) {
     throw new MarketActionError(`${name} must fit uint256`);
   }
@@ -10374,7 +10952,7 @@ function uint256Word3(value, name) {
   }
   return out;
 }
-function addressWord4(addr) {
+function addressWord5(addr) {
   if (addr.length !== 20) {
     throw new MarketActionError("address must be 20 bytes");
   }
@@ -10914,7 +11492,7 @@ var MONOLYTHIUM_NETWORKS = {
 };
 
 // src/index.ts
-var version = "0.4.4";
+var version = "0.4.8";
 
 exports.ADDRESS_HRP = ADDRESS_HRP;
 exports.ADDRESS_KIND_HRPS = ADDRESS_KIND_HRPS;
@@ -10935,6 +11513,7 @@ exports.CLOB_MARKET_ID_DOMAIN_TAG = CLOB_MARKET_ID_DOMAIN_TAG;
 exports.CLOB_SELECTORS = CLOB_SELECTORS;
 exports.CLUSTER_FORMED_EVENT_SIG = CLUSTER_FORMED_EVENT_SIG;
 exports.DEFAULT_CLUSTER_JOIN_EXECUTION_UNIT_LIMIT = DEFAULT_CLUSTER_JOIN_EXECUTION_UNIT_LIMIT;
+exports.DEFAULT_OPERATOR_SEAL_KEY_EXECUTION_UNIT_LIMIT = DEFAULT_OPERATOR_SEAL_KEY_EXECUTION_UNIT_LIMIT;
 exports.DELEGATION_REVERT_TAGS = DELEGATION_REVERT_TAGS;
 exports.DELEGATION_SELECTORS = DELEGATION_SELECTORS;
 exports.DIVERSITY_SCORE_MAX = DIVERSITY_SCORE_MAX;
@@ -11003,6 +11582,9 @@ exports.NODE_REGISTRY_FORM_CLUSTER_MESSAGE_DOMAIN = NODE_REGISTRY_FORM_CLUSTER_M
 exports.NODE_REGISTRY_FORM_CLUSTER_STANDBY_COUNT = NODE_REGISTRY_FORM_CLUSTER_STANDBY_COUNT;
 exports.NODE_REGISTRY_FORM_CLUSTER_THRESHOLD = NODE_REGISTRY_FORM_CLUSTER_THRESHOLD;
 exports.NODE_REGISTRY_LEGACY_CLUSTER_MEMBER_PUBKEY_BYTES = NODE_REGISTRY_LEGACY_CLUSTER_MEMBER_PUBKEY_BYTES;
+exports.NODE_REGISTRY_OPERATOR_ALIAS_MAX_BYTES = NODE_REGISTRY_OPERATOR_ALIAS_MAX_BYTES;
+exports.NODE_REGISTRY_OPERATOR_MONIKER_MAX_BYTES = NODE_REGISTRY_OPERATOR_MONIKER_MAX_BYTES;
+exports.NODE_REGISTRY_OPERATOR_SEAL_EK_BYTES = NODE_REGISTRY_OPERATOR_SEAL_EK_BYTES;
 exports.NODE_REGISTRY_PENDING_CHANGE_MAX_INTENT_ID = NODE_REGISTRY_PENDING_CHANGE_MAX_INTENT_ID;
 exports.NODE_REGISTRY_PUBLIC_SERVICE_MASK = NODE_REGISTRY_PUBLIC_SERVICE_MASK;
 exports.NODE_REGISTRY_SELECTORS = NODE_REGISTRY_SELECTORS;
@@ -11049,9 +11631,24 @@ exports.SPENDING_POLICY_SELECTORS = SPENDING_POLICY_SELECTORS;
 exports.SdkError = SdkError;
 exports.SpendingPolicyError = SpendingPolicyError;
 exports.TESTNET_69420 = TESTNET_69420;
+exports.TOKEN_FACTORY_CREATE_DEPOSIT_LYTHOSHI = TOKEN_FACTORY_CREATE_DEPOSIT_LYTHOSHI;
+exports.TOKEN_FACTORY_FLAGS = TOKEN_FACTORY_FLAGS;
+exports.TOKEN_FACTORY_KNOWN_FLAG_MASK = TOKEN_FACTORY_KNOWN_FLAG_MASK;
+exports.TOKEN_FACTORY_MAX_CREATOR_FEE_BPS = TOKEN_FACTORY_MAX_CREATOR_FEE_BPS;
+exports.TOKEN_FACTORY_MAX_DECIMALS = TOKEN_FACTORY_MAX_DECIMALS;
+exports.TOKEN_FACTORY_NAME_MAX_BYTES = TOKEN_FACTORY_NAME_MAX_BYTES;
+exports.TOKEN_FACTORY_SELECTORS = TOKEN_FACTORY_SELECTORS;
+exports.TOKEN_FACTORY_SIGS = TOKEN_FACTORY_SIGS;
+exports.TOKEN_FACTORY_SYMBOL_MAX_BYTES = TOKEN_FACTORY_SYMBOL_MAX_BYTES;
+exports.TOKEN_FACTORY_TOKEN_ID_DOMAIN_TAG = TOKEN_FACTORY_TOKEN_ID_DOMAIN_TAG;
 exports.TRANSFER_DEFAULT_EXECUTION_UNIT_LIMIT = TRANSFER_DEFAULT_EXECUTION_UNIT_LIMIT;
+exports.TokenFactoryError = TokenFactoryError;
 exports.V1_BRIDGE_ALLOWED_FEE_TOKEN = V1_BRIDGE_ALLOWED_FEE_TOKEN;
 exports.V1_BRIDGE_ALLOWED_PROTOCOL = V1_BRIDGE_ALLOWED_PROTOCOL;
+exports.VRF_DOMAIN_TAG_MAX_BYTES = VRF_DOMAIN_TAG_MAX_BYTES;
+exports.VRF_HEIGHT_NOT_FINALIZED_REVERT = VRF_HEIGHT_NOT_FINALIZED_REVERT;
+exports.VRF_OUTPUT_BYTES = VRF_OUTPUT_BYTES;
+exports.VrfCallError = VrfCallError;
 exports.addressBytesToHex = addressBytesToHex;
 exports.addressToBech32 = addressToBech32;
 exports.addressToTypedBech32 = addressToTypedBech32;
@@ -11120,6 +11717,7 @@ exports.buildPlaceLimitOrderViaPlan = buildPlaceLimitOrderViaPlan;
 exports.buildPlaceSpotLimitOrderPlan = buildPlaceSpotLimitOrderPlan;
 exports.buildPlaceSpotMarketOrderExPlan = buildPlaceSpotMarketOrderExPlan;
 exports.buildPlaceSpotMarketOrderPlan = buildPlaceSpotMarketOrderPlan;
+exports.buildPublishOperatorSealKeyTxFields = buildPublishOperatorSealKeyTxFields;
 exports.buildRequestClusterJoinTxFields = buildRequestClusterJoinTxFields;
 exports.buildVoteClusterAdmitTxFields = buildVoteClusterAdmitTxFields;
 exports.categoryRoot = categoryRoot;
@@ -11150,9 +11748,12 @@ exports.decodeNativeReceiptResponse = decodeNativeReceiptResponse;
 exports.decodeNoEvmReceiptTranscript = decodeNoEvmReceiptTranscript;
 exports.decodeOperatorFeeChargedEvent = decodeOperatorFeeChargedEvent;
 exports.decodeOperatorNetworkMetadata = decodeOperatorNetworkMetadata;
+exports.decodeOperatorSealKey = decodeOperatorSealKey;
 exports.decodeOracleEvent = decodeOracleEvent;
 exports.decodeTimeWindow = decodeTimeWindow;
+exports.decodeTokenFactoryTokenId = decodeTokenFactoryTokenId;
 exports.decodeTxFeedResponse = decodeTxFeedResponse;
+exports.decodeVrfOutput = decodeVrfOutput;
 exports.delegationAddressHex = delegationAddressHex;
 exports.denyRootFor = denyRootFor;
 exports.deriveClobMarketId = deriveClobMarketId;
@@ -11162,6 +11763,7 @@ exports.deriveFeedId = deriveFeedId;
 exports.deriveMrvContractAddress = deriveMrvContractAddress;
 exports.deriveNativeSpotMarketId = deriveNativeSpotMarketId;
 exports.deriveNativeSpotOrderId = deriveNativeSpotOrderId;
+exports.deriveTokenFactoryTokenId = deriveTokenFactoryTokenId;
 exports.destinationRoot = destinationRoot;
 exports.encodeAttestDkgReshareCalldata = encodeAttestDkgReshareCalldata;
 exports.encodeBlockSelector = encodeBlockSelector;
@@ -11173,14 +11775,17 @@ exports.encodeCancelPendingChangeCalldata = encodeCancelPendingChangeCalldata;
 exports.encodeClaimCalldata = encodeClaimCalldata;
 exports.encodeClaimPolicyByAddressCalldata = encodeClaimPolicyByAddressCalldata;
 exports.encodeCompleteRedemptionCalldata = encodeCompleteRedemptionCalldata;
+exports.encodeCreateFixedSupplyMrc20Calldata = encodeCreateFixedSupplyMrc20Calldata;
 exports.encodeCreateRequestCalldata = encodeCreateRequestCalldata;
 exports.encodeCreateRequestCanonical = encodeCreateRequestCanonical;
+exports.encodeCreateTokenCalldata = encodeCreateTokenCalldata;
 exports.encodeDelegateCalldata = encodeDelegateCalldata;
 exports.encodeDisableCalldata = encodeDisableCalldata;
 exports.encodeEnableCalldata = encodeEnableCalldata;
 exports.encodeExpireClusterJoinCalldata = encodeExpireClusterJoinCalldata;
 exports.encodeFormClusterCalldata = encodeFormClusterCalldata;
 exports.encodeGetClusterJoinRequestCalldata = encodeGetClusterJoinRequestCalldata;
+exports.encodeGetOperatorSealKeyCalldata = encodeGetOperatorSealKeyCalldata;
 exports.encodeHasPubkeyCalldata = encodeHasPubkeyCalldata;
 exports.encodeLockBridgeConfigCalldata = encodeLockBridgeConfigCalldata;
 exports.encodeLookupPubkeyCalldata = encodeLookupPubkeyCalldata;
@@ -11237,6 +11842,7 @@ exports.encodePlaceLimitOrderCalldata = encodePlaceLimitOrderCalldata;
 exports.encodePlaceLimitOrderViaCalldata = encodePlaceLimitOrderViaCalldata;
 exports.encodePlaceMarketOrderCalldata = encodePlaceMarketOrderCalldata;
 exports.encodePlaceMarketOrderExCalldata = encodePlaceMarketOrderExCalldata;
+exports.encodePublishOperatorSealKeyCalldata = encodePublishOperatorSealKeyCalldata;
 exports.encodeRecoverOperatorNodeCalldata = encodeRecoverOperatorNodeCalldata;
 exports.encodeRedelegateCalldata = encodeRedelegateCalldata;
 exports.encodeRegisterPubkeyCalldata = encodeRegisterPubkeyCalldata;
@@ -11247,13 +11853,29 @@ exports.encodeSetBridgeResumeCooldownCalldata = encodeSetBridgeResumeCooldownCal
 exports.encodeSetBridgeRouteFinalityCalldata = encodeSetBridgeRouteFinalityCalldata;
 exports.encodeSetLotSizeCalldata = encodeSetLotSizeCalldata;
 exports.encodeSetMinNotionalCalldata = encodeSetMinNotionalCalldata;
+exports.encodeSetOperatorDisplayCalldata = encodeSetOperatorDisplayCalldata;
 exports.encodeSetPolicyCalldata = encodeSetPolicyCalldata;
 exports.encodeSetPolicyClaimCalldata = encodeSetPolicyClaimCalldata;
 exports.encodeSetTickSizeCalldata = encodeSetTickSizeCalldata;
 exports.encodeSubmitBridgeProofCalldata = encodeSubmitBridgeProofCalldata;
 exports.encodeSubmitPendingChangeCalldata = encodeSubmitPendingChangeCalldata;
+exports.encodeTokenFactoryAllowanceCalldata = encodeTokenFactoryAllowanceCalldata;
+exports.encodeTokenFactoryApproveCalldata = encodeTokenFactoryApproveCalldata;
+exports.encodeTokenFactoryBalanceOfCalldata = encodeTokenFactoryBalanceOfCalldata;
+exports.encodeTokenFactoryBurnCalldata = encodeTokenFactoryBurnCalldata;
+exports.encodeTokenFactoryDecreaseAllowanceCalldata = encodeTokenFactoryDecreaseAllowanceCalldata;
+exports.encodeTokenFactoryDestroyCalldata = encodeTokenFactoryDestroyCalldata;
+exports.encodeTokenFactoryIncreaseAllowanceCalldata = encodeTokenFactoryIncreaseAllowanceCalldata;
+exports.encodeTokenFactoryMetadataCalldata = encodeTokenFactoryMetadataCalldata;
+exports.encodeTokenFactoryMintCalldata = encodeTokenFactoryMintCalldata;
+exports.encodeTokenFactorySetPausedCalldata = encodeTokenFactorySetPausedCalldata;
+exports.encodeTokenFactoryTotalSupplyCalldata = encodeTokenFactoryTotalSupplyCalldata;
+exports.encodeTokenFactoryTransferCalldata = encodeTokenFactoryTransferCalldata;
+exports.encodeTokenFactoryTransferFromCalldata = encodeTokenFactoryTransferFromCalldata;
+exports.encodeTokenFactoryTransferOwnershipCalldata = encodeTokenFactoryTransferOwnershipCalldata;
 exports.encodeUndelegateCalldata = encodeUndelegateCalldata;
 exports.encodeVoteClusterAdmitCalldata = encodeVoteClusterAdmitCalldata;
+exports.encodeVrfEvaluateCalldata = encodeVrfEvaluateCalldata;
 exports.exportBridgeRouteCatalogueJson = exportBridgeRouteCatalogueJson;
 exports.fetchChainInfoLatest = fetchChainInfoLatest;
 exports.fetchChainRegistryLatest = fetchChainRegistryLatest;
@@ -11339,9 +11961,11 @@ exports.spendingPolicyAddressHex = spendingPolicyAddressHex;
 exports.submitMrvCallNativeTx = submitMrvCallNativeTx;
 exports.submitMrvDeployNativeTx = submitMrvDeployNativeTx;
 exports.submitMrvDeployPayloadNativeTx = submitMrvDeployPayloadNativeTx;
+exports.submitPublishOperatorSealKey = submitPublishOperatorSealKey;
 exports.submitRequestClusterJoin = submitRequestClusterJoin;
 exports.submitSighash = submitSighash;
 exports.submitVoteClusterAdmit = submitVoteClusterAdmit;
+exports.tokenFactoryAddressHex = tokenFactoryAddressHex;
 exports.transactionFeeExposure = transactionFeeExposure;
 exports.typedBech32ToAddress = typedBech32ToAddress;
 exports.validateAddress = validateAddress;
@@ -11349,6 +11973,7 @@ exports.validateBridgeRouteCatalogue = validateBridgeRouteCatalogue;
 exports.validateMrvArtifactMetadata = validateMrvArtifactMetadata;
 exports.validateMrvCallRequest = validateMrvCallRequest;
 exports.validateMrvDeployRequest = validateMrvDeployRequest;
+exports.validateTokenFactoryFlags = validateTokenFactoryFlags;
 exports.verifyNoEvmArchiveProofSignatures = verifyNoEvmArchiveProofSignatures;
 exports.verifyNoEvmBlockFinalityEvidenceMultisig = verifyNoEvmBlockFinalityEvidenceMultisig;
 exports.verifyNoEvmBlockFinalityEvidenceThreshold = verifyNoEvmBlockFinalityEvidenceThreshold;
@@ -11357,5 +11982,6 @@ exports.verifyNoEvmFinalityEvidenceThreshold = verifyNoEvmFinalityEvidenceThresh
 exports.verifyNoEvmReceiptProof = verifyNoEvmReceiptProof;
 exports.verifyNoEvmReceiptProofTrust = verifyNoEvmReceiptProofTrust;
 exports.version = version;
+exports.vrfAddressHex = vrfAddressHex;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map