@microsoft/ccf-app 7.0.0-dev0 → 7.0.0-dev10

package/consensus.d.ts

@@ -10,4 +10,4 @@ export declare const getStatusForTxId: (view: number, seqno: number) => import("
  * @inheritDoc global!CCFConsensus.getViewForSeqno
  */
 export declare const getViewForSeqno: (seqno: number) => number | null;
-export { TransactionStatus } from "./global";
+export type { TransactionStatus } from "./global";

package/converters.js

@@ -20,6 +20,7 @@
  * @module
  */
 import { ccf } from "./global.js";
+import { toArrayBuffer } from "./utils.js";
 function checkBoolean(val) {
     if (typeof val !== "boolean") {
         throw new TypeError(`Value ${val} is not a boolean`);
@@ -230,7 +231,7 @@ class TypedArrayConverter {
         this.clazz = clazz;
     }
     encode(val) {
-        return val.buffer.slice(val.byteOffset, val.byteOffset + val.byteLength);
+        return toArrayBuffer(val.buffer.slice(val.byteOffset, val.byteOffset + val.byteLength));
     }
     decode(buf) {
         return new this.clazz(buf);

package/crypto.d.ts

@@ -90,4 +90,4 @@ export declare const pubEddsaJwkToPem: (jwk: import("./global.js").JsonWebKeyEdD
  * @inheritDoc global!CCFCrypto.eddsaJwkToPem
  */
 export declare const eddsaJwkToPem: (jwk: import("./global.js").JsonWebKeyEdDSAPrivate) => string;
-export { WrapAlgoParams, AesKwpParams, RsaOaepParams, RsaOaepAesKwpParams, CryptoKeyPair, DigestAlgorithm, SigningAlgorithm, } from "./global";
+export type { WrapAlgoParams, AesKwpParams, RsaOaepParams, RsaOaepAesKwpParams, CryptoKeyPair, DigestAlgorithm, SigningAlgorithm, } from "./global";

package/endpoints.d.ts

@@ -4,7 +4,7 @@
  *
  * @module
  */
-import { JsonCompatible } from "./global.js";
+import { type JsonCompatible } from "./global.js";
 /**
  * The body of a request.
  *

package/historical.d.ts

@@ -10,4 +10,4 @@ export declare const getStateRange: (handle: number, startSeqno: number, endSeqn
  * @inheritDoc global!CCFHistorical.dropCachedStates
  */
 export declare const dropCachedStates: (handle: number) => boolean;
-export { HistoricalState, Receipt, Proof, ProofElement } from "./global";
+export type { HistoricalState, Receipt, Proof, ProofElement } from "./global";

package/kv.d.ts

@@ -33,8 +33,8 @@
  *
  * @module
  */
-import { KvMap } from "./global.js";
-import { DataConverter } from "./converters.js";
+import { type KvMap } from "./global.js";
+import { type DataConverter } from "./converters.js";
 export declare class TypedKvMap<K, V> {
     private kv;
     private kt;
@@ -92,4 +92,4 @@ export declare function typedKvSet<K, V>(nameOrMap: string | KvMap, kt: DataConv
  * @inheritDoc global!CCF.kv
  */
 export declare const rawKv: import("./global.js").KvMaps;
-export { KvMap, KvSet, KvMaps } from "./global";
+export type { KvMap, KvSet, KvMaps } from "./global";

package/kv.js

@@ -36,6 +36,7 @@
  * @module
  */
 import { ccf } from "./global.js";
+import {} from "./converters.js";
 export class TypedKvMap {
     constructor(kv, kt, vt) {
         this.kv = kv;

package/package.json

@@ -1,6 +1,10 @@
 {
   "name": "@microsoft/ccf-app",
-  "version": "7.0.0-dev0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/microsoft/ccf"
+  },
+  "version": "7.0.0-dev10",
   "description": "CCF app support package",
   "main": "index.js",
   "files": [
@@ -20,19 +24,21 @@
   "devDependencies": {
     "@types/chai": "^5.0.0",
     "@types/mocha": "^10.0.0",
-    "@types/node": "^24.0.3",
+    "@types/node": "^25.0.2",
     "@types/node-forge": "^1.0.0",
-    "chai": "^5.0.0",
-    "colors": "1.4.0",
-    "cross-env": "^7.0.3",
+    "chai": "^6.0.1",
+    "cross-env": "^10.0.0",
     "get-func-name": "3.0.0",
-    "mocha": "^11.0.1",
+    "mocha": "^11.7.5",
     "node-forge": "^1.2.0",
-    "ts-node": "^10.4.0",
-    "typedoc": "^0.28.1",
-    "typescript": "^5.7.2"
+    "ts-node": "^10.9.2",
+    "typedoc": "^0.28.10",
+    "typescript": "^5.9.2"
   },
   "bin": {
     "ccf-build-bundle": "scripts/build_bundle.js"
+  },
+  "dependencies": {
+    "colors": "1.4.0"
   }
 }

package/polyfill.js

@@ -16,6 +16,7 @@
  */
 import * as jscrypto from "crypto";
 import { TextEncoder, TextDecoder } from "util";
+import { toArrayBuffer } from "./utils.js";
 // JavaScript's Map uses reference equality for non-primitive types,
 // whereas CCF compares the content of the ArrayBuffer.
 // To achieve CCF's semantics, all keys are base64-encoded.
@@ -98,7 +99,7 @@ class CCFPolyfill {
                         .toLowerCase();
                     const hmac = jscrypto.createHmac(hashAlg, key);
                     hmac.update(new Uint8Array(data));
-                    return hmac.digest();
+                    return nodeBufToArrBuf(hmac.digest());
                 }
                 let padding = undefined;
                 const privKey = jscrypto.createPrivateKey(key);
@@ -124,17 +125,17 @@ class CCFPolyfill {
                     throw new Error("unrecognized signing algorithm");
                 }
                 if (algorithm.name === "EdDSA") {
-                    return jscrypto.sign(null, new Uint8Array(data), privKey);
+                    return nodeBufToArrBuf(jscrypto.sign(null, new Uint8Array(data), privKey));
                 }
                 const hashAlg = algorithm.hash.replace("-", "").toLowerCase();
                 const signer = jscrypto.createSign(hashAlg);
                 signer.update(new Uint8Array(data));
-                return signer.sign({
+                return nodeBufToArrBuf(signer.sign({
                     key: privKey,
                     dsaEncoding: "ieee-p1363",
                     padding: padding,
                     saltLength: algorithm.saltLength ?? 0,
-                });
+                }));
             },
             verifySignature(algorithm, key, signature, data) {
                 let padding = undefined;
@@ -383,8 +384,14 @@ class CCFPolyfill {
                 const jwk = key.export({
                     format: "jwk",
                 });
-                jwk.kid = kid;
-                return jwk;
+                const jwkWithKid = {
+                    kty: jwk.kty,
+                    crv: jwk.crv,
+                    x: jwk.x,
+                    y: jwk.y,
+                    kid: kid,
+                };
+                return jwkWithKid;
             },
             pemToJwk(pem, kid) {
                 const key = jscrypto.createPrivateKey({
@@ -393,8 +400,15 @@ class CCFPolyfill {
                 const jwk = key.export({
                     format: "jwk",
                 });
-                jwk.kid = kid;
-                return jwk;
+                const jwkWithKid = {
+                    kty: jwk.kty,
+                    crv: jwk.crv,
+                    x: jwk.x,
+                    y: jwk.y,
+                    d: jwk.d,
+                    kid: kid,
+                };
+                return jwkWithKid;
             },
             pubRsaPemToJwk(pem, kid) {
                 const key = jscrypto.createPublicKey({
@@ -403,8 +417,13 @@ class CCFPolyfill {
                 const jwk = key.export({
                     format: "jwk",
                 });
-                jwk.kid = kid;
-                return jwk;
+                const jwkWithKid = {
+                    kty: jwk.kty,
+                    n: jwk.n,
+                    e: jwk.e,
+                    kid: kid,
+                };
+                return jwkWithKid;
             },
             rsaPemToJwk(pem, kid) {
                 const key = jscrypto.createPrivateKey({
@@ -413,8 +432,19 @@ class CCFPolyfill {
                 const jwk = key.export({
                     format: "jwk",
                 });
-                jwk.kid = kid;
-                return jwk;
+                const jwkWithKid = {
+                    kty: jwk.kty,
+                    n: jwk.n,
+                    e: jwk.e,
+                    d: jwk.d,
+                    p: jwk.p,
+                    q: jwk.q,
+                    dp: jwk.dp,
+                    dq: jwk.dq,
+                    qi: jwk.qi,
+                    kid: kid,
+                };
+                return jwkWithKid;
             },
             pubEddsaPemToJwk(pem, kid) {
                 const key = jscrypto.createPublicKey({
@@ -423,8 +453,13 @@ class CCFPolyfill {
                 const jwk = key.export({
                     format: "jwk",
                 });
-                jwk.kid = kid;
-                return jwk;
+                const jwkWithKid = {
+                    kty: jwk.kty,
+                    crv: jwk.crv,
+                    x: jwk.x,
+                    kid: kid,
+                };
+                return jwkWithKid;
             },
             eddsaPemToJwk(pem, kid) {
                 const key = jscrypto.createPrivateKey({
@@ -433,8 +468,14 @@ class CCFPolyfill {
                 const jwk = key.export({
                     format: "jwk",
                 });
-                jwk.kid = kid;
-                return jwk;
+                const jwkWithKid = {
+                    kty: jwk.kty,
+                    crv: jwk.crv,
+                    x: jwk.x,
+                    d: jwk.d,
+                    kid: kid,
+                };
+                return jwkWithKid;
             },
             pubJwkToPem(jwk) {
                 const key = jscrypto.createPublicKey({
@@ -539,7 +580,7 @@ function nodeBufToArrBuf(buf) {
     return arrBuf;
 }
 function typedArrToArrBuf(ta) {
-    return ta.buffer.slice(ta.byteOffset, ta.byteOffset + ta.byteLength);
+    return toArrayBuffer(ta.buffer.slice(ta.byteOffset, ta.byteOffset + ta.byteLength));
 }
 function base64(buf) {
     return Buffer.from(buf).toString("base64");

package/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function toUint8ArrayBuffer(buffer: Uint8Array<ArrayBufferLike>): Uint8Array<ArrayBuffer>;
+export declare function toArrayBuffer(buffer: ArrayBufferLike | Buffer | Uint8Array): ArrayBuffer;

package/utils.js

@@ -0,0 +1,32 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the Apache 2.0 License.
+// toUint8ArrayBuffer(buffer) converts the buffer into a Uint8Array<ArrayBuffer>
+// If the input is already a Uint8Array<ArrayBuffer>, it returns it directly
+// Otherwise it will copy the data into a new Uint8Array<ArrayBuffer>
+export function toUint8ArrayBuffer(buffer) {
+    if (buffer.buffer instanceof ArrayBuffer) {
+        return buffer;
+    }
+    if (buffer.buffer instanceof SharedArrayBuffer) {
+        const view = new Uint8Array(new ArrayBuffer(buffer.buffer.byteLength));
+        view.set(buffer);
+        return new Uint8Array(view.buffer, buffer.byteOffset, buffer.byteLength);
+    }
+    throw new Error("Unsupported buffer type");
+}
+// toArrayBuffer(buffer) converts the buffer to an ArrayBuffer
+// If the input is already an ArrayBuffer, it returns it directly
+// Otherwise it will copy the data into a new ArrayBuffer
+export function toArrayBuffer(buffer) {
+    if (buffer instanceof ArrayBuffer) {
+        return buffer;
+    }
+    if (buffer instanceof SharedArrayBuffer) {
+        const view = new Uint8Array(buffer);
+        return toUint8ArrayBuffer(view).buffer;
+    }
+    if (buffer instanceof Uint8Array || buffer instanceof Buffer) {
+        return toArrayBuffer(buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength));
+    }
+    throw new Error("Unsupported buffer type");
+}