@road-labs/ocmf 0.0.1

package/build/cjs/errors.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownSignatureMimeType = exports.UnknownSignatureEncoding = exports.CurveMismatchError = void 0;
+class CurveMismatchError extends Error {
+}
+exports.CurveMismatchError = CurveMismatchError;
+class UnknownSignatureEncoding extends Error {
+}
+exports.UnknownSignatureEncoding = UnknownSignatureEncoding;
+class UnknownSignatureMimeType extends Error {
+}
+exports.UnknownSignatureMimeType = UnknownSignatureMimeType;

package/build/cjs/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Verifier = exports.Signer = void 0;
+__exportStar(require("./types"), exports);
+__exportStar(require("./parse"), exports);
+__exportStar(require("./signature"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./verifier"), exports);
+__exportStar(require("./signer"), exports);
+var signer_1 = require("./signer");
+Object.defineProperty(exports, "Signer", { enumerable: true, get: function () { return __importDefault(signer_1).default; } });
+var verifier_1 = require("./verifier");
+Object.defineProperty(exports, "Verifier", { enumerable: true, get: function () { return __importDefault(verifier_1).default; } });

package/build/cjs/parse.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decomposeValue = decomposeValue;
+exports.parseSections = parseSections;
+function decomposeValue(value) {
+    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,
+    };
+}
+function parseSections(sections) {
+    return {
+        header: sections.header,
+        payloadData: JSON.parse(sections.payloadData),
+        signature: JSON.parse(sections.signature),
+    };
+}

package/build/cjs/signature.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signatureMethodFromId = signatureMethodFromId;
+const signatureMethods = [
+    {
+        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',
+    },
+];
+function signatureMethodFromId(id) {
+    const signatureMethod = signatureMethods.find((signature) => signature.id === id);
+    if (!signatureMethod) {
+        throw new Error(`Unsupported signature method: ${id}`);
+    }
+    return signatureMethod;
+}

package/build/cjs/signer.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const signature_1 = require("./signature");
+const types_1 = require("./types");
+const errors_1 = require("./errors");
+class Signer {
+    crypto;
+    constructor(crypto) {
+        this.crypto = crypto;
+    }
+    async sign(payload, privateKey, signatureMethodId) {
+        const signatureMethod = (0, signature_1.signatureMethodFromId)(signatureMethodId);
+        if (signatureMethod.curve !== privateKey.getCurve()) {
+            throw new errors_1.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(),
+        });
+        return [types_1.Header, payloadDataSegment, signatureSegment].join('|');
+    }
+}
+exports.default = Signer;
+function bytesToHex(bytes) {
+    return Array.from(bytes)
+        .map((x) => x.toString(16).padStart(2, '0'))
+        .join('');
+}

package/build/cjs/types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Header = void 0;
+exports.Header = 'OCMF';

package/build/cjs/verifier.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const signature_1 = require("./signature");
+const parse_1 = require("./parse");
+const errors_1 = require("./errors");
+class Verifier {
+    crypto;
+    constructor(crypto) {
+        this.crypto = crypto;
+    }
+    async parseAndVerify(rawSignedData, publicKey) {
+        const sections = (0, parse_1.decomposeValue)(rawSignedData);
+        const signedData = (0, parse_1.parseSections)(sections);
+        const { signature } = signedData;
+        const signatureMethod = (0, signature_1.signatureMethodFromId)(signature.SA);
+        if (signatureMethod.curve !== publicKey.getCurve()) {
+            throw new errors_1.CurveMismatchError(`Expected ${publicKey.getCurve()}, actual ${signatureMethod.curve}`);
+        }
+        if (signature.SE && signature.SE !== 'hex') {
+            throw new errors_1.UnknownSignatureEncoding('Only hex encoded signatures are supported');
+        }
+        if (signature.SM && signature.SM !== 'application/x-der') {
+            throw new errors_1.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,
+        };
+    }
+}
+exports.default = Verifier;
+function hexToBytes(hex) {
+    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/build/es2022/errors.js

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

package/build/es2022/index.js

@@ -0,0 +1,8 @@
+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/build/es2022/parse.js

@@ -0,0 +1,30 @@
+export function decomposeValue(value) {
+    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) {
+    return {
+        header: sections.header,
+        payloadData: JSON.parse(sections.payloadData),
+        signature: JSON.parse(sections.signature),
+    };
+}

package/build/es2022/signature.js

@@ -0,0 +1,51 @@
+const signatureMethods = [
+    {
+        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) {
+    const signatureMethod = signatureMethods.find((signature) => signature.id === id);
+    if (!signatureMethod) {
+        throw new Error(`Unsupported signature method: ${id}`);
+    }
+    return signatureMethod;
+}

package/build/es2022/signer.js

@@ -0,0 +1,29 @@
+import { signatureMethodFromId } from './signature';
+import { Header } from './types';
+import { CurveMismatchError } from './errors';
+export default class Signer {
+    crypto;
+    constructor(crypto) {
+        this.crypto = crypto;
+    }
+    async sign(payload, privateKey, signatureMethodId) {
+        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(),
+        });
+        return [Header, payloadDataSegment, signatureSegment].join('|');
+    }
+}
+function bytesToHex(bytes) {
+    return Array.from(bytes)
+        .map((x) => x.toString(16).padStart(2, '0'))
+        .join('');
+}

package/build/es2022/types.js

@@ -0,0 +1 @@
+export const Header = 'OCMF';

package/build/es2022/verifier.js

@@ -0,0 +1,44 @@
+import { signatureMethodFromId } from './signature';
+import { decomposeValue, parseSections } from './parse';
+import { CurveMismatchError, UnknownSignatureEncoding, UnknownSignatureMimeType, } from './errors';
+export default class Verifier {
+    crypto;
+    constructor(crypto) {
+        this.crypto = crypto;
+    }
+    async parseAndVerify(rawSignedData, publicKey) {
+        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) {
+    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/build/types/errors.d.ts

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

package/build/types/index.d.ts

@@ -0,0 +1,8 @@
+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/build/types/parse.d.ts

@@ -0,0 +1,9 @@
+import { Header, SignedData } from './types';
+interface Sections {
+    header: Header;
+    payloadData: string;
+    signature: string;
+}
+export declare function decomposeValue(value: string): Sections;
+export declare function parseSections(sections: Sections): SignedData;
+export {};

package/build/types/signature.d.ts

@@ -0,0 +1,9 @@
+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;
+};
+export declare function signatureMethodFromId(id: SignatureMethodId): SignatureMethod;

package/build/types/signer.d.ts

@@ -0,0 +1,13 @@
+import { SignatureMethodId } from './signature';
+import { PayloadData } from './types';
+import { CryptoAdapter, EcPrivateKey } from '@road-labs/ocmf-crypto';
+export default class Signer {
+    private readonly crypto;
+    constructor(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
+     */
+    sign(payload: PayloadData, privateKey: EcPrivateKey, signatureMethodId: SignatureMethodId): Promise<string>;
+}

package/build/types/types.d.ts

@@ -0,0 +1,51 @@
+import { SignatureMethodId } from './signature';
+export interface SignedData {
+    header: Header;
+    payloadData: PayloadData;
+    signature: Signature;
+}
+export type Header = 'OCMF';
+export declare const Header: Header;
+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/build/types/verifier.d.ts

@@ -0,0 +1,16 @@
+import { SignedData } from './types';
+import { CryptoAdapter, EcPublicKey } from '@road-labs/ocmf-crypto';
+export interface ParseAndVerifyResult {
+    verified: boolean;
+    value?: SignedData;
+}
+export default class Verifier {
+    private readonly crypto;
+    constructor(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.
+     */
+    parseAndVerify(rawSignedData: string, publicKey: EcPublicKey): Promise<ParseAndVerifyResult>;
+}

package/jest.config.js

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

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@road-labs/ocmf",
+  "version": "0.0.1",
+  "main": "build/cjs/index.js",
+  "module": "build/es2022/index.js",
+  "types": "build/types/index.d.ts",
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "description": "",
+  "devDependencies": {
+    "@jest/globals": "^30.0.0",
+    "@types/node": "^22.15.30",
+    "jest": "^30.0.0",
+    "rimraf": "^6.0.1",
+    "ts-jest": "^29.4.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3",
+    "jest-mock-extended": "^4.0.0",
+    "test-commons": "0.0.1"
+  },
+  "dependencies": {
+    "@road-labs/ocmf-crypto": "0.0.1"
+  },
+  "scripts": {
+    "clear": "rimraf build",
+    "build": "pnpm run build:module && pnpm run build:types",
+    "build:module": "pnpm run build:cjs && pnpm run build:es2022",
+    "build:cjs": "tsc -p tsconfig.json --removeComments --module commonjs --outDir build/cjs",
+    "build:es2022": "tsc -p tsconfig.json --removeComments --module es2022 --outDir build/es2022",
+    "prebuild:types": "rimraf build/types",
+    "build:types": "tsc -p tsconfig.json --outDir build/types --declaration --emitDeclarationOnly",
+    "rebuild": "pnpm run clear && pnpm run build",
+    "test": "jest"
+  }
+}

package/src/errors.ts

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

package/src/index.ts

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,72 @@
+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

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,55 @@
+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

@@ -0,0 +1,83 @@
+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

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,81 @@
+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

@@ -0,0 +1,111 @@
+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

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