feat: Refactor NeonTypes

Interfaces for classes should not be used for Neon Objects.

Author: cdmurph32

js-src/Builder.ts

@@ -23,14 +23,16 @@ import type {
   LocalSignerInterface,
   ManifestAssertionKind,
   SourceAsset,
+  NeonBuilderHandle,
 } from "./types";
+import { IdentityAssertionSigner } from "./IdentityAssertion";
 import type { Manifest } from "@contentauth/c2pa-types";
 
 export class Builder implements BuilderInterface {
-  private constructor(private builder: BuilderInterface) {}
+  private constructor(private builder: NeonBuilderHandle) {}
 
   static new(): Builder {
-    const builder = neon.builderNew();
+    const builder: NeonBuilderHandle = neon.builderNew();
     return new Builder(builder);
   }
 
@@ -49,7 +51,7 @@ export class Builder implements BuilderInterface {
         "Failed to stringify JSON Manifest Definition: Unknown error",
       );
     }
-    const builder: BuilderInterface = neon.builderWithJson(jsonString);
+    const builder: NeonBuilderHandle = neon.builderWithJson(jsonString);
     return new Builder(builder);
   }
 
@@ -146,8 +148,13 @@ export class Builder implements BuilderInterface {
     input: SourceAsset,
     output: DestinationAsset,
   ): Promise<Buffer> {
-    return neon.builderSignAsync
-      .call(this.builder, signer.signer(), input, output)
+    const neonHandle = signer.signer();
+    const isIdentity = signer instanceof IdentityAssertionSigner;
+    const neonFn = isIdentity
+      ? neon.builderIdentitySignAsync
+      : neon.builderSignAsync;
+    return neonFn
+      .call(this.builder, neonHandle, input, output)
       .then((result: Buffer | { manifest: Buffer; signedAsset: Buffer }) => {
         // output is a buffer and result is the manifest and the signed asset.
         if ("buffer" in output) {

js-src/IdentityAssertion.spec.ts

@@ -13,22 +13,17 @@
 
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 
-import { CallbackSigner } from "./Signer";
-import { Reader } from "./Reader";
-import { Builder } from "./Builder";
-import {
-  IdentityAssertionBuilder,
-  IdentityAssertionSigner,
-  CallbackCredentialHolder,
-} from "./IdentityAssertion";
+// Note: We will dynamically import modules after establishing mocks
 import type {
   JsCallbackSignerConfig,
   DestinationBufferAsset,
   SigningAlg,
+  SignerPayload,
 } from "./types";
 import type { Manifest } from "@contentauth/c2pa-types";
 import * as fs from "fs-extra";
 import * as crypto from "crypto";
+import { encode } from "cbor2";
 
 class TestSigner {
   private privateKey: crypto.KeyObject;
@@ -41,7 +36,19 @@ class TestSigner {
   }
 
   sign = async (bytes: Buffer): Promise<Buffer> => {
-    return crypto.sign(null, bytes, this.privateKey);
+    const sign = crypto.createSign("SHA256");
+    sign.update(bytes);
+    sign.end();
+    return sign.sign(this.privateKey);
+  };
+}
+
+class TestCawgSigner {
+  constructor(private manifestSigner: TestSigner) {}
+
+  sign = async (payload: SignerPayload): Promise<Buffer> => {
+    const cborBytes = Buffer.from(encode(payload));
+    return this.manifestSigner.sign(cborBytes);
   };
 }
 
@@ -103,17 +110,20 @@ describe("IdentityAssertionBuilder", () => {
   };
 
   it("should build an Identity Assertion Signer", async () => {
+    const { CallbackSigner } = await import("./Signer");
+    const { Reader } = await import("./Reader");
+    const { Builder } = await import("./Builder");
+    const {
+      IdentityAssertionBuilder,
+      IdentityAssertionSigner,
+      CallbackCredentialHolder,
+    } = await import("./IdentityAssertion");
     // Read certificate files once
     const c2paPrivateKey = await fs.readFile(
       "./tests/fixtures/certs/es256.pem",
     );
     const c2paPublicKey = await fs.readFile("./tests/fixtures/certs/es256.pub");
-    const cawgPrivateKey = await fs.readFile(
-      "./tests/fixtures/certs/ed25519.pem",
-    );
-    const cawgPublicKey = await fs.readFile(
-      "./tests/fixtures/certs/ed25519.pub",
-    );
+    // Use the same signer for both C2PA manifest and COSE signing
 
     // Create signer configurations
     const c2paConfig: JsCallbackSignerConfig = {
@@ -128,11 +138,11 @@ describe("IdentityAssertionBuilder", () => {
 
     // Create signers
     const c2paTestSigner = new TestSigner(c2paPrivateKey);
-    const cawgTestSigner = new TestSigner(cawgPrivateKey);
     const c2paSigner = CallbackSigner.newSigner(
       c2paConfig,
       c2paTestSigner.sign,
     );
+    const cawgTestSigner = new TestCawgSigner(c2paTestSigner);
     const cawgSigner = CallbackCredentialHolder.newCallbackCredentialHolder(
       10000,
       "cawg.x509.cose",
@@ -164,13 +174,13 @@ describe("IdentityAssertionBuilder", () => {
     const iaSigner = IdentityAssertionSigner.new(c2paSigner.signer());
     const iab =
       await IdentityAssertionBuilder.identityBuilderForCredentialHolder(
-        cawgSigner.signer(),
+        cawgSigner,
       );
     iab.addReferencedAssertions(["cawg.training-mining"]);
     iaSigner.addIdentityAssertion(iab);
 
     // Sign the manifest (standard async flow)
-    await builder.signAsync(iaSigner.signer(), source, dest);
+    await builder.signAsync(iaSigner, source, dest);
 
     // Verify the manifest
     const reader = await Reader.fromAsset({

js-src/IdentityAssertion.ts

@@ -14,16 +14,19 @@
 const neon = require("./index.node");
 import type {
   CallbackCredentialHolderInterface,
-  CallbackSignerInterface,
   IdentityAssertionBuilderInterface,
   IdentityAssertionSignerInterface,
+  NeonCallbackCredentialHolderHandle,
+  NeonIdentityAssertionSignerHandle,
+  NeonIdentityAssertionBuilderHandle,
   SignerPayload,
+  NeonCallbackSignerHandle,
 } from "./types";
 
 export class IdentityAssertionBuilder
   implements IdentityAssertionBuilderInterface
 {
-  constructor(private _builder: IdentityAssertionBuilderInterface) {}
+  constructor(private _builder: NeonIdentityAssertionBuilderHandle) {}
 
   static async identityBuilderForCredentialHolder(
     credentialHolder: CallbackCredentialHolderInterface,
@@ -45,18 +48,18 @@ export class IdentityAssertionBuilder
     neon.identityBuilderAddRoles.call(this._builder, roles);
   }
 
-  builder(): IdentityAssertionBuilderInterface {
+  builder(): NeonIdentityAssertionBuilderHandle {
     return this._builder;
   }
 }
 
 export class IdentityAssertionSigner
   implements IdentityAssertionSignerInterface
 {
-  constructor(private _signer: IdentityAssertionSignerInterface) {}
+  constructor(private _signer: NeonIdentityAssertionSignerHandle) {}
 
-  static new(signer: CallbackSignerInterface): IdentityAssertionSigner {
-    const identitySigner = neon.identitySignerNew(signer.signer());
+  static new(signer: NeonCallbackSignerHandle): IdentityAssertionSigner {
+    const identitySigner = neon.identitySignerNew(signer);
     return new IdentityAssertionSigner(identitySigner);
   }
 
@@ -69,7 +72,7 @@ export class IdentityAssertionSigner
     );
   }
 
-  signer(): IdentityAssertionSignerInterface {
+  signer(): NeonIdentityAssertionSignerHandle {
     return this._signer;
   }
 }
@@ -78,10 +81,10 @@ export class CallbackCredentialHolder
   implements CallbackCredentialHolderInterface
 {
   constructor(
-    private callbackCredentialHolder: CallbackCredentialHolderInterface,
+    private callbackCredentialHolder: NeonCallbackCredentialHolderHandle,
   ) {}
 
-  signer(): CallbackCredentialHolderInterface {
+  signer(): NeonCallbackCredentialHolderHandle {
     return this.callbackCredentialHolder;
   }
 

js-src/Reader.ts

@@ -12,12 +12,17 @@
 // each license.
 
 const neon = require("./index.node");
-import type { DestinationAsset, ReaderInterface, SourceAsset } from "./types";
+import type {
+  DestinationAsset,
+  ReaderInterface,
+  SourceAsset,
+  NeonReaderHandle,
+} from "./types";
 
 import type { Manifest, ManifestStore } from "@contentauth/c2pa-types";
 
 export class Reader implements ReaderInterface {
-  constructor(private reader: ReaderInterface) {}
+  constructor(private reader: NeonReaderHandle) {}
 
   json(): ManifestStore {
     return JSON.parse(neon.readerJson.call(this.reader));
@@ -36,15 +41,15 @@ export class Reader implements ReaderInterface {
   }
 
   static async fromAsset(asset: SourceAsset): Promise<Reader> {
-    const reader = await neon.readerFromAsset(asset);
+    const reader: NeonReaderHandle = await neon.readerFromAsset(asset);
     return new Reader(reader);
   }
 
   static async fromManifestDataAndAsset(
     manifestData: Buffer,
     asset: SourceAsset,
   ): Promise<Reader> {
-    const reader = await neon.readerFromManifestDataAndAsset(
+    const reader: NeonReaderHandle = await neon.readerFromManifestDataAndAsset(
       manifestData,
       asset,
     );

js-src/Signer.ts

@@ -15,12 +15,14 @@ const neon = require("./index.node");
 import type {
   CallbackSignerInterface,
   JsCallbackSignerConfig,
+  NeonCallbackSignerHandle,
+  NeonLocalSignerHandle,
   LocalSignerInterface,
   SigningAlg,
 } from "./types";
 
 export class LocalSigner implements LocalSignerInterface {
-  constructor(private localSigner: LocalSignerInterface) {}
+  constructor(private localSigner: NeonLocalSignerHandle) {}
 
   static newSigner(
     certificate: Buffer,
@@ -57,15 +59,15 @@ export class LocalSigner implements LocalSignerInterface {
     return neon.localSignerTimeAuthorityUrl.call(this.localSigner);
   }
 
-  signer(): LocalSignerInterface {
+  signer(): NeonLocalSignerHandle {
     return this.localSigner;
   }
 }
 
 export class CallbackSigner implements CallbackSignerInterface {
-  constructor(private callbackSigner: CallbackSignerInterface) {}
+  constructor(private callbackSigner: NeonCallbackSignerHandle) {}
 
-  signer(): CallbackSignerInterface {
+  signer(): NeonCallbackSignerHandle {
     return this.callbackSigner;
   }
 

js-src/Trustmark.ts

@@ -12,13 +12,17 @@
 // each license.
 
 const neon = require("./index.node");
-import type { TrustmarkInterface, TrustmarkConfig } from "./types";
+import type {
+  TrustmarkInterface,
+  TrustmarkConfig,
+  NeonTrustmarkHandle,
+} from "./types";
 
 export class Trustmark implements TrustmarkInterface {
-  constructor(private trustmark: TrustmarkInterface) {}
+  constructor(private trustmark: NeonTrustmarkHandle) {}
 
   static async newTrustmark(config: TrustmarkConfig): Promise<Trustmark> {
-    const trustmark = await neon.trustmarkNew(config);
+    const trustmark: NeonTrustmarkHandle = await neon.trustmarkNew(config);
     return new Trustmark(trustmark);
   }