hd-wallet-wasm 2.1.1 → 2.1.2

package/dist/runtime/aligned.mjs

@@ -442,9 +442,14 @@ export class AlignedSigner {
   signBatch(privateKey, hashes, curve = AlignedCurve.SECP256K1) {
     const wasm = this.#wasm;
     V.curve(curve, BATCH_CURVES);
-    if (!Array.isArray(hashes) || hashes.length > MAX_BATCH) {
+    // The array and each entry are read once (a Proxy or a getter could answer
+    // a second read differently); only the copies are used below.
+    const hashCount = Array.isArray(hashes) ? hashes.length : -1;
+    if (!Number.isInteger(hashCount) || hashCount < 0 || hashCount > MAX_BATCH) {
       throw new AlignedError(AlignedErrorCode.INVALID_ARGUMENT, `hashes must be an array of at most ${MAX_BATCH}`);
     }
+    const hashCopies = [];
+    for (let i = 0; i < hashCount; i++) hashCopies.push(V.snapshot(hashes[i], 'hash'));
     // The request holds a 32-byte key: secp256k1 and P-256 keys must be
     // 0 < d < n; Ed25519 seeds are any 32 bytes. P-384 and X25519 entries
     // report NOT_SUPPORTED.
@@ -453,8 +458,8 @@ export class AlignedSigner {
     } else {
       V.bytesOfLength(privateKey, 32, 'privateKey', AlignedErrorCode.INVALID_PRIVATE_KEY);
     }
-    for (const hash of hashes) V.bytesOfLength(hash, 32, 'hash');
-    const count = hashes.length;
+    for (const hash of hashCopies) V.bytesOfLength(hash, 32, 'hash');
+    const count = hashCopies.length;
 
     // Allocate request
     const requestPtr = allocZeroed(wasm, BATCHSIGNREQUEST_SIZE);
@@ -474,7 +479,7 @@ export class AlignedSigner {
         for (let i = 0; i < count; i++) {
           const entry = hashesArray.at(i);
           entry.index = i;
-          entry.hash_data.set(hashes[i]);
+          entry.hash_data.set(hashCopies[i]);
         }
 
         // Allocate results
@@ -533,38 +538,43 @@ export class AlignedSigner {
   verifyBatch(publicKey, entries, curve = AlignedCurve.SECP256K1) {
     const wasm = this.#wasm;
     V.curve(curve, BATCH_CURVES);
-    if (!Array.isArray(entries) || entries.length > MAX_BATCH) {
+    // The array, each entry and each field are read once (a Proxy or a getter
+    // could answer a second read differently); only the copies are used below.
+    const entryCount = Array.isArray(entries) ? entries.length : -1;
+    if (!Number.isInteger(entryCount) || entryCount < 0 || entryCount > MAX_BATCH) {
       throw new AlignedError(AlignedErrorCode.INVALID_ARGUMENT, `entries must be an array of at most ${MAX_BATCH}`);
     }
     // Types are programmer errors (throw); wrong lengths or an invalid key
     // only make the affected entries invalid.
-    V.bytes(publicKey, 'publicKey');
-    for (const entry of entries) {
+    const publicKeyCopy = V.snapshot(publicKey, 'publicKey');
+    const entryCopies = [];
+    for (let i = 0; i < entryCount; i++) {
+      const entry = entries[i];
       if (entry === null || typeof entry !== 'object') {
         throw new AlignedError(AlignedErrorCode.INVALID_ARGUMENT, 'each entry must be { hash, signature }');
       }
-      V.bytes(entry.hash, 'hash');
-      V.bytes(entry.signature, 'signature');
+      const { hash, signature } = entry;
+      entryCopies.push({ hash: V.snapshot(hash, 'hash'), signature: V.snapshot(signature, 'signature') });
     }
-    const count = entries.length;
+    const count = entryCopies.length;
 
     // The request holds a 33-byte key: a compressed secp256k1 or P-256 key,
     // or an Ed25519 key after one padding byte.
     let keyBytes = null;
     if (curve === AlignedCurve.ED25519) {
-      if (publicKey.length === 32) {
+      if (publicKeyCopy.length === 32) {
         keyBytes = new Uint8Array(33);
-        keyBytes.set(publicKey, 1);
-      } else if (publicKey.length === 33) {
-        keyBytes = publicKey;
+        keyBytes.set(publicKeyCopy, 1);
+      } else if (publicKeyCopy.length === 33) {
+        keyBytes = publicKeyCopy;
       }
     } else if (curve === AlignedCurve.SECP256K1 || curve === AlignedCurve.P256) {
-      if (V.isPublicKey(wasm, publicKey, curve, [33])) keyBytes = publicKey;
+      if (V.isPublicKey(wasm, publicKeyCopy, curve, [33])) keyBytes = publicKeyCopy;
     } else {
       // P-384 / X25519: the export reports NOT_SUPPORTED for every entry.
       keyBytes = new Uint8Array(33);
     }
-    const entryValid = entries.map((entry) => keyBytes !== null &&
+    const entryValid = entryCopies.map((entry) => keyBytes !== null &&
       entry.hash.length === 32 && entry.signature.length === 64);
 
     // Allocate request
@@ -587,8 +597,8 @@ export class AlignedSigner {
           const view = entriesArray.at(i);
           view.index = i;
           if (entryValid[i]) {
-            view.hash_data.set(entries[i].hash);
-            view.signature_data.set(entries[i].signature);
+            view.hash_data.set(entryCopies[i].hash);
+            view.signature_data.set(entryCopies[i].signature);
           }
         }
 

package/dist/runtime/index.d.ts

@@ -12,8 +12,16 @@
 // Import aligned API types
 import { AlignedAPI } from './aligned.js';
 
-export type BinaryLike = Uint8Array | ArrayBuffer | ArrayBufferView;
-export type X509CertificateInput = string | BinaryLike;
+/**
+ * Binary input to every wallet API: a Uint8Array (Node Buffers included) of
+ * this realm. A DataView, an ArrayBuffer, another typed array, a detached or
+ * cross-realm array is refused.
+ */
+export type BinaryLike = Uint8Array;
+/** A PEM string or its bytes, or DER bytes. */
+export type X509CertificateInput = string | Uint8Array;
+/** What an SDN plugin capability callback may return (it is copied to a Uint8Array). */
+export type PluginBinaryLike = Uint8Array | ArrayBuffer | ArrayBufferView;
 
 export interface SdnPluginTypeRef {
   schemaName: string | null;
@@ -113,7 +121,7 @@ export interface SdnPluginInvocationResult {
 }
 
 export interface SdnPluginCapabilities {
-  randomBytes?: (length: number, context?: Record<string, unknown>) => BinaryLike;
+  randomBytes?: (length: number, context?: Record<string, unknown>) => PluginBinaryLike;
   /**
    * Wallet-held signer for sign_detached. For secp256k1 it receives the message
    * (digest is null) and must return ECDSA over SHA-256(messageBytes), hashed once.
@@ -124,8 +132,8 @@ export interface SdnPluginCapabilities {
     messageBytes: Uint8Array;
     digest: Uint8Array | null;
   }) => {
-    signature: BinaryLike;
-    publicKey: BinaryLike;
+    signature: PluginBinaryLike;
+    publicKey: PluginBinaryLike;
     algorithm?: string;
   };
 }
@@ -818,7 +826,12 @@ export interface BitcoinTxBuilder {
 
 export interface BitcoinTx {
   addInput(txid: string, vout: number, sequence?: number): this;
-  addOutput(address: string, amount: bigint): this;
+  /**
+   * Pay `address`: P2PKH, P2SH, P2WPKH (v0, 20 bytes), P2WSH (v0, 32 bytes)
+   * or P2TR (v1, 32 bytes) of `network` (mainnet by default). Any other
+   * address, or one of the other network, throws (BIP-350).
+   */
+  addOutput(address: string, amount: bigint, network?: Network): this;
   sign(inputIndex: number, privateKey: Uint8Array, redeemScript?: Uint8Array): this;
   serialize(): Uint8Array;
   getTxid(): string;
@@ -867,6 +880,11 @@ export interface EthereumAPI {
   tx: EthereumTxBuilder;
 }
 
+/**
+ * `nonce` and `chainId` are required: a missing nonce or chainId, or a chainId
+ * outside 1 to 2^63 - 37 (EIP-2294), throws (an explicit nonce 0 is valid).
+ * Each field is read once.
+ */
 export interface EthereumTxBuilder {
   create(params: {
     nonce: number;
@@ -1044,7 +1062,7 @@ export interface UtilsAPI {
 
 export interface X509WalletAttestationOptions {
   curve: Curve;
-  privateKey: BinaryLike;
+  privateKey: Uint8Array;
   keyLabel?: string;
   commentPrefix?: string;
 }
@@ -1090,22 +1108,22 @@ export interface X509Pkcs12Bundle {
 export interface X509API {
   isAvailable(): boolean;
   generatePrivateKey(curve: Curve): Uint8Array;
-  exportPrivateKeyPem(curve: Curve, privateKey: BinaryLike): string;
+  exportPrivateKeyPem(curve: Curve, privateKey: Uint8Array): string;
   importPrivateKeyPem(curve: Curve, pem: string): Uint8Array;
   createSelfSignedCertificate(
     options: X509CertificateOptions,
     certificateCurve: Curve,
-    certificatePrivateKey: BinaryLike,
+    certificatePrivateKey: Uint8Array,
     outputEncoding?: X509Encoding
   ): string | Uint8Array;
   issueCertificate(
     options: X509CertificateOptions,
     issuerCurve: Curve,
-    issuerPrivateKey: BinaryLike,
+    issuerPrivateKey: Uint8Array,
     issuerCertificate: X509CertificateInput,
     issuerCertificateEncoding: X509Encoding,
     subjectCurve: Curve,
-    subjectPrivateKey: BinaryLike,
+    subjectPrivateKey: Uint8Array,
     outputEncoding?: X509Encoding
   ): string | Uint8Array;
   convertCertificate(
@@ -1119,12 +1137,12 @@ export interface X509API {
     certificate: X509CertificateInput,
     certificateEncoding: X509Encoding,
     privateKeyCurve: Curve,
-    privateKey: BinaryLike,
+    privateKey: Uint8Array,
     password: string,
     friendlyName?: string,
     chainPem?: X509CertificateInput
   ): Uint8Array;
-  importPkcs12(pkcs12Bundle: BinaryLike, password: string): X509Pkcs12Bundle;
+  importPkcs12(pkcs12Bundle: Uint8Array, password: string): X509Pkcs12Bundle;
 }
 
 // =============================================================================