@road-labs/ocmf 0.0.1 → 0.0.3

package/build/types/types.d.ts

@@ -6,6 +6,17 @@ export interface SignedData {
 }
 export type Header = 'OCMF';
 export declare const Header: Header;
+type Iso15118UserAssignment = 'ISO15118_NONE' | 'ISO15118_PNC';
+type PlmnUserAssignment = 'PLMN_NONE' | 'PLMN_RING' | 'PLMN_SMS';
+type ChargingPointAssignment = 'EVSEID' | 'CBIDC';
+type RfidUserAssignment = 'RFID_NONE' | 'RFID_PLAIN' | 'RFID_RELATED' | 'RFID_PSK';
+type OcppUserAssignment = 'OCPP_NONE' | 'OCPP_RS' | 'OCPP_AUTH' | 'OCPP_RS_TLS' | 'OCPP_AUTH_TLS' | 'OCPP_CACHE' | 'OCPP_WHITELIST' | 'OCPP_CERTIFIED';
+type IdentificationLevel = 'NONE' | 'HEARSAY' | 'TRUSTED' | 'VERIFIED' | 'CERTIFIED' | 'SECURE' | 'MISMATCH' | 'INVALID' | 'OUTDATED' | 'UNKNOWN';
+type IdentificationType = 'NONE' | 'DENIED' | 'UNDEFINED' | 'ISO14443' | 'ISO15693' | 'EMAID' | 'EVCCID' | 'EVCOID' | 'ISO7812' | 'CARD_TXN_NR' | 'CENTRAL' | 'CENTRAL_1' | 'CENTRAL_2' | 'LOCAL' | 'LOCAL_1' | 'LOCAL_2' | 'PHONE_NUMBER' | 'KEY_CODE';
+type MeterReadingReason = 'B' | 'C' | 'X' | 'E' | 'L' | 'R' | 'A' | 'P' | 'S' | 'T';
+type MeterStatus = 'N' | 'G' | 'T' | 'D' | 'R' | 'M' | 'X' | 'I' | 'O' | 'S' | 'E' | 'F';
+type UserAssignment = RfidUserAssignment | OcppUserAssignment | Iso15118UserAssignment | PlmnUserAssignment;
+type UnitType = 'kWh' | 'Wh' | 'mOhm' | 'uOhm';
 export interface PayloadData {
     FV?: string;
     GI?: string;
@@ -17,9 +28,9 @@ export interface PayloadData {
     MS: string;
     MF?: string;
     IS: boolean;
-    IL?: string;
-    IF?: string[];
-    IT: string;
+    IL?: IdentificationLevel;
+    IF?: UserAssignment[];
+    IT: IdentificationType;
     ID?: string;
     TT?: string;
     CF?: string;
@@ -27,20 +38,20 @@ export interface PayloadData {
         LN?: string;
         LI?: number;
         LR: number;
-        LU: string;
+        LU: Extract<UnitType, 'mOhm' | 'uOhm'>;
     };
-    CT?: string;
+    CT?: ChargingPointAssignment;
     CI?: string;
     RD: {
         TM: string;
-        TX?: 'B' | 'C' | 'X' | 'E' | 'L' | 'R' | 'A' | 'P' | 'S' | 'T';
+        TX?: MeterReadingReason;
         RV: number;
         RI?: string;
-        RU: string;
+        RU: UnitType;
         RT?: string;
         CL?: number;
         EF?: string;
-        ST: string;
+        ST: MeterStatus;
     }[];
 }
 export interface Signature {
@@ -49,3 +60,4 @@ export interface Signature {
     SM?: 'application/x-der';
     SD: string;
 }
+export {};

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@road-labs/ocmf",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "main": "build/cjs/index.js",
   "module": "build/es2022/index.js",
   "types": "build/types/index.d.ts",
+  "files": [
+    "build/**/*"
+  ],
   "keywords": [],
   "author": "",
   "license": "MIT",
@@ -20,7 +23,7 @@
     "test-commons": "0.0.1"
   },
   "dependencies": {
-    "@road-labs/ocmf-crypto": "0.0.1"
+    "@road-labs/ocmf-crypto": "0.0.3"
   },
   "scripts": {
     "clear": "rimraf build",

package/jest.config.js

@@ -1,11 +0,0 @@
-const { createDefaultPreset } = require('ts-jest');
-
-const tsJestTransformCfg = createDefaultPreset().transform;
-
-/** @type {import("jest").Config} **/
-module.exports = {
-  testEnvironment: 'node',
-  transform: {
-    ...tsJestTransformCfg,
-  },
-};

package/src/errors.ts

@@ -1,3 +0,0 @@
-export class CurveMismatchError extends Error {}
-export class UnknownSignatureEncoding extends Error {}
-export class UnknownSignatureMimeType extends Error {}

package/src/index.ts

@@ -1,8 +0,0 @@
-export * from './types';
-export * from './parse';
-export * from './signature';
-export * from './errors';
-export * from './verifier';
-export * from './signer';
-export { default as Signer } from './signer';
-export { default as Verifier } from './verifier';

package/src/parse.ts

@@ -1,42 +0,0 @@
-import { Header, SignedData } from './types';
-
-interface Sections {
-  header: Header;
-  payloadData: string;
-  signature: string;
-}
-
-export function decomposeValue(value: string): Sections {
-  const parts = value.split('|');
-  if (parts.length !== 3) {
-    throw new Error('Signed data must be in OCMF|data|signature format');
-  }
-
-  const headerSection = parts[0];
-  const payloadDataSection = parts[1];
-  const signatureSection = parts[2];
-
-  if (headerSection !== 'OCMF') {
-    throw new Error('OCMF header required');
-  }
-  if (payloadDataSection.length === 0) {
-    throw new Error('Payload section cannot be empty');
-  }
-  if (signatureSection.length === 0) {
-    throw new Error('Signature section cannot be empty');
-  }
-
-  return {
-    header: headerSection,
-    payloadData: payloadDataSection,
-    signature: signatureSection,
-  };
-}
-
-export function parseSections(sections: Sections): SignedData {
-  return {
-    header: sections.header,
-    payloadData: JSON.parse(sections.payloadData),
-    signature: JSON.parse(sections.signature),
-  };
-}

package/src/signature.ts

@@ -1,72 +0,0 @@
-import { Curve, Hash } from '@road-labs/ocmf-crypto';
-
-export type SignatureMethodId =
-  | 'ECDSA-brainpool256r1-SHA256'
-  | 'ECDSA-brainpool384r1-SHA256'
-  | 'ECDSA-secp192k1-SHA256'
-  | 'ECDSA-secp192r1-SHA256'
-  | 'ECDSA-secp256k1-SHA256'
-  | 'ECDSA-secp256r1-SHA256'
-  | 'ECDSA-secp384r1-SHA256';
-
-export type SignatureMethod = {
-  id: SignatureMethodId;
-  algorithm: string;
-  curve: Curve;
-  hash: Hash;
-};
-
-const signatureMethods: SignatureMethod[] = [
-  {
-    id: 'ECDSA-secp192r1-SHA256',
-    algorithm: 'ECDSA',
-    curve: 'secp192r1',
-    hash: 'SHA-256',
-  },
-  {
-    id: 'ECDSA-secp192k1-SHA256',
-    algorithm: 'ECDSA',
-    curve: 'secp192k1',
-    hash: 'SHA-256',
-  },
-  {
-    id: 'ECDSA-secp256r1-SHA256',
-    algorithm: 'ECDSA',
-    curve: 'secp256r1',
-    hash: 'SHA-256',
-  },
-  {
-    id: 'ECDSA-secp256k1-SHA256',
-    algorithm: 'ECDSA',
-    curve: 'secp256k1',
-    hash: 'SHA-256',
-  },
-  {
-    id: 'ECDSA-secp384r1-SHA256',
-    algorithm: 'ECDSA',
-    curve: 'secp384r1',
-    hash: 'SHA-256',
-  },
-  {
-    id: 'ECDSA-brainpool256r1-SHA256',
-    algorithm: 'ECDSA',
-    curve: 'brainpool256r1',
-    hash: 'SHA-256',
-  },
-  {
-    id: 'ECDSA-brainpool384r1-SHA256',
-    algorithm: 'ECDSA',
-    curve: 'brainpool384r1',
-    hash: 'SHA-256',
-  },
-];
-
-export function signatureMethodFromId(id: SignatureMethodId): SignatureMethod {
-  const signatureMethod = signatureMethods.find(
-    (signature) => signature.id === id
-  );
-  if (!signatureMethod) {
-    throw new Error(`Unsupported signature method: ${id}`);
-  }
-  return signatureMethod;
-}

package/src/signer.ts

@@ -1,50 +0,0 @@
-import { signatureMethodFromId, SignatureMethodId } from './signature';
-import { Header, PayloadData, Signature } from './types';
-import { CryptoAdapter, EcPrivateKey } from '@road-labs/ocmf-crypto';
-import { CurveMismatchError } from './errors';
-
-export default class Signer {
-  constructor(private readonly crypto: CryptoAdapter) {}
-
-  /**
-   * @param payload - Meter data payload to be signed
-   * @param privateKey - Private key to use for signing
-   * @param signatureMethodId - Signing method. Note: the curve indicated by the id must match that of the private key
-   */
-  public async sign(
-    payload: PayloadData,
-    privateKey: EcPrivateKey,
-    signatureMethodId: SignatureMethodId
-  ): Promise<string> {
-    const signatureMethod = signatureMethodFromId(signatureMethodId);
-    if (signatureMethod.curve !== privateKey.getCurve()) {
-      throw new CurveMismatchError(
-        `Expected ${privateKey.getCurve()}, actual ${signatureMethod.curve}`
-      );
-    }
-
-    const payloadDataSegment = JSON.stringify(payload);
-    const textEncoder = new TextEncoder();
-    const payloadDataSegmentBytes = textEncoder.encode(payloadDataSegment);
-
-    const signature = await this.crypto.sign(
-      payloadDataSegmentBytes,
-      privateKey,
-      signatureMethod.hash,
-      'sigvalue-der'
-    );
-
-    const signatureSegment = JSON.stringify({
-      SA: signatureMethod.id,
-      SD: bytesToHex(signature).toUpperCase(),
-    } as Signature);
-
-    return [Header, payloadDataSegment, signatureSegment].join('|');
-  }
-}
-
-function bytesToHex(bytes: Uint8Array): string {
-  return Array.from(bytes)
-    .map((x) => x.toString(16).padStart(2, '0'))
-    .join('');
-}

package/src/types.ts

@@ -1,55 +0,0 @@
-import { SignatureMethodId } from './signature';
-
-export interface SignedData {
-  header: Header;
-  payloadData: PayloadData;
-  signature: Signature;
-}
-
-export type Header = 'OCMF';
-export const Header: Header = 'OCMF';
-
-export interface PayloadData {
-  FV?: string;
-  GI?: string;
-  GS?: string;
-  GV?: string;
-  PG: string;
-  MV?: string;
-  MM?: string;
-  MS: string;
-  MF?: string;
-  IS: boolean;
-  IL?: string;
-  IF?: string[];
-  IT: string;
-  ID?: string;
-  TT?: string;
-  CF?: string;
-  LC?: {
-    LN?: string;
-    LI?: number;
-    LR: number;
-    LU: string;
-  };
-  CT?: string;
-  CI?: string;
-  RD: {
-    TM: string;
-    TX?: 'B' | 'C' | 'X' | 'E' | 'L' | 'R' | 'A' | 'P' | 'S' | 'T';
-    RV: number;
-    RI?: string;
-    RU: string;
-    RT?: string;
-    CL?: number;
-    EF?: string;
-    ST: string;
-  }[];
-}
-
-export interface Signature {
-  SA: SignatureMethodId;
-  SE?: 'hex';
-  SM?: 'application/x-der';
-  SD: string;
-}

package/src/verifier.ts

@@ -1,83 +0,0 @@
-import { SignedData } from './types';
-import { signatureMethodFromId } from './signature';
-import { decomposeValue, parseSections } from './parse';
-import { CryptoAdapter, EcPublicKey } from '@road-labs/ocmf-crypto';
-import {
-  CurveMismatchError,
-  UnknownSignatureEncoding,
-  UnknownSignatureMimeType,
-} from './errors';
-
-export interface ParseAndVerifyResult {
-  verified: boolean;
-  value?: SignedData; // Only included if the payload was verified
-}
-
-export default class Verifier {
-  constructor(private readonly crypto: CryptoAdapter) {}
-
-  /**
-   * @param rawSignedData - The full OCMF signed meter data payload as sent by the charging station
-   * @param publicKey - The public key for verifying the OCMF signed meter data payload
-   * @return Result of verification. Note: if the payload was not verified, the parsed value is not included.
-   */
-  async parseAndVerify(
-    rawSignedData: string,
-    publicKey: EcPublicKey
-  ): Promise<ParseAndVerifyResult> {
-    const sections = decomposeValue(rawSignedData);
-    const signedData = parseSections(sections);
-    const { signature } = signedData;
-
-    const signatureMethod = signatureMethodFromId(signature.SA);
-    if (signatureMethod.curve !== publicKey.getCurve()) {
-      throw new CurveMismatchError(
-        `Expected ${publicKey.getCurve()}, actual ${signatureMethod.curve}`
-      );
-    }
-
-    if (signature.SE && signature.SE !== 'hex') {
-      throw new UnknownSignatureEncoding(
-        'Only hex encoded signatures are supported'
-      );
-    }
-
-    if (signature.SM && signature.SM !== 'application/x-der') {
-      throw new UnknownSignatureMimeType(
-        'Only application/x-der encoded signatures are supported'
-      );
-    }
-
-    const textEncoder = new TextEncoder();
-    const payloadDataSegment = textEncoder.encode(sections.payloadData);
-    const signatureBytes = hexToBytes(signature.SD);
-
-    const verified = await this.crypto.verify(
-      signatureBytes,
-      payloadDataSegment,
-      publicKey,
-      signatureMethod.hash,
-      'sigvalue-der'
-    );
-
-    return {
-      verified,
-      value: verified ? signedData : undefined,
-    };
-  }
-}
-
-function hexToBytes(hex: string): Uint8Array {
-  if (
-    hex.length === 0 ||
-    hex.length % 2 !== 0 ||
-    !hex.match(/^[A-Za-f0-9]+$/)
-  ) {
-    throw new Error('Invalid hex string');
-  }
-  const bytes = hex.match(/.{2}/g)?.map((byte) => parseInt(byte, 16));
-  if (!bytes) {
-    throw new Error('Failed to map hex string');
-  }
-  return new Uint8Array(bytes);
-}

package/test/parse.spec.ts

@@ -1,67 +0,0 @@
-import { describe, expect, it } from '@jest/globals';
-import { decomposeValue, parseSections } from '../src';
-
-describe('decomposeValue', () => {
-  it('returns decomposed sections for a valid value', () => {
-    const { header, payloadData, signature } = decomposeValue(
-      'OCMF|data|signature'
-    );
-    expect(header).toEqual('OCMF');
-    expect(payloadData).toEqual('data');
-    expect(signature).toEqual('signature');
-  });
-
-  it.each([
-    {
-      name: 'too few segments',
-      value: 'OCMF|data',
-    },
-    {
-      name: 'wrong header segment',
-      value: 'FOO|data|signature',
-    },
-    {
-      name: 'empty data payload segment',
-      value: 'OCMF||signature',
-    },
-    {
-      name: 'empty signature segment',
-      value: 'OCMF|data|',
-    },
-  ])('throws when $name', ({ value }) => {
-    expect(() => decomposeValue(value)).toThrow();
-  });
-});
-
-describe('parseSections', () => {
-  it('parses the sections', () => {
-    const { header, payloadData, signature } = parseSections({
-      header: 'OCMF',
-      payloadData: '{"FV":"1.0"}',
-      signature: '{"SD":"ABC"}',
-    });
-    expect(header).toEqual('OCMF');
-    expect(payloadData).toEqual({ FV: '1.0' });
-    expect(signature).toEqual({ SD: 'ABC' });
-  });
-
-  it('throws on invalid json in the data section', () => {
-    expect(() =>
-      parseSections({
-        header: 'OCMF',
-        payloadData: '{',
-        signature: '{"SD":"ABC"}',
-      })
-    ).toThrow();
-  });
-
-  it('throws on invalid json in the signature section', () => {
-    expect(() =>
-      parseSections({
-        header: 'OCMF',
-        payloadData: '{"FV":"1.0"}',
-        signature: '{',
-      })
-    ).toThrow();
-  });
-});

package/test/signer.spec.ts

@@ -1,81 +0,0 @@
-import { beforeEach, describe, expect, it } from '@jest/globals';
-import { CryptoAdapter, EcPrivateKey } from '@road-labs/ocmf-crypto';
-import { mock, MockProxy } from 'jest-mock-extended';
-import { CurveMismatchError, PayloadData, Signer } from '../src';
-import { hexToBytes } from 'test-commons';
-
-const payload: PayloadData = {
-  FV: '1.0',
-  GI: 'TEST',
-  GS: '1234567',
-  GV: '1.0.0',
-  PG: 'T1',
-  MV: 'MV',
-  MM: 'MM',
-  MS: '1234567',
-  MF: '1.0',
-  IS: true,
-  IL: 'VERIFIED',
-  IF: ['RFID_PLAIN', 'OCPP_RS_TLS'],
-  IT: 'ISO14443',
-  ID: '79A94A26862469',
-  CI: 'CSONE',
-  CT: 'CBIDC',
-  RD: [
-    {
-      TM: '2025-06-14T08:44:54,562+0100 S',
-      TX: 'B',
-      RV: 0.75727,
-      RI: '1-b',
-      RU: 'kWh',
-      ST: 'G',
-    },
-    {
-      TM: '2025-06-14T11:44:54,562+0100 S',
-      TX: 'E',
-      RV: 3.12961,
-      RI: '1-b',
-      RU: 'kWh',
-      ST: 'G',
-    },
-  ],
-};
-const hexPayloadData =
-  '7b224656223a22312e30222c224749223a2254455354222c224753223a2231323334353637222c224756223a22312e302e30222c225047223a225431222c224d56223a224d56222c224d4d223a224d4d222c224d53223a2231323334353637222c224d46223a22312e30222c224953223a747275652c22494c223a225645524946494544222c224946223a5b22524649445f504c41494e222c224f4350505f52535f544c53225d2c224954223a2249534f3134343433222c224944223a223739413934413236383632343639222c224349223a2243534f4e45222c224354223a224342494443222c225244223a5b7b22544d223a22323032352d30362d31345430383a34343a35342c3536322b303130302053222c225458223a2242222c225256223a302e37353732372c225249223a22312d62222c225255223a226b5768222c225354223a2247227d2c7b22544d223a22323032352d30362d31345431313a34343a35342c3536322b303130302053222c225458223a2245222c225256223a332e31323936312c225249223a22312d62222c225255223a226b5768222c225354223a2247227d5d7d';
-
-describe('Signer', () => {
-  let privateKey: MockProxy<EcPrivateKey>;
-  let crypto: MockProxy<CryptoAdapter>;
-  let signer: Signer;
-
-  beforeEach(() => {
-    privateKey = mock<EcPrivateKey>();
-    crypto = mock<CryptoAdapter>();
-    signer = new Signer(crypto);
-  });
-
-  it('throws if the private key curve does not align with the signature', async () => {
-    privateKey.getCurve.mockReturnValue('secp192r1');
-    await expect(() =>
-      signer.sign(payload, privateKey, 'ECDSA-secp256r1-SHA256')
-    ).rejects.toThrow(CurveMismatchError);
-  });
-
-  it('signs via the crypto adapter and returns a composed value', async () => {
-    privateKey.getCurve.mockReturnValue('secp256r1');
-    crypto.sign.mockReturnValue(new Uint8Array([0x01, 0x02, 0x03, 0x0a]));
-    const actual = await signer.sign(
-      payload,
-      privateKey,
-      'ECDSA-secp256r1-SHA256'
-    );
-    const expected = `OCMF|{"FV":"1.0","GI":"TEST","GS":"1234567","GV":"1.0.0","PG":"T1","MV":"MV","MM":"MM","MS":"1234567","MF":"1.0","IS":true,"IL":"VERIFIED","IF":["RFID_PLAIN","OCPP_RS_TLS"],"IT":"ISO14443","ID":"79A94A26862469","CI":"CSONE","CT":"CBIDC","RD":[{"TM":"2025-06-14T08:44:54,562+0100 S","TX":"B","RV":0.75727,"RI":"1-b","RU":"kWh","ST":"G"},{"TM":"2025-06-14T11:44:54,562+0100 S","TX":"E","RV":3.12961,"RI":"1-b","RU":"kWh","ST":"G"}]}|{"SA":"ECDSA-secp256r1-SHA256","SD":"0102030A"}`;
-    expect(actual).toEqual(expected);
-    expect(crypto.sign).toHaveBeenCalledWith(
-      hexToBytes(hexPayloadData),
-      privateKey,
-      'SHA-256',
-      'sigvalue-der'
-    );
-  });
-});

package/test/verifier.spec.ts

@@ -1,111 +0,0 @@
-import { beforeEach, describe, expect, it } from '@jest/globals';
-import { CryptoAdapter, EcPublicKey } from '@road-labs/ocmf-crypto';
-import { mock, MockProxy } from 'jest-mock-extended';
-import {
-  CurveMismatchError,
-  UnknownSignatureEncoding,
-  UnknownSignatureMimeType,
-  Verifier,
-} from '../src';
-import { hexToBytes } from 'test-commons';
-
-const signedData = `OCMF|{"FV":"1.0","GI":"TEST","GS":"1234567","GV":"1.0.0","PG":"T1","MV":"MV","MM":"MM","MS":"1234567","MF":"1.0","IS":true,"IL":"VERIFIED","IF":["RFID_PLAIN","OCPP_RS_TLS"],"IT":"ISO14443","ID":"79A94A26862469","CI":"CSONE","CT":"CBIDC","RD":[{"TM":"2025-06-14T08:44:54,562+0100 S","TX":"B","RV":0.75727,"RI":"1-b","RU":"kWh","ST":"G"},{"TM":"2025-06-14T11:44:54,562+0100 S","TX":"E","RV":3.12961,"RI":"1-b","RU":"kWh","ST":"G"}]}|{"SA":"ECDSA-secp256r1-SHA256","SD":"0102030A"}`;
-const hexPayloadData =
-  '7b224656223a22312e30222c224749223a2254455354222c224753223a2231323334353637222c224756223a22312e302e30222c225047223a225431222c224d56223a224d56222c224d4d223a224d4d222c224d53223a2231323334353637222c224d46223a22312e30222c224953223a747275652c22494c223a225645524946494544222c224946223a5b22524649445f504c41494e222c224f4350505f52535f544c53225d2c224954223a2249534f3134343433222c224944223a223739413934413236383632343639222c224349223a2243534f4e45222c224354223a224342494443222c225244223a5b7b22544d223a22323032352d30362d31345430383a34343a35342c3536322b303130302053222c225458223a2242222c225256223a302e37353732372c225249223a22312d62222c225255223a226b5768222c225354223a2247227d2c7b22544d223a22323032352d30362d31345431313a34343a35342c3536322b303130302053222c225458223a2245222c225256223a332e31323936312c225249223a22312d62222c225255223a226b5768222c225354223a2247227d5d7d';
-
-describe('Verifier', () => {
-  let publicKey: MockProxy<EcPublicKey>;
-  let crypto: MockProxy<CryptoAdapter>;
-  let verifier: Verifier;
-
-  beforeEach(() => {
-    publicKey = mock<EcPublicKey>();
-    crypto = mock<CryptoAdapter>();
-    verifier = new Verifier(crypto);
-  });
-
-  it('throws if the private key curve does not align with the signature', async () => {
-    publicKey.getCurve.mockReturnValue('secp192r1');
-    await expect(() =>
-      verifier.parseAndVerify(signedData, publicKey)
-    ).rejects.toThrow(CurveMismatchError);
-  });
-
-  it('throws if the signature is encoded with an unknown type', async () => {
-    publicKey.getCurve.mockReturnValue('secp256r1');
-    const signedData = `OCMF|{"FV":"1.0"}|{"SE":"foo","SA":"ECDSA-secp256r1-SHA256","SD":"0102030A"}`;
-
-    await expect(() =>
-      verifier.parseAndVerify(signedData, publicKey)
-    ).rejects.toThrow(UnknownSignatureEncoding);
-  });
-
-  it('throws if the signature is encoded with an unknown mime type', async () => {
-    publicKey.getCurve.mockReturnValue('secp256r1');
-    const signedData = `OCMF|{"FV":"1.0"}|{"SM":"foo","SA":"ECDSA-secp256r1-SHA256","SD":"0102030A"}`;
-
-    await expect(() =>
-      verifier.parseAndVerify(signedData, publicKey)
-    ).rejects.toThrow(UnknownSignatureMimeType);
-  });
-
-  it('signs via the crypto adapter and returns a composed value', async () => {
-    publicKey.getCurve.mockReturnValue('secp256r1');
-    crypto.verify.mockReturnValue(true);
-    const actual = await verifier.parseAndVerify(signedData, publicKey);
-    const expected = {
-      verified: true,
-      value: {
-        header: 'OCMF',
-        payloadData: {
-          FV: '1.0',
-          GI: 'TEST',
-          GS: '1234567',
-          GV: '1.0.0',
-          PG: 'T1',
-          MV: 'MV',
-          MM: 'MM',
-          MS: '1234567',
-          MF: '1.0',
-          IS: true,
-          IL: 'VERIFIED',
-          IF: ['RFID_PLAIN', 'OCPP_RS_TLS'],
-          IT: 'ISO14443',
-          ID: '79A94A26862469',
-          CI: 'CSONE',
-          CT: 'CBIDC',
-          RD: [
-            {
-              TM: '2025-06-14T08:44:54,562+0100 S',
-              TX: 'B',
-              RV: 0.75727,
-              RI: '1-b',
-              RU: 'kWh',
-              ST: 'G',
-            },
-            {
-              TM: '2025-06-14T11:44:54,562+0100 S',
-              TX: 'E',
-              RV: 3.12961,
-              RI: '1-b',
-              RU: 'kWh',
-              ST: 'G',
-            },
-          ],
-        },
-        signature: {
-          SA: 'ECDSA-secp256r1-SHA256',
-          SD: '0102030A',
-        },
-      },
-    };
-    expect(actual).toEqual(expected);
-    expect(crypto.verify).toHaveBeenCalledWith(
-      hexToBytes('0102030A'),
-      hexToBytes(hexPayloadData),
-      publicKey,
-      'SHA-256',
-      'sigvalue-der'
-    );
-  });
-});

package/tsconfig.json

@@ -1,4 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "include": ["src/**/*"]
-}