@series-inc/rundot-kinetix 0.0.0-bootstrap.0

package/src/kinetix-product-contract.mjs

@@ -0,0 +1,121 @@
+import { createHash } from 'node:crypto';
+
+import {
+  assertKinetixRuntimeIdentity,
+  kinetixRuntimeAbiVersion,
+} from './kinetix-runtime-contract.mjs';
+
+export const kinetixProductKinds = Object.freeze(['simulation', 'presentation', 'binding']);
+
+export function stableKinetixContractBytes(value) {
+  return Buffer.from(JSON.stringify(canonicalize(value)));
+}
+
+export function digestKinetixBytes(bytes) {
+  return createHash('sha256').update(bytes).digest('hex');
+}
+
+export function assertKinetixProductContract(products) {
+  if (!isPlainObject(products)
+    || !/^[0-9a-f]{64}$/u.test(products.sourceDigest)
+    || !isPlainObject(products.manifest)
+    || !Array.isArray(products.manifest.payloads)) {
+    throw new Error('KINETIX_PRODUCTS_INVALID');
+  }
+
+  const payloadKinds = products.manifest.payloads.map((entry) => entry?.name);
+  if (payloadKinds.some((kind) => !kinetixProductKinds.includes(kind))) {
+    throw new Error('KINETIX_PRODUCT_KIND_UNKNOWN');
+  }
+  if (new Set(payloadKinds).size !== payloadKinds.length) {
+    throw new Error('KINETIX_PRODUCT_KIND_DUPLICATE');
+  }
+  if (payloadKinds.length !== kinetixProductKinds.length
+    || kinetixProductKinds.some((kind) => !payloadKinds.includes(kind))) {
+    throw new Error('KINETIX_PRODUCT_KIND_MISSING');
+  }
+
+  for (const kind of kinetixProductKinds) {
+    if (!Object.hasOwn(products, kind)) {
+      throw new Error('KINETIX_PRODUCT_PAYLOAD_MISSING');
+    }
+    const declaration = products.manifest.payloads.find((entry) => entry.name === kind);
+    if (!/^[0-9a-f]{64}$/u.test(declaration.digest)) {
+      throw new Error('KINETIX_PRODUCT_DIGEST_MISSING');
+    }
+    const bytes = stableKinetixContractBytes(products[kind]);
+    if (declaration.byteLength !== bytes.length) {
+      throw new Error('KINETIX_PRODUCT_BYTE_LENGTH_MISMATCH');
+    }
+    if (declaration.digest !== digestKinetixBytes(bytes)) {
+      throw new Error('KINETIX_PRODUCT_DIGEST_MISMATCH');
+    }
+  }
+  return products;
+}
+
+export function deriveKinetixRuntimeIdentity(products, runtimeContract = products?.manifest?.runtime) {
+  assertKinetixProductContract(products);
+  assertKinetixRuntimeContract(runtimeContract);
+  const simulation = products.manifest.payloads.find((entry) => entry.name === 'simulation');
+  return assertKinetixRuntimeIdentity({
+    abiVersion: kinetixRuntimeAbiVersion,
+    tickRate: runtimeContract.tickRate,
+    inputSchemaId: digestKinetixBytes(stableKinetixContractBytes({
+      domain: 'rundot.kinetix-input-schema.v1',
+      schema: runtimeContract.inputSchema,
+    })),
+    stateSchemaId: digestKinetixBytes(stableKinetixContractBytes({
+      domain: 'rundot.kinetix-state-schema.v1',
+      schema: runtimeContract.stateSchema,
+    })),
+    deterministicVersion: runtimeContract.deterministicVersion,
+    engineIdentityHash: digestKinetixBytes(stableKinetixContractBytes({
+      domain: 'rundot.kinetix-engine-identity.v1',
+      sourceDigest: products.sourceDigest,
+      targetProfile: runtimeContract.targetProfile,
+      numericProfile: runtimeContract.numericProfile,
+      deterministicAbi: runtimeContract.deterministicAbi,
+      simulationPayloadDigest: simulation.digest,
+    })),
+  });
+}
+
+export function assertKinetixRuntimeIdentityMatchesProducts(products, identity) {
+  assertKinetixRuntimeIdentity(identity);
+  const expected = deriveKinetixRuntimeIdentity(products);
+  if (stableKinetixContractBytes(expected).equals(stableKinetixContractBytes(identity)) === false) {
+    throw new Error('KINETIX_RUNTIME_IDENTITY_PRODUCT_MISMATCH');
+  }
+  return identity;
+}
+
+export function assertKinetixRuntimeContract(runtimeContract) {
+  if (!isPlainObject(runtimeContract)
+    || ![10, 20, 30, 60].includes(runtimeContract.tickRate)
+    || typeof runtimeContract.targetProfile !== 'string'
+    || runtimeContract.targetProfile.length === 0
+    || typeof runtimeContract.numericProfile !== 'string'
+    || runtimeContract.numericProfile.length === 0
+    || typeof runtimeContract.deterministicAbi !== 'string'
+    || runtimeContract.deterministicAbi.length === 0
+    || typeof runtimeContract.deterministicVersion !== 'string'
+    || runtimeContract.deterministicVersion.length === 0
+    || !isPlainObject(runtimeContract.inputSchema)
+    || !isPlainObject(runtimeContract.stateSchema)) {
+    throw new Error('KINETIX_RUNTIME_CONTRACT_INVALID');
+  }
+  return runtimeContract;
+}
+
+function canonicalize(value) {
+  if (Array.isArray(value)) return value.map(canonicalize);
+  if (isPlainObject(value)) {
+    return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonicalize(value[key])]));
+  }
+  return value;
+}
+
+function isPlainObject(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}