@polkadot-api/forklift 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,64 @@
+import { JsonRpcProvider } from '@polkadot-api/substrate-client';
+import { HexString, Enum } from 'polkadot-api';
+import pino from 'pino';
+
+interface CreateBlockParams {
+    parent: HexString;
+    unsafeBlockHeight?: number;
+    transactions: Uint8Array[];
+    xcm: XcmMessages;
+    storage: Record<HexString, Uint8Array | null>;
+    disableOnIdle: boolean;
+}
+interface DmpMessage {
+    sent_at: number;
+    msg: Uint8Array<ArrayBufferLike>;
+}
+interface XcmMessages {
+    dmp: Array<DmpMessage>;
+    hrmp: Record<number, Uint8Array[]>;
+}
+
+interface NewBlockOptions {
+    type: "best" | "finalized" | "fork";
+    unsafeBlockHeight?: number;
+    parent: HexString;
+    disableOnIdle: boolean;
+    storage: CreateBlockParams["storage"];
+}
+interface Forklift {
+    serve: JsonRpcProvider;
+    newBlock: (opts?: Partial<NewBlockOptions>) => Promise<HexString>;
+    changeBest: (hash: HexString) => Promise<void>;
+    changeFinalized: (hash: HexString) => Promise<void>;
+    setStorage: (hash: HexString, changes: Record<string, Uint8Array>) => Promise<void>;
+    getStorageDiff: (hash: HexString, baseHash?: HexString) => Promise<Record<string, {
+        value: Uint8Array | null;
+        prev?: Uint8Array | null;
+    }>>;
+    changeOptions: (options: Partial<ForkliftOptions>) => void;
+    destroy: () => void;
+}
+type ForkliftSource = Enum<{
+    remote: {
+        url: string | string[];
+        atBlock?: number | string;
+    };
+}>;
+type DelayMode = Enum<{
+    manual: undefined;
+    timer: number;
+}>;
+interface ForkliftOptions {
+    buildBlockMode: DelayMode;
+    finalizeMode: DelayMode;
+    disableOnIdle?: boolean;
+    mockSignatureHost?: (signature: Uint8Array) => boolean;
+    key?: string;
+}
+declare function forklift(sourceDef: ForkliftSource, opts?: Partial<ForkliftOptions>): Forklift;
+
+declare const logger: pino.Logger<never, boolean>;
+
+export { forklift, logger };
+export type { Forklift };

package/dist/src/block-builder/create-block.js

@@ -0,0 +1,232 @@
+import { Struct, u64, u32, Bytes, Variant, _void, blockHeader, Blake2256 } from '@polkadot-api/substrate-bindings';
+import { Binary, Enum } from 'polkadot-api';
+import { getStorageCodecs, getConstant } from '../codecs.js';
+import { getRuntimeVersion, runRuntimeCall } from '../executor.js';
+import { logger } from '../logger.js';
+import { insertValue, deleteValue, getNode } from '../storage.js';
+import { paraInherentEnterInherent } from './para-enter.js';
+import { setValidationDataInherent } from './set-validation-data.js';
+import { getCurrentSlot } from './slot-utils.js';
+import { timestampInherent } from './timestamp.js';
+
+const log = logger.child({ module: "block-builder" });
+const CODE_KEY = "0x3a636f6465";
+const createBlock = async (chain, params) => {
+  const parentHash = params.parent;
+  const parent = chain.getBlock(parentHash);
+  if (!parent) throw new Error("Block not found");
+  const height = params.unsafeBlockHeight ?? parent.header.number + 1;
+  const extrinsics = [
+    await timestampInherent(chain, parent),
+    await setValidationDataInherent(chain, parent, params.xcm),
+    await paraInherentEnterInherent(chain, parent),
+    ...params.transactions
+  ].filter((v) => v !== null);
+  const storageOverrides = Object.fromEntries(
+    Object.entries(params.storage).map(([key, value]) => [
+      key,
+      value == null ? null : Binary.toHex(value)
+    ])
+  );
+  const result = await buildBlock(
+    chain,
+    height,
+    parent,
+    extrinsics,
+    storageOverrides,
+    params.disableOnIdle
+  );
+  const encodedFinalHeader = Binary.fromHex(result.header);
+  const finalHeader = blockHeader.dec(encodedFinalHeader);
+  const blockHash = Binary.toHex(Blake2256(encodedFinalHeader));
+  let newStorageRoot = parent.storageRoot;
+  for (const key in result.storageDiff) {
+    const binKey = Binary.fromHex(key);
+    const value = result.storageDiff[key];
+    if (value != null) {
+      newStorageRoot = insertValue(
+        newStorageRoot,
+        binKey,
+        binKey.length * 2,
+        typeof value === "string" ? Binary.fromHex(value) : value
+      );
+    } else {
+      newStorageRoot = deleteValue(newStorageRoot, binKey, binKey.length * 2);
+    }
+  }
+  const codeNode = getNode(
+    newStorageRoot,
+    Binary.fromHex(CODE_KEY),
+    CODE_KEY.length - 2
+  );
+  if (!codeNode?.value) {
+    throw new Error("Unexpected: new block doesn't have code");
+  }
+  const code = codeNode.value;
+  const hasNewRuntime = CODE_KEY in result.storageDiff;
+  const runtime = hasNewRuntime ? await getRuntimeVersion(code) : parent.runtime;
+  const block = {
+    hash: blockHash,
+    parent: parentHash,
+    code,
+    storageRoot: newStorageRoot,
+    header: finalHeader,
+    runtime,
+    body: result.body,
+    hasNewRuntime: hasNewRuntime || void 0,
+    children: []
+  };
+  parent.children.push(blockHash);
+  return block;
+};
+const buildBlock = async (chain, height, parent, extrinsics, storageOverrides, disableIdleHook) => {
+  const parentHash = parent.hash;
+  const digests = await buildNextDigests(chain, parent);
+  const provisionalHeader = {
+    parentHash,
+    number: height,
+    stateRoot: "0x0000000000000000000000000000000000000000000000000000000000000000",
+    extrinsicRoot: "0x0000000000000000000000000000000000000000000000000000000000000000",
+    digests
+  };
+  const systemNumberCodec = await getStorageCodecs(parent, "System", "Number");
+  if (systemNumberCodec) {
+    storageOverrides = {
+      [systemNumberCodec.keys.enc()]: Binary.toHex(
+        systemNumberCodec.value.enc(height - 1)
+      )
+    };
+  }
+  log.debug("initialise block");
+  const initResponse = await runRuntimeCall({
+    chain,
+    hash: parentHash,
+    call: "Core_initialize_block",
+    params: Binary.toHex(blockHeader.enc(provisionalHeader)),
+    storageOverrides
+  });
+  storageOverrides = {
+    ...storageOverrides,
+    ...Object.fromEntries(initResponse.storageDiff)
+  };
+  const body = [];
+  for (const extrinsic of extrinsics) {
+    try {
+      log.debug("apply extrinsic");
+      const applyResponse = await runRuntimeCall({
+        chain,
+        hash: parentHash,
+        call: "BlockBuilder_apply_extrinsic",
+        params: Binary.toHex(extrinsic),
+        storageOverrides,
+        // Enable mock signature verification to bypass relay chain header seal verification
+        mockSignatureHost: true
+      });
+      body.push(extrinsic);
+      storageOverrides = {
+        ...storageOverrides,
+        ...Object.fromEntries(applyResponse.storageDiff)
+      };
+    } catch (ex) {
+      log.error(ex, "failed to apply extrinsic");
+    }
+  }
+  log.debug("finalize block");
+  let originalWeight;
+  if (disableIdleHook) {
+    try {
+      const blockWeights = await getConstant(parent, "System", "BlockWeights");
+      const blockWeightCodecs = await getStorageCodecs(
+        parent,
+        "System",
+        "BlockWeight"
+      );
+      if (!blockWeightCodecs) throw null;
+      const key = blockWeightCodecs.keys.enc();
+      const value = blockWeightCodecs.value.enc({
+        normal: blockWeights.max_block,
+        operational: blockWeights.max_block,
+        mandatory: blockWeights.max_block
+      });
+      originalWeight = storageOverrides[key] ? {
+        key,
+        value: storageOverrides[key]
+      } : void 0;
+      storageOverrides[key] = Binary.toHex(value);
+    } catch {
+    }
+  }
+  const finalizeResponse = await runRuntimeCall({
+    chain,
+    hash: parentHash,
+    call: "BlockBuilder_finalize_block",
+    params: "0x",
+    storageOverrides
+  });
+  if (originalWeight) {
+    storageOverrides[originalWeight.key] = originalWeight.value;
+  }
+  storageOverrides = {
+    ...storageOverrides,
+    ...Object.fromEntries(finalizeResponse.storageDiff)
+  };
+  return {
+    header: finalizeResponse.result,
+    body,
+    storageDiff: storageOverrides
+  };
+};
+const buildNextDigests = async (chain, parent) => {
+  const currentSlot = await getCurrentSlot(chain, parent);
+  const nextSlot = currentSlot + 1n;
+  const nextSlotPayload = Binary.toHex(u64.enc(nextSlot));
+  if (parent.header.digests.length === 0) {
+    return [Enum("preRuntime", { engine: "aura", payload: nextSlotPayload })];
+  }
+  return parent.header.digests.map((digest) => {
+    if (digest.type !== "preRuntime") return digest;
+    if (digest.value.engine === "aura") {
+      return Enum("preRuntime", {
+        engine: "aura",
+        payload: nextSlotPayload
+      });
+    }
+    if (digest.value.engine === "BABE" || digest.value.engine === "babe") {
+      const preDigest = BabePreDigest.dec(digest.value.payload);
+      if (preDigest.type === "Unknown") return digest;
+      return Enum("preRuntime", {
+        engine: digest.value.engine,
+        payload: Binary.toHex(
+          BabePreDigest.enc({
+            ...preDigest,
+            value: {
+              ...preDigest.value,
+              slot: nextSlot
+            }
+          })
+        )
+      });
+    }
+    return digest;
+  });
+};
+const DigestWithVRF = Struct({
+  authority_index: u32,
+  slot: u64,
+  vrf_signature: Struct({
+    pre_output: Bytes(32),
+    proof: Bytes(64)
+  })
+});
+const BabePreDigest = Variant({
+  Unknown: _void,
+  Primary: DigestWithVRF,
+  SecondaryPlain: Struct({
+    authority_index: u32,
+    slot: u64
+  }),
+  SecondaryVRF: DigestWithVRF
+});
+
+export { createBlock };
+//# sourceMappingURL=create-block.js.map

package/dist/src/block-builder/create-block.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-block.js","sources":["../../../src/block-builder/create-block.ts"],"sourcesContent":["import {\n  _void,\n  Blake2256,\n  blockHeader,\n  Bytes,\n  Struct,\n  u32,\n  u64,\n  Variant,\n} from \"@polkadot-api/substrate-bindings\";\nimport { Binary, Enum, type BlockHeader, type HexString } from \"polkadot-api\";\nimport type { Chain } from \"../chain\";\nimport { getConstant, getStorageCodecs } from \"../codecs\";\nimport {\n  getRuntimeVersion,\n  runRuntimeCall,\n  type RuntimeVersion,\n} from \"../executor\";\nimport { logger } from \"../logger\";\nimport {\n  deleteValue,\n  getNode,\n  insertValue,\n  type StorageNode,\n} from \"../storage\";\nimport { paraInherentEnterInherent } from \"./para-enter\";\nimport { setValidationDataInherent } from \"./set-validation-data\";\nimport { getCurrentSlot } from \"./slot-utils\";\nimport { timestampInherent } from \"./timestamp\";\n\nconst log = logger.child({ module: \"block-builder\" });\n\nexport interface CreateBlockParams {\n  parent: HexString;\n  unsafeBlockHeight?: number;\n  transactions: Uint8Array[];\n  xcm: XcmMessages;\n  storage: Record<HexString, Uint8Array | null>;\n  disableOnIdle: boolean;\n}\n\nexport interface Block {\n  hash: HexString;\n  parent: HexString;\n  code: Uint8Array;\n  storageRoot: StorageNode;\n  header: BlockHeader;\n  runtime: RuntimeVersion;\n  body: Uint8Array[];\n  hasNewRuntime?: boolean;\n  children: HexString[];\n}\n\nexport interface DmpMessage {\n  sent_at: number;\n  msg: Uint8Array<ArrayBufferLike>;\n}\n\nexport interface XcmMessages {\n  dmp: Array<DmpMessage>;\n  hrmp: Record<number, Uint8Array[]>;\n}\n\nconst CODE_KEY: HexString = \"0x3a636f6465\"; // hex-encoded \":code\"\n\nexport const createBlock = async (\n  chain: Chain,\n  params: CreateBlockParams\n): Promise<Block> => {\n  // Determine parent block\n  const parentHash = params.parent;\n  const parent = chain.getBlock(parentHash);\n  if (!parent) throw new Error(\"Block not found\");\n\n  // Create header template for Core_initialize_block\n  const height = params.unsafeBlockHeight ?? parent.header.number + 1;\n\n  const extrinsics = [\n    await timestampInherent(chain, parent),\n    await setValidationDataInherent(chain, parent, params.xcm),\n    await paraInherentEnterInherent(chain, parent),\n    ...params.transactions,\n  ].filter((v) => v !== null);\n\n  const storageOverrides = Object.fromEntries(\n    Object.entries(params.storage).map(([key, value]) => [\n      key,\n      value == null ? null : Binary.toHex(value),\n    ])\n  );\n\n  const result = await buildBlock(\n    chain,\n    height,\n    parent,\n    extrinsics,\n    storageOverrides,\n    params.disableOnIdle\n  );\n\n  // Decode the final header from runtime\n  const encodedFinalHeader = Binary.fromHex(result.header);\n  const finalHeader = blockHeader.dec(encodedFinalHeader);\n\n  // Compute block hash (Blake2-256 of encoded header)\n  const blockHash = Binary.toHex(Blake2256(encodedFinalHeader)) as HexString;\n\n  // Create new storage root from parent's, applying the diff\n  let newStorageRoot = parent.storageRoot;\n  for (const key in result.storageDiff) {\n    const binKey = Binary.fromHex(key as HexString);\n    const value = result.storageDiff[key];\n\n    if (value != null) {\n      newStorageRoot = insertValue(\n        newStorageRoot,\n        binKey,\n        binKey.length * 2,\n        typeof value === \"string\" ? Binary.fromHex(value) : value\n      );\n    } else {\n      newStorageRoot = deleteValue(newStorageRoot, binKey, binKey.length * 2);\n    }\n  }\n\n  // Check if runtime code changed\n  const codeNode = getNode(\n    newStorageRoot,\n    Binary.fromHex(CODE_KEY),\n    CODE_KEY.length - 2\n  );\n  if (!codeNode?.value) {\n    throw new Error(\"Unexpected: new block doesn't have code\");\n  }\n  const code = codeNode.value;\n\n  const hasNewRuntime = CODE_KEY in result.storageDiff;\n  const runtime = hasNewRuntime\n    ? await getRuntimeVersion(code)\n    : parent.runtime;\n\n  // Create the new block\n  const block: Block = {\n    hash: blockHash,\n    parent: parentHash,\n    code,\n    storageRoot: newStorageRoot,\n    header: finalHeader,\n    runtime,\n    body: result.body,\n    hasNewRuntime: hasNewRuntime || undefined,\n    children: [],\n  };\n\n  // Update parent's children\n  parent.children.push(blockHash);\n\n  return block;\n};\n\nconst buildBlock = async (\n  chain: Chain,\n  height: number,\n  parent: Block,\n  extrinsics: Uint8Array[],\n  storageOverrides: Record<HexString, HexString | null>,\n  disableIdleHook?: boolean\n) => {\n  const parentHash = parent.hash;\n  const digests = await buildNextDigests(chain, parent);\n\n  const provisionalHeader: BlockHeader = {\n    parentHash,\n    number: height,\n    stateRoot:\n      \"0x0000000000000000000000000000000000000000000000000000000000000000\",\n    extrinsicRoot:\n      \"0x0000000000000000000000000000000000000000000000000000000000000000\",\n    digests,\n  };\n\n  // Override height of parent to support unsafeBlockHeight\n  const systemNumberCodec = await getStorageCodecs(parent, \"System\", \"Number\");\n  if (systemNumberCodec) {\n    storageOverrides = {\n      [systemNumberCodec.keys.enc()]: Binary.toHex(\n        systemNumberCodec.value.enc(height - 1)\n      ),\n    };\n  }\n\n  log.debug(\"initialise block\");\n  // Call Core_initialize_block\n  const initResponse = await runRuntimeCall({\n    chain,\n    hash: parentHash,\n    call: \"Core_initialize_block\",\n    params: Binary.toHex(blockHeader.enc(provisionalHeader)),\n    storageOverrides,\n  });\n\n  // console.log(\"init storageDiff\", Object.fromEntries(initResponse.storageDiff));\n\n  // Apply storage changes\n  storageOverrides = {\n    ...storageOverrides,\n    ...Object.fromEntries(initResponse.storageDiff),\n  };\n\n  const body: Uint8Array[] = [];\n  for (const extrinsic of extrinsics) {\n    try {\n      log.debug(\"apply extrinsic\");\n      const applyResponse = await runRuntimeCall({\n        chain,\n        hash: parentHash,\n        call: \"BlockBuilder_apply_extrinsic\",\n        params: Binary.toHex(extrinsic),\n        storageOverrides,\n        // Enable mock signature verification to bypass relay chain header seal verification\n        mockSignatureHost: true,\n      });\n      body.push(extrinsic);\n\n      // console.log(Object.fromEntries(applyResponse.storageDiff));\n\n      storageOverrides = {\n        ...storageOverrides,\n        ...Object.fromEntries(applyResponse.storageDiff),\n      };\n    } catch (ex) {\n      log.error(ex, \"failed to apply extrinsic\");\n    }\n  }\n\n  log.debug(\"finalize block\");\n  let originalWeight:\n    | {\n        key: HexString;\n        value: HexString;\n      }\n    | undefined;\n\n  if (disableIdleHook) {\n    // on_idle hook only triggers if either:\n    //  - no migrations are happenning\n    //  - no remaining block weight\n    // Here it mocks blockWeight to maxWeight before finalizing to disable idle hook\n    // which performs tasks like rebagging that slow down block production, since\n    // it performs serial storage requests.\n    try {\n      const blockWeights = await getConstant(parent, \"System\", \"BlockWeights\");\n      const blockWeightCodecs = await getStorageCodecs(\n        parent,\n        \"System\",\n        \"BlockWeight\"\n      );\n      if (!blockWeightCodecs) throw null;\n      const key = blockWeightCodecs.keys.enc();\n      const value = blockWeightCodecs.value.enc({\n        normal: blockWeights.max_block,\n        operational: blockWeights.max_block,\n        mandatory: blockWeights.max_block,\n      });\n      originalWeight = storageOverrides[key]\n        ? {\n            key,\n            value: storageOverrides[key],\n          }\n        : undefined;\n      storageOverrides[key] = Binary.toHex(value);\n    } catch {}\n  }\n  const finalizeResponse = await runRuntimeCall({\n    chain,\n    hash: parentHash,\n    call: \"BlockBuilder_finalize_block\",\n    params: \"0x\",\n    storageOverrides,\n  });\n  if (originalWeight) {\n    storageOverrides[originalWeight.key] = originalWeight.value;\n  }\n\n  // Apply finalize storage changes\n  storageOverrides = {\n    ...storageOverrides,\n    ...Object.fromEntries(finalizeResponse.storageDiff),\n  };\n\n  return {\n    header: finalizeResponse.result,\n    body,\n    storageDiff: storageOverrides,\n  };\n};\n\nconst buildNextDigests = async (chain: Chain, parent: Block) => {\n  const currentSlot = await getCurrentSlot(chain, parent);\n  const nextSlot = currentSlot + 1n;\n  const nextSlotPayload = Binary.toHex(u64.enc(nextSlot));\n\n  if (parent.header.digests.length === 0) {\n    return [Enum(\"preRuntime\", { engine: \"aura\", payload: nextSlotPayload })];\n  }\n\n  return parent.header.digests.map((digest) => {\n    if (digest.type !== \"preRuntime\") return digest;\n    if (digest.value.engine === \"aura\") {\n      return Enum(\"preRuntime\", {\n        engine: \"aura\",\n        payload: nextSlotPayload,\n      });\n    }\n    if (digest.value.engine === \"BABE\" || digest.value.engine === \"babe\") {\n      const preDigest = BabePreDigest.dec(digest.value.payload);\n      if (preDigest.type === \"Unknown\") return digest;\n\n      return Enum(\"preRuntime\", {\n        engine: digest.value.engine,\n        payload: Binary.toHex(\n          BabePreDigest.enc({\n            ...preDigest,\n            value: {\n              ...(preDigest.value as any),\n              slot: nextSlot,\n            },\n          })\n        ),\n      });\n    }\n\n    return digest;\n  });\n};\n\nconst DigestWithVRF = Struct({\n  authority_index: u32,\n  slot: u64,\n  vrf_signature: Struct({\n    pre_output: Bytes(32),\n    proof: Bytes(64),\n  }),\n});\nconst BabePreDigest = Variant({\n  Unknown: _void,\n  Primary: DigestWithVRF,\n  SecondaryPlain: Struct({\n    authority_index: u32,\n    slot: u64,\n  }),\n  SecondaryVRF: DigestWithVRF,\n});\n"],"names":[],"mappings":"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"}

package/dist/src/block-builder/para-enter.js

@@ -0,0 +1,21 @@
+import { blockHeader } from '@polkadot-api/substrate-bindings';
+import { getCallData, unsignedExtrinsic } from '../codecs.js';
+import { runtimeBlockHeader } from './slot-utils.js';
+
+const paraInherentEnterInherent = async (_chain, parentBlock) => {
+  const parent_header = runtimeBlockHeader.dec(
+    blockHeader.enc(parentBlock.header)
+  );
+  const callData = await getCallData(parentBlock, "ParaInherent", "enter", {
+    data: {
+      bitfields: [],
+      backed_candidates: [],
+      disputes: [],
+      parent_header
+    }
+  });
+  return callData ? unsignedExtrinsic(callData) : null;
+};
+
+export { paraInherentEnterInherent };
+//# sourceMappingURL=para-enter.js.map

package/dist/src/block-builder/para-enter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"para-enter.js","sources":["../../../src/block-builder/para-enter.ts"],"sourcesContent":["import { blockHeader } from \"@polkadot-api/substrate-bindings\";\nimport type { Chain } from \"../chain\";\nimport { getCallData, unsignedExtrinsic } from \"../codecs\";\nimport type { Block } from \"./create-block\";\nimport { runtimeBlockHeader } from \"./slot-utils\";\n\nexport const paraInherentEnterInherent = async (\n  _chain: Chain,\n  parentBlock: Block\n) => {\n  const parent_header = runtimeBlockHeader.dec(\n    blockHeader.enc(parentBlock.header)\n  );\n\n  const callData = await getCallData(parentBlock, \"ParaInherent\", \"enter\", {\n    data: {\n      bitfields: [],\n      backed_candidates: [],\n      disputes: [],\n      parent_header,\n    },\n  });\n  return callData ? unsignedExtrinsic(callData) : null;\n};\n"],"names":[],"mappings":";;;;AAMO,MAAM,yBAAA,GAA4B,OACvC,MAAA,EACA,WAAA,KACG;AACH,EAAA,MAAM,gBAAgB,kBAAA,CAAmB,GAAA;AAAA,IACvC,WAAA,CAAY,GAAA,CAAI,WAAA,CAAY,MAAM;AAAA,GACpC;AAEA,EAAA,MAAM,QAAA,GAAW,MAAM,WAAA,CAAY,WAAA,EAAa,gBAAgB,OAAA,EAAS;AAAA,IACvE,IAAA,EAAM;AAAA,MACJ,WAAW,EAAC;AAAA,MACZ,mBAAmB,EAAC;AAAA,MACpB,UAAU,EAAC;AAAA,MACX;AAAA;AACF,GACD,CAAA;AACD,EAAA,OAAO,QAAA,GAAW,iBAAA,CAAkB,QAAQ,CAAA,GAAI,IAAA;AAClD;;;;"}

package/dist/src/block-builder/set-validation-data.js

@@ -0,0 +1,284 @@
+import { decode_proof, create_proof } from '@acala-network/chopsticks-executor';
+import { Struct, u32, Bytes, Vector, Option, Twox128, blockHeader, u64, Blake2256, compact, Twox64Concat } from '@polkadot-api/substrate-bindings';
+import { Binary } from 'polkadot-api';
+import { mergeUint8 } from 'polkadot-api/utils';
+import { getTxCodec, getExtrinsicDecoder, getConstant, getCallData, unsignedExtrinsic } from '../codecs.js';
+import { getSlotDuration, getCurrentSlot, runtimeBlockHeader } from './slot-utils.js';
+
+const textEncoder = new TextEncoder();
+const RELAY_CHAIN_SLOT_DURATION_MILLIS = 6000n;
+const storagePrefix = (pallet, storage) => Binary.toHex(
+  mergeUint8([
+    Twox128(textEncoder.encode(pallet)),
+    Twox128(textEncoder.encode(storage))
+  ])
+);
+const DMP_QUEUE_HEADS_KEY = storagePrefix("Dmp", "DownwardMessageQueueHeads");
+const HRMP_INGRESS_INDEX_KEY = storagePrefix(
+  "Hrmp",
+  "HrmpIngressChannelsIndex"
+);
+const HRMP_EGRESS_INDEX_KEY = storagePrefix("Hrmp", "HrmpEgressChannelsIndex");
+const HRMP_CHANNELS_KEY = storagePrefix("Hrmp", "HrmpChannels");
+const appendParaId = (key, paraId) => Binary.toHex(
+  mergeUint8([Binary.fromHex(key), Twox64Concat(u32.enc(paraId))])
+);
+const hrmpIngressIndexKey = (receiverParaId) => appendParaId(HRMP_INGRESS_INDEX_KEY, receiverParaId);
+const hrmpEgressIndexKey = (senderParaId) => appendParaId(HRMP_EGRESS_INDEX_KEY, senderParaId);
+const hrmpChannelKey = (sender, receiver) => Binary.toHex(
+  mergeUint8([
+    Binary.fromHex(HRMP_CHANNELS_KEY),
+    Twox64Concat(mergeUint8([u32.enc(sender), u32.enc(receiver)]))
+  ])
+);
+const DEFAULT_CHANNEL = {
+  max_capacity: 1e3,
+  max_total_size: 102400,
+  max_message_size: 102400,
+  msg_count: 0,
+  total_size: 0,
+  mqc_head: void 0
+};
+const BABE_CURRENT_SLOT_KEY = storagePrefix("Babe", "CurrentSlot");
+const PRESERVE_PROOFS = [
+  storagePrefix("Babe", "EpochIndex"),
+  storagePrefix("Babe", "CurrentBlockRandomness"),
+  storagePrefix("Babe", "Randomness"),
+  storagePrefix("Babe", "NextRandomness"),
+  BABE_CURRENT_SLOT_KEY,
+  storagePrefix("Configuration", "ActiveConfig"),
+  storagePrefix("Babe", "Authorities")
+];
+const PARAS_HEADS_PREFIX = Binary.fromHex(storagePrefix("Paras", "Heads"));
+const paraHeadKey = (paraId) => {
+  const paraIdBytes = u32.enc(paraId);
+  return mergeUint8([PARAS_HEADS_PREFIX, Twox64Concat(paraIdBytes)]);
+};
+const encodeHeadData = (header) => {
+  return mergeUint8([compact.enc(header.length), header]);
+};
+const setValidationDataInherent = async (chain, parentBlock, xcm) => {
+  if (!parentBlock.header.digests.some(
+    (d) => d.type === "preRuntime" && d.value.engine === "aura"
+  ))
+    return null;
+  const txCodec = getTxCodec(
+    parentBlock,
+    "ParachainSystem",
+    "set_validation_data"
+  );
+  if (!txCodec) return null;
+  const txDec = await getExtrinsicDecoder(parentBlock);
+  const prevValidationDataRaw = parentBlock.body.find((raw) => {
+    const ext = txDec(raw);
+    return ext.call.type === "ParachainSystem" && ext.call.value.type === "set_validation_data";
+  });
+  const prevValidationDataExt = prevValidationDataRaw && txDec(prevValidationDataRaw);
+  const prevValidationData = prevValidationDataExt?.call.value.value.data;
+  if (!prevValidationData) {
+    throw new Error("TODO no prevValidationData in previous block");
+  }
+  const paraId = await getConstant(
+    parentBlock,
+    "ParachainSystem",
+    "SelfParaId"
+  );
+  if (paraId == null) {
+    throw new Error("Could not get parachain ID");
+  }
+  const encodedParentHeader = blockHeader.enc(parentBlock.header);
+  const headData = encodeHeadData(encodedParentHeader);
+  const storageKey = paraHeadKey(paraId);
+  const existingNodes = prevValidationData.relay_chain_state.map((node) => Binary.toHex(node));
+  const existingStateRoot = prevValidationData.validation_data.relay_parent_storage_root;
+  const decodedProofArray = await decode_proof(
+    existingStateRoot,
+    existingNodes
+  );
+  const decodedProof = new Map(decodedProofArray);
+  const slotDuration = await getSlotDuration(chain, parentBlock);
+  const relaySlotIncreaseRaw = slotDuration / RELAY_CHAIN_SLOT_DURATION_MILLIS;
+  const relaySlotIncrease = relaySlotIncreaseRaw > 0n ? relaySlotIncreaseRaw : 1n;
+  const relayCurrentSlot = await (async () => {
+    const currentSlotHex = decodedProof.get(BABE_CURRENT_SLOT_KEY);
+    if (typeof currentSlotHex === "string") {
+      return u64.dec(Binary.fromHex(currentSlotHex));
+    }
+    const currentSlot = await getCurrentSlot(chain, parentBlock);
+    return currentSlot * relaySlotIncrease;
+  })();
+  const nextRelayChainSlot = Binary.toHex(
+    u64.enc(relayCurrentSlot + relaySlotIncrease)
+  );
+  const newEntries = [];
+  for (const key of PRESERVE_PROOFS) {
+    if (decodedProof.has(key)) {
+      const value = key === BABE_CURRENT_SLOT_KEY && nextRelayChainSlot ? nextRelayChainSlot : decodedProof.get(key) ?? null;
+      newEntries.push([key, value]);
+    }
+  }
+  newEntries.push([
+    Binary.toHex(storageKey),
+    Binary.toHex(headData)
+  ]);
+  const dmpHashKey = appendParaId(DMP_QUEUE_HEADS_KEY, paraId);
+  let dmpHash = Binary.fromHex(
+    decodedProof.get(dmpHashKey) ?? "0x0000000000000000000000000000000000000000000000000000000000000000"
+  );
+  for (const { msg, sent_at } of xcm.dmp) {
+    dmpHash = Blake2256(
+      mqcChain.enc({
+        hash: dmpHash,
+        sent_at,
+        msg_hash: Blake2256(Binary.toOpaque(msg))
+      })
+    );
+  }
+  newEntries.push([dmpHashKey, Binary.toHex(dmpHash)]);
+  const egressIndexHex = decodedProof.get(hrmpEgressIndexKey(paraId));
+  const existingEgressRecipients = egressIndexHex ? vecU32.dec(Binary.fromHex(egressIndexHex)) : [];
+  const allEgressRecipients = [
+    .../* @__PURE__ */ new Set([...existingEgressRecipients, ...chain.hrmpChannels])
+  ].sort((a, b) => a - b);
+  if (allEgressRecipients.length > 0) {
+    newEntries.push([
+      hrmpEgressIndexKey(paraId),
+      Binary.toHex(vecU32.enc(allEgressRecipients))
+    ]);
+    for (const recipientId of allEgressRecipients) {
+      const chKey = hrmpChannelKey(paraId, recipientId);
+      const existingHex = decodedProof.get(chKey);
+      if (existingHex) {
+        newEntries.push([chKey, existingHex]);
+      } else {
+        newEntries.push([
+          chKey,
+          Binary.toHex(AbridgedHrmpChannelCodec.enc(DEFAULT_CHANNEL))
+        ]);
+      }
+    }
+  }
+  const nextRelayNumber = Number(prevValidationData.validation_data.relay_parent_number) + Number(relaySlotIncrease);
+  const ingressIndexHex = decodedProof.get(hrmpIngressIndexKey(paraId));
+  const existingIngressRecipients = ingressIndexHex ? vecU32.dec(Binary.fromHex(ingressIndexHex)) : [];
+  const allIngressSenders = [
+    .../* @__PURE__ */ new Set([...existingIngressRecipients, ...chain.hrmpChannels])
+  ].sort((a, b) => a - b);
+  if (allIngressSenders.length > 0)
+    newEntries.push([
+      hrmpIngressIndexKey(paraId),
+      Binary.toHex(vecU32.enc(allIngressSenders))
+    ]);
+  for (const senderId of allIngressSenders) {
+    const chKey = hrmpChannelKey(senderId, paraId);
+    const existingHex = decodedProof.get(chKey);
+    const ch = existingHex ? AbridgedHrmpChannelCodec.dec(existingHex) : { ...DEFAULT_CHANNEL };
+    const hrmpMessages = xcm.hrmp[senderId];
+    if (hrmpMessages) {
+      let mqcHead = ch.mqc_head ?? new Uint8Array(32);
+      let totalSize = ch.total_size;
+      for (const data2 of hrmpMessages) {
+        mqcHead = Blake2256(
+          mqcChain.enc({
+            hash: mqcHead,
+            sent_at: nextRelayNumber,
+            msg_hash: Blake2256(Binary.toOpaque(data2))
+          })
+        );
+        totalSize += data2.length;
+      }
+      newEntries.push([
+        chKey,
+        Binary.toHex(
+          AbridgedHrmpChannelCodec.enc({
+            ...ch,
+            msg_count: ch.msg_count + hrmpMessages.length,
+            total_size: totalSize,
+            mqc_head: mqcHead
+          })
+        )
+      ]);
+    } else {
+      newEntries.push([chKey, Binary.toHex(AbridgedHrmpChannelCodec.enc(ch))]);
+    }
+  }
+  const [newStateRoot, newNodes] = await create_proof(
+    existingNodes,
+    newEntries
+  );
+  const originalDescendants = prevValidationData.relay_parent_descendants ?? [];
+  const updatedDescendants = [];
+  let lastHeaderHash;
+  let nextDescNumber = Number(prevValidationData.validation_data.relay_parent_number) + Number(relaySlotIncrease);
+  for (let i = 0; i < originalDescendants.length; i++) {
+    const desc = originalDescendants[i];
+    const updatedDesc = {
+      ...desc,
+      // Update state_root for the first descendant
+      state_root: i === 0 ? newStateRoot : desc.state_root,
+      // Update parentHash to point to the modified previous header
+      parent_hash: lastHeaderHash ?? desc.parent_hash,
+      // Align descendant numbers with the new relay_parent_number
+      number: nextDescNumber
+    };
+    updatedDescendants.push(updatedDesc);
+    nextDescNumber += 1;
+    const encoded = runtimeBlockHeader.enc(updatedDesc);
+    lastHeaderHash = Binary.toHex(Blake2256(encoded));
+  }
+  const data = {
+    ...prevValidationData,
+    validation_data: {
+      ...prevValidationData.validation_data,
+      relay_parent_number: nextRelayNumber,
+      relay_parent_storage_root: newStateRoot
+    },
+    relay_chain_state: newNodes.map((node) => Binary.fromHex(node)),
+    relay_parent_descendants: updatedDescendants
+  };
+  const inbound_messages_data = {
+    downward_messages: {
+      full_messages: xcm.dmp,
+      hashed_messages: []
+    },
+    horizontal_messages: {
+      full_messages: allIngressSenders.flatMap(
+        (senderId) => (xcm.hrmp[senderId] ?? []).map((data2) => [
+          senderId,
+          {
+            sent_at: nextRelayNumber,
+            data: data2
+          }
+        ])
+      ),
+      hashed_messages: []
+    }
+  };
+  const callData = await getCallData(
+    parentBlock,
+    "ParachainSystem",
+    "set_validation_data",
+    {
+      data,
+      inbound_messages_data
+    }
+  );
+  return unsignedExtrinsic(callData);
+};
+const mqcChain = Struct({
+  hash: Bytes(32),
+  sent_at: u32,
+  msg_hash: Bytes(32)
+});
+const vecU32 = Vector(u32);
+const AbridgedHrmpChannelCodec = Struct({
+  max_capacity: u32,
+  max_total_size: u32,
+  max_message_size: u32,
+  msg_count: u32,
+  total_size: u32,
+  mqc_head: Option(Bytes(32))
+});
+
+export { setValidationDataInherent };
+//# sourceMappingURL=set-validation-data.js.map