space-data-module-sdk 0.5.14 → 0.5.18

package/src/testing/publicationProtectionDemo.js

@@ -0,0 +1,271 @@
+import * as flatbuffers from "flatbuffers";
+
+import { createRecipientKeypairHex, protectModuleArtifact } from "../compiler/compileModule.js";
+import { extractPublicationRecordCollection } from "../transport/records.js";
+import { REC } from "spacedatastandards.org/lib/js/REC/REC.js";
+import { Record } from "spacedatastandards.org/lib/js/REC/Record.js";
+import { PNM } from "spacedatastandards.org/lib/js/PNM/main.js";
+import { ENC } from "spacedatastandards.org/lib/js/ENC/main.js";
+
+const MINIMAL_WASM_BYTES = Uint8Array.of(
+  0x00,
+  0x61,
+  0x73,
+  0x6d,
+  0x01,
+  0x00,
+  0x00,
+  0x00,
+);
+
+export function createPublicationProtectionDemoManifest() {
+  return {
+    pluginId: "com.digitalarsenal.examples.publication-protection-demo",
+    name: "Publication Protection Demo",
+    version: "0.1.0",
+    pluginFamily: "propagator",
+    capabilities: ["clock", "crypto_sign", "crypto_encrypt"],
+    externalInterfaces: [],
+    methods: [
+      {
+        methodId: "propagate",
+        displayName: "Propagate",
+        inputPorts: [
+          {
+            portId: "request",
+            acceptedTypeSets: [
+              {
+                setId: "omm-request",
+                allowedTypes: [
+                  {
+                    schemaName: "OMM.fbs",
+                    fileIdentifier: "$OMM",
+                  },
+                ],
+              },
+            ],
+            minStreams: 1,
+            maxStreams: 1,
+            required: true,
+          },
+        ],
+        outputPorts: [
+          {
+            portId: "state",
+            acceptedTypeSets: [
+              {
+                setId: "state-vector",
+                allowedTypes: [
+                  {
+                    schemaName: "StateVector.fbs",
+                    fileIdentifier: "STVC",
+                  },
+                  {
+                    schemaName: "StateVector.fbs",
+                    fileIdentifier: "STVC",
+                    wireFormat: "aligned-binary",
+                    rootTypeName: "StateVector",
+                    byteLength: 72,
+                    requiredAlignment: 8,
+                  },
+                ],
+              },
+            ],
+            minStreams: 1,
+            maxStreams: 1,
+            required: true,
+          },
+        ],
+        maxBatch: 32,
+        drainPolicy: "drain-to-empty",
+      },
+    ],
+    schemasUsed: [
+      {
+        schemaName: "OMM.fbs",
+        fileIdentifier: "$OMM",
+      },
+      {
+        schemaName: "StateVector.fbs",
+        fileIdentifier: "STVC",
+      },
+      {
+        schemaName: "StateVector.fbs",
+        fileIdentifier: "STVC",
+        wireFormat: "aligned-binary",
+        rootTypeName: "StateVector",
+        byteLength: 72,
+        requiredAlignment: 8,
+      },
+    ],
+  };
+}
+
+function summarizeAlignedBinaryContract(manifest = {}) {
+  const summaries = [];
+  for (const method of Array.isArray(manifest.methods) ? manifest.methods : []) {
+    const ports = [
+      ...(Array.isArray(method.inputPorts) ? method.inputPorts : []),
+      ...(Array.isArray(method.outputPorts) ? method.outputPorts : []),
+    ];
+    for (const port of ports) {
+      for (const typeSet of Array.isArray(port.acceptedTypeSets)
+        ? port.acceptedTypeSets
+        : []) {
+        const allowedTypes = Array.isArray(typeSet.allowedTypes)
+          ? typeSet.allowedTypes
+          : [];
+        for (const allowedType of allowedTypes) {
+          if (allowedType?.wireFormat !== "aligned-binary") {
+            continue;
+          }
+          const hasFlatbufferFallback = allowedTypes.some(
+            (candidate) =>
+              (candidate?.wireFormat ?? "flatbuffer") === "flatbuffer" &&
+              candidate?.schemaName === allowedType.schemaName &&
+              candidate?.fileIdentifier === allowedType.fileIdentifier,
+          );
+          summaries.push({
+            methodId: method.methodId ?? null,
+            portId: port.portId ?? null,
+            setId: typeSet.setId ?? null,
+            schemaName: allowedType.schemaName ?? null,
+            fileIdentifier: allowedType.fileIdentifier ?? null,
+            rootTypeName: allowedType.rootTypeName ?? null,
+            byteLength: allowedType.byteLength ?? null,
+            requiredAlignment: allowedType.requiredAlignment ?? null,
+            hasFlatbufferFallback,
+          });
+        }
+      }
+    }
+  }
+  return summaries;
+}
+
+function parseStandardsRec(recordCollectionBytes) {
+  const recBuffer = new flatbuffers.ByteBuffer(recordCollectionBytes);
+  const rec = REC.getRootAsREC(recBuffer);
+  const records = [];
+  for (let index = 0; index < rec.recordsLength(); index += 1) {
+    const record = rec.RECORDS(index, new Record());
+    if (!record) {
+      continue;
+    }
+    const standard = record.standard() ?? null;
+    if (standard === "PNM") {
+      const pnm = record.value(new PNM());
+      records.push({
+        standard,
+        fileIdentifier: "$PNM",
+        fileName: pnm?.FILE_NAME() ?? null,
+        fileId: pnm?.FILE_ID() ?? null,
+        cid: pnm?.CID() ?? null,
+        hasSignature: Boolean(pnm?.SIGNATURE()),
+      });
+      continue;
+    }
+    if (standard === "ENC") {
+      const enc = record.value(new ENC());
+      records.push({
+        standard,
+        fileIdentifier: "$ENC",
+        context: enc?.CONTEXT() ?? null,
+        rootType: enc?.ROOT_TYPE() ?? null,
+        nonceLength: enc?.nonceStartLength() ?? 0,
+        ephemeralPublicKeyLength: enc?.ephemeralPublicKeyLength() ?? 0,
+      });
+      continue;
+    }
+    records.push({
+      standard,
+      fileIdentifier: null,
+    });
+  }
+  return {
+    fileIdentifier: "$REC",
+    version: rec.version() ?? null,
+    recordCount: records.length,
+    recordStandards: records.map((record) => record.standard),
+    usesStandardsFlatbuffers: REC.bufferHasIdentifier(
+      new flatbuffers.ByteBuffer(recordCollectionBytes),
+    ),
+    records,
+  };
+}
+
+function summarizeProtectedArtifact(protectedArtifact) {
+  const parsed = extractPublicationRecordCollection(
+    protectedArtifact.protectedArtifactBytes,
+  );
+  if (!parsed) {
+    throw new Error("Protected artifact is missing the REC publication trailer.");
+  }
+  const trailer = parseStandardsRec(parsed.recordCollectionBytes);
+  return {
+    artifactId: protectedArtifact.payload.artifactId,
+    encrypted: protectedArtifact.encrypted,
+    trailer,
+    recordStandards: trailer.recordStandards,
+    pnm: parsed.pnm
+      ? {
+          fileName: parsed.pnm.fileName ?? null,
+          fileId: parsed.pnm.fileId ?? null,
+          cid: parsed.pnm.cid ?? null,
+          hasSignature: Boolean(parsed.pnm.signature),
+          signatureType: parsed.pnm.signatureType ?? null,
+          publishTimestamp: parsed.pnm.publishTimestamp ?? null,
+        }
+      : null,
+    enc: parsed.enc
+      ? {
+          context: parsed.enc.context ?? null,
+          rootType: parsed.enc.rootType ?? null,
+          keyExchange: parsed.enc.keyExchange ?? null,
+          symmetric: parsed.enc.symmetric ?? null,
+          keyDerivation: parsed.enc.keyDerivation ?? null,
+          nonceLength: parsed.enc.nonceStart?.length ?? 0,
+          ephemeralPublicKeyLength: parsed.enc.ephemeralPublicKey?.length ?? 0,
+        }
+      : null,
+    envelope: protectedArtifact.encryptedEnvelope
+      ? {
+          scheme: protectedArtifact.encryptedEnvelope.scheme ?? null,
+          hasEncRecord: Boolean(
+            protectedArtifact.encryptedEnvelope.encRecordBase64,
+          ),
+          hasPnmRecord: Boolean(
+            protectedArtifact.encryptedEnvelope.pnmRecordBase64,
+          ),
+        }
+      : null,
+  };
+}
+
+export async function createPublicationProtectionDemoSummary(options = {}) {
+  const manifest = options.manifest ?? createPublicationProtectionDemoManifest();
+  const wasmBytes =
+    options.wasmBytes instanceof Uint8Array
+      ? options.wasmBytes
+      : MINIMAL_WASM_BYTES;
+  const recipient = options.recipient ?? (await createRecipientKeypairHex());
+  const signedOnly = await protectModuleArtifact({
+    manifest,
+    wasmBytes,
+    mnemonic: options.mnemonic ?? null,
+  });
+  const encryptedDelivery = await protectModuleArtifact({
+    manifest,
+    wasmBytes,
+    mnemonic: options.mnemonic ?? null,
+    recipientPublicKeyHex: recipient.publicKeyHex,
+  });
+
+  return {
+    manifest,
+    recTrailer: parseStandardsRec(signedOnly.publicationRecordsBytes),
+    alignedBinaryContract: summarizeAlignedBinaryContract(manifest),
+    signedOnly: summarizeProtectedArtifact(signedOnly),
+    encryptedDelivery: summarizeProtectedArtifact(encryptedDelivery),
+  };
+}

package/src/testing/streamInvokeCodec.js

@@ -0,0 +1,175 @@
+import * as flatbuffers from "flatbuffers/mjs/flatbuffers.js";
+
+import { DrainPolicy } from "../generated/orbpro/manifest/drain-policy.js";
+import { TypedArenaBuffer } from "../generated/orbpro/stream/typed-arena-buffer.js";
+
+function toByteBuffer(data) {
+  if (data instanceof flatbuffers.ByteBuffer) {
+    return data;
+  }
+  return new flatbuffers.ByteBuffer(data);
+}
+
+class StreamInvokeRequest {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+
+  __init(i, bb) {
+    this.bb_pos = i;
+    this.bb = bb;
+    return this;
+  }
+
+  static getRootAsStreamInvokeRequest(bb, obj) {
+    return (obj || new StreamInvokeRequest()).__init(
+      bb.readInt32(bb.position()) + bb.position(),
+      bb,
+    );
+  }
+
+  static startStreamInvokeRequest(builder) {
+    builder.startObject(4);
+  }
+
+  static addMethodId(builder, methodIdOffset) {
+    builder.addFieldOffset(0, methodIdOffset, 0);
+  }
+
+  static addInputs(builder, inputsOffset) {
+    builder.addFieldOffset(1, inputsOffset, 0);
+  }
+
+  static createInputsVector(builder, data) {
+    builder.startVector(4, data.length, 4);
+    for (let i = data.length - 1; i >= 0; i -= 1) {
+      builder.addOffset(data[i]);
+    }
+    return builder.endVector();
+  }
+
+  static addOutputStreamCap(builder, outputStreamCap) {
+    builder.addFieldInt32(2, outputStreamCap, 0);
+  }
+
+  static addDrainPolicy(builder, drainPolicy) {
+    builder.addFieldInt8(3, drainPolicy, DrainPolicy.DRAIN_UNTIL_YIELD);
+  }
+
+  static endStreamInvokeRequest(builder) {
+    const offset = builder.endObject();
+    builder.requiredField(offset, 4);
+    return offset;
+  }
+}
+
+class StreamInvokeRequestT {
+  constructor(
+    methodId = null,
+    inputs = [],
+    outputStreamCap = 0,
+    drainPolicy = DrainPolicy.DRAIN_UNTIL_YIELD,
+  ) {
+    this.methodId = methodId;
+    this.inputs = inputs;
+    this.outputStreamCap = outputStreamCap;
+    this.drainPolicy = drainPolicy;
+  }
+
+  pack(builder) {
+    const methodId =
+      this.methodId !== null ? builder.createString(this.methodId) : 0;
+    const inputs = StreamInvokeRequest.createInputsVector(
+      builder,
+      builder.createObjectOffsetList(this.inputs),
+    );
+    StreamInvokeRequest.startStreamInvokeRequest(builder);
+    StreamInvokeRequest.addMethodId(builder, methodId);
+    StreamInvokeRequest.addInputs(builder, inputs);
+    StreamInvokeRequest.addOutputStreamCap(builder, this.outputStreamCap);
+    StreamInvokeRequest.addDrainPolicy(builder, this.drainPolicy);
+    return StreamInvokeRequest.endStreamInvokeRequest(builder);
+  }
+}
+
+class StreamInvokeResponse {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+
+  __init(i, bb) {
+    this.bb_pos = i;
+    this.bb = bb;
+    return this;
+  }
+
+  static getRootAsStreamInvokeResponse(bb, obj) {
+    return (obj || new StreamInvokeResponse()).__init(
+      bb.readInt32(bb.position()) + bb.position(),
+      bb,
+    );
+  }
+
+  outputs(index, obj) {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset
+      ? (obj || new TypedArenaBuffer()).__init(
+          this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
+          this.bb,
+        )
+      : null;
+  }
+
+  outputsLength() {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+  }
+
+  backlogRemaining() {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
+  }
+
+  yielded() {
+    const offset = this.bb.__offset(this.bb_pos, 8);
+    return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
+  }
+
+  errorCode() {
+    const offset = this.bb.__offset(this.bb_pos, 10);
+    return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+  }
+
+  errorMessage(optionalEncoding) {
+    const offset = this.bb.__offset(this.bb_pos, 12);
+    return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+  }
+
+  unpack() {
+    return {
+      outputs: this.bb.createObjList(this.outputs.bind(this), this.outputsLength()),
+      backlogRemaining: this.backlogRemaining(),
+      yielded: this.yielded(),
+      errorCode: this.errorCode(),
+      errorMessage: this.errorMessage(),
+    };
+  }
+}
+
+export function encodeStreamInvokeRequest(request) {
+  const normalized =
+    request instanceof StreamInvokeRequestT
+      ? request
+      : Object.assign(new StreamInvokeRequestT(), request);
+  const builder = new flatbuffers.Builder(1024);
+  builder.finish(normalized.pack(builder));
+  return builder.asUint8Array();
+}
+
+export function decodeStreamInvokeResponse(data) {
+  return StreamInvokeResponse.getRootAsStreamInvokeResponse(
+    toByteBuffer(data),
+  ).unpack();
+}

package/src/transport/records.js

@@ -1,6 +1,12 @@
-import * as flatbuffers from "flatbuffers";
+import * as flatbuffers from "flatbuffers/mjs/flatbuffers.js";
 
-import { ENC, ENCT, KDF, KeyExchange, SymmetricAlgo } from "spacedatastandards.org/lib/js/ENC/main.js";
+import {
+  ENC,
+  ENCT,
+  KDF,
+  KeyExchange,
+  SymmetricAlgo,
+} from "spacedatastandards.org/lib/js/ENC/main.js";
 import { PNM, PNMT } from "spacedatastandards.org/lib/js/PNM/main.js";
 import { REC, RECT } from "spacedatastandards.org/lib/js/REC/REC.js";
 import { Record, RecordT } from "spacedatastandards.org/lib/js/REC/Record.js";
@@ -75,6 +81,16 @@ function readUint16LE(buffer, offset, label) {
   return buffer[offset] | (buffer[offset + 1] << 8);
 }
 
+function getRecordValueType(recordTable) {
+  if (typeof recordTable.valueType === "function") {
+    return recordTable.valueType();
+  }
+  if (typeof recordTable.value_type === "function") {
+    return recordTable.value_type();
+  }
+  throw new TypeError("REC record table does not expose a value type accessor.");
+}
+
 function readUint32LE(buffer, offset, label) {
   assertBounds(buffer, offset, 4, label);
   return (
@@ -277,7 +293,27 @@ function validateEncTable(table, buffer, label) {
     maxLength: 32,
   });
   assertOptionalStringField(buffer, tableMeta, 22, `${label} root type`);
-  const record = normalizeEncTable(table.unpack());
+  const timestamp = table.TIMESTAMP();
+  const record = {
+    version: Number(table.VERSION()),
+    keyExchange:
+      KEY_EXCHANGE_NAME_BY_VALUE[table.KEY_EXCHANGE()] ??
+      String(table.KEY_EXCHANGE()),
+    symmetric:
+      SYMMETRIC_ALGO_NAME_BY_VALUE[table.SYMMETRIC()] ??
+      String(table.SYMMETRIC()),
+    keyDerivation:
+      KDF_NAME_BY_VALUE[table.KEY_DERIVATION()] ??
+      String(table.KEY_DERIVATION()),
+    ephemeralPublicKey: normalizeByteField(table.ephemeralPublicKeyArray()),
+    nonceStart: normalizeByteField(table.nonceStartArray()),
+    recipientKeyId: normalizeByteField(table.recipientKeyIdArray()),
+    context: normalizeStringField(table.CONTEXT()),
+    schemaHash: normalizeByteField(table.schemaHashArray()),
+    rootType: normalizeStringField(table.ROOT_TYPE()),
+    timestamp:
+      timestamp === undefined || timestamp === null ? 0 : Number(timestamp),
+  };
   if (!record.ephemeralPublicKey?.length) {
     throw new Error(`${label} is missing the ephemeral public key.`);
   }
@@ -316,7 +352,17 @@ function validatePnmTable(table, buffer, label) {
   assertOptionalStringField(buffer, tableMeta, 16, `${label} timestamp signature`);
   assertOptionalStringField(buffer, tableMeta, 18, `${label} signature type`);
   assertOptionalStringField(buffer, tableMeta, 20, `${label} timestamp signature type`);
-  const record = normalizePnmTable(table.unpack());
+  const record = {
+    multiformatAddress: normalizeStringField(table.MULTIFORMAT_ADDRESS()),
+    publishTimestamp: normalizeStringField(table.PUBLISH_TIMESTAMP()),
+    cid: normalizeStringField(table.CID()),
+    fileName: normalizeStringField(table.FILE_NAME()),
+    fileId: normalizeStringField(table.FILE_ID()),
+    signature: normalizeStringField(table.SIGNATURE()),
+    timestampSignature: normalizeStringField(table.TIMESTAMP_SIGNATURE()),
+    signatureType: normalizeStringField(table.SIGNATURE_TYPE()),
+    timestampSignatureType: normalizeStringField(table.TIMESTAMP_SIGNATURE_TYPE()),
+  };
   if (
     !record.multiformatAddress &&
     !record.publishTimestamp &&
@@ -426,48 +472,6 @@ function pnmTableFromObject(record = {}) {
   );
 }
 
-function normalizeEncTable(table) {
-  if (!table) {
-    return null;
-  }
-  return {
-    version: Number(table.VERSION ?? 1),
-    keyExchange:
-      KEY_EXCHANGE_NAME_BY_VALUE[table.KEY_EXCHANGE] ?? String(table.KEY_EXCHANGE),
-    symmetric:
-      SYMMETRIC_ALGO_NAME_BY_VALUE[table.SYMMETRIC] ?? String(table.SYMMETRIC),
-    keyDerivation:
-      KDF_NAME_BY_VALUE[table.KEY_DERIVATION] ?? String(table.KEY_DERIVATION),
-    ephemeralPublicKey: normalizeByteField(table.EPHEMERAL_PUBLIC_KEY),
-    nonceStart: normalizeByteField(table.NONCE_START),
-    recipientKeyId: normalizeByteField(table.RECIPIENT_KEY_ID),
-    context: normalizeStringField(table.CONTEXT),
-    schemaHash: normalizeByteField(table.SCHEMA_HASH),
-    rootType: normalizeStringField(table.ROOT_TYPE),
-    timestamp:
-      table.TIMESTAMP === undefined || table.TIMESTAMP === null
-        ? 0
-        : Number(table.TIMESTAMP),
-  };
-}
-
-function normalizePnmTable(table) {
-  if (!table) {
-    return null;
-  }
-  return {
-    multiformatAddress: normalizeStringField(table.MULTIFORMAT_ADDRESS),
-    publishTimestamp: normalizeStringField(table.PUBLISH_TIMESTAMP),
-    cid: normalizeStringField(table.CID),
-    fileName: normalizeStringField(table.FILE_NAME),
-    fileId: normalizeStringField(table.FILE_ID),
-    signature: normalizeStringField(table.SIGNATURE),
-    timestampSignature: normalizeStringField(table.TIMESTAMP_SIGNATURE),
-    signatureType: normalizeStringField(table.SIGNATURE_TYPE),
-    timestampSignatureType: normalizeStringField(table.TIMESTAMP_SIGNATURE_TYPE),
-  };
-}
-
 function readFooterLength(bytes) {
   const view = toUint8Array(bytes);
   if (view.length < TRAILER_FOOTER_LENGTH) {
@@ -601,7 +605,6 @@ export function decodePublicationRecordCollection(bytes) {
   if (recordTables.length === 0) {
     throw new Error("REC trailer does not contain any records.");
   }
-  const collection = collectionTable.unpack();
   const records = [];
   let enc = null;
   let pnm = null;
@@ -622,10 +625,9 @@ export function decodePublicationRecordCollection(bytes) {
       8,
       `REC trailer record ${index} standard`,
     );
-    const unpackedRecord = collection.RECORDS[index];
-    const recordType = recordTable.value_type();
+    const recordType = getRecordValueType(recordTable);
     const standard =
-      normalizeStringField(unpackedRecord?.standard) ??
+      normalizeStringField(recordTable.standard()) ??
       STANDARD_BY_RECORD_TYPE[recordType] ??
       null;
     const expectedStandard =
@@ -644,10 +646,7 @@ export function decodePublicationRecordCollection(bytes) {
     if (!valueMeta) {
       throw new Error(`REC trailer record ${index} is missing a value.`);
     }
-    let value =
-      standard === "ENC" || standard === "PNM"
-        ? null
-        : unpackedRecord?.value ?? null;
+    let value = null;
     if (standard === "ENC") {
       const encTable = recordTable.value(new ENC());
       if (!encTable) {
@@ -684,7 +683,9 @@ export function decodePublicationRecordCollection(bytes) {
     });
   }
   return {
-    version: normalizeStringField(collection.version) ?? DEFAULT_RECORD_COLLECTION_VERSION,
+    version:
+      normalizeStringField(collectionTable.version()) ??
+      DEFAULT_RECORD_COLLECTION_VERSION,
     records,
     enc,
     pnm,