Merge pull request #1893 from cosmos/uint8array-arraybuffer

Return Uint8Array<ArrayBuffer> whenever we create an Uint8Array

Author: webmaster128

CHANGELOG.md

@@ -6,6 +6,48 @@ and this project adheres to
 
 ## [Unreleased]
 
+### Added
+
+- @cosmjs/encoding: Add `fixUint8Array` which takes an
+  `Uint8Array<ArrayBufferLike>` and returns `Uint8Array<ArrayBuffer>`. This can
+  be used in cases where a data source returns an `Uint8Array` without
+  specifying the buffer type but you need an `ArrayBuffer`. Internally it might
+  perform a copy but in the vast majority of cases it will just change the type
+  after ensuring `ArrayBuffer` is used. ([#1883])
+
+[#1883]: https://github.com/cosmos/cosmjs/issues/1883
+
+### Changed
+
+- all: return `Uint8Array<ArrayBuffer>` instead of
+  `Uint8Array = Uint8Array<ArrayBufferLike>` whenever CosmJS creates binary data
+  for users. This allows users to stick it into APIs that require `ArrayBuffer`
+  such as many APIs from Subtle crypto. You can still assign
+  `Uint8Array<ArrayBuffer>` to any `Uint8Array` in an existing codebase like
+  this:
+
+  ```ts
+  const myVar: Uint8Array = fromHex("aabb");
+  ```
+
+  That's the easy way and probably good for many use cases. However, this way
+  you lose information which buffer type is in use and you cannot trivially pass
+  it to an API requiring `Uint8Array<ArrayBuffer>` later on.
+
+  The other option is to preserve the information you are getting from CosmJS by
+  using `Uint8Array<ArrayBuffer>` too:
+
+  ```ts
+  const myVar: Uint8Array<ArrayBuffer> = fromHex("aabb");
+
+  // or inferred
+  const myVar = fromHex("aabb"); // Uint8Array<ArrayBuffer>
+  ```
+
+  This change requires users to use TypeScript 5.7 or newer. ([#1883])
+
+[#1883]: https://github.com/cosmos/cosmjs/issues/1883
+
 ## [0.37.0] - 2025-10-29
 
 ### Added

packages/amino/src/addresses.ts

@@ -6,22 +6,22 @@ import { fromBase64, toBech32 } from "@cosmjs/encoding";
 import { encodeAminoPubkey } from "./encoding";
 import { isEd25519Pubkey, isMultisigThresholdPubkey, isSecp256k1Pubkey, Pubkey } from "./pubkeys";
 
-export function rawEd25519PubkeyToRawAddress(pubkeyData: Uint8Array): Uint8Array {
+export function rawEd25519PubkeyToRawAddress(pubkeyData: Uint8Array): Uint8Array<ArrayBuffer> {
   if (pubkeyData.length !== 32) {
     throw new Error(`Invalid Ed25519 pubkey length: ${pubkeyData.length}`);
   }
   return sha256(pubkeyData).slice(0, 20);
 }
 
-export function rawSecp256k1PubkeyToRawAddress(pubkeyData: Uint8Array): Uint8Array {
+export function rawSecp256k1PubkeyToRawAddress(pubkeyData: Uint8Array): Uint8Array<ArrayBuffer> {
   if (pubkeyData.length !== 33) {
     throw new Error(`Invalid Secp256k1 pubkey length (compressed): ${pubkeyData.length}`);
   }
   return ripemd160(sha256(pubkeyData));
 }
 
 // For secp256k1 this assumes we already have a compressed pubkey.
-export function pubkeyToRawAddress(pubkey: Pubkey): Uint8Array {
+export function pubkeyToRawAddress(pubkey: Pubkey): Uint8Array<ArrayBuffer> {
   if (isSecp256k1Pubkey(pubkey)) {
     const pubkeyData = fromBase64(pubkey.value);
     return rawSecp256k1PubkeyToRawAddress(pubkeyData);

packages/amino/src/encoding.ts

@@ -192,7 +192,7 @@ function encodeUvarint(value: number | string): number[] {
 /**
  * Encodes a public key to binary Amino.
  */
-export function encodeAminoPubkey(pubkey: Pubkey): Uint8Array {
+export function encodeAminoPubkey(pubkey: Pubkey): Uint8Array<ArrayBuffer> {
   if (isMultisigThresholdPubkey(pubkey)) {
     const out = Array.from(pubkeyAminoPrefixMultisigThreshold);
     out.push(0x08); // TODO: What is this?

packages/amino/src/signdoc.ts

@@ -96,7 +96,7 @@ export function escapeCharacters(input: string): string {
   return input.replace(amp, "\\u0026").replace(lt, "\\u003c").replace(gt, "\\u003e");
 }
 
-export function serializeSignDoc(signDoc: StdSignDoc): Uint8Array {
+export function serializeSignDoc(signDoc: StdSignDoc): Uint8Array<ArrayBuffer> {
   const serialized = escapeCharacters(sortedJsonStringify(signDoc));
   return toUtf8(serialized);
 }

packages/amino/src/wallet.ts

@@ -13,7 +13,7 @@ import { sleep } from "@cosmjs/utils";
  * This reduces the scope of a potential rainbow attack to all CosmJS users.
  * Must be 16 bytes due to implementation limitations.
  */
-export const cosmjsSalt: Uint8Array = toAscii("The CosmJS salt.");
+export const cosmjsSalt: Uint8Array<ArrayBuffer> = toAscii("The CosmJS salt.");
 
 export interface KdfConfiguration {
   /**

packages/cosmwasm-stargate/src/cosmwasmclient.ts

@@ -1,4 +1,4 @@
-import { fromUtf8, toHex } from "@cosmjs/encoding";
+import { fixUint8Array, fromUtf8, toHex } from "@cosmjs/encoding";
 import { Uint53 } from "@cosmjs/math";
 import {
   Account,
@@ -496,7 +496,10 @@ export class CosmWasmClient {
         events: tx.result.events.map(fromTendermintEvent),
         rawLog: tx.result.log || "",
         tx: tx.tx,
-        msgResponses: txMsgData.msgResponses,
+        msgResponses: txMsgData.msgResponses.map((mr) => ({
+          typeUrl: mr.typeUrl,
+          value: fixUint8Array(mr.value),
+        })),
         gasUsed: tx.result.gasUsed,
         gasWanted: tx.result.gasWanted,
       };

packages/cosmwasm-stargate/src/instantiate2.ts

@@ -7,14 +7,14 @@ import { assert } from "@cosmjs/utils";
  * The "Basic Address" Hash from
  * https://github.com/cosmos/cosmos-sdk/blob/v0.45.8/docs/architecture/adr-028-public-key-addresses.md
  */
-function hash(type: string, key: Uint8Array): Uint8Array {
+function hash(type: string, key: Uint8Array): Uint8Array<ArrayBuffer> {
   return new Sha256(sha256(toAscii(type))).update(key).digest();
 }
 
 /**
  * Takes an integer [0, 2**64-1] and returns a one-byte encoding of it.
  */
-function toUint64(int: number): Uint8Array {
+function toUint64(int: number): Uint8Array<ArrayBuffer> {
   return Uint64.fromNumber(int).toBytesBigEndian();
 }
 

packages/crypto/src/bip39.ts

@@ -1,3 +1,4 @@
+import { fixUint8Array } from "@cosmjs/encoding";
 import { entropyToMnemonic, mnemonicToEntropy, mnemonicToSeed } from "@scure/bip39";
 import { wordlist } from "@scure/bip39/wordlists/english";
 
@@ -38,8 +39,8 @@ export class Bip39 {
     return new EnglishMnemonic(entropyToMnemonic(entropy, wordlist));
   }
 
-  public static decode(mnemonic: EnglishMnemonic): Uint8Array {
-    return mnemonicToEntropy(mnemonic.toString(), wordlist);
+  public static decode(mnemonic: EnglishMnemonic): Uint8Array<ArrayBuffer> {
+    return fixUint8Array(mnemonicToEntropy(mnemonic.toString(), wordlist));
   }
 
   public static async mnemonicToSeed(mnemonic: EnglishMnemonic, password?: string): Promise<Uint8Array> {

packages/crypto/src/hmac.ts

@@ -1,3 +1,5 @@
+import { fixUint8Array } from "@cosmjs/encoding";
+
 import { HashFunction } from "./hash";
 
 export class Hmac<H extends HashFunction> implements HashFunction {
@@ -6,7 +8,7 @@ export class Hmac<H extends HashFunction> implements HashFunction {
   private readonly messageHasher: H;
   private readonly oKeyPad: Uint8Array;
   private readonly iKeyPad: Uint8Array;
-  private readonly hash: (data: Uint8Array) => Uint8Array;
+  private readonly hash: (data: Uint8Array) => Uint8Array<ArrayBuffer>;
 
   public constructor(hashFunctionConstructor: new () => H, originalKey: Uint8Array) {
     // This implementation is based on https://en.wikipedia.org/wiki/HMAC#Implementation
@@ -15,7 +17,7 @@ export class Hmac<H extends HashFunction> implements HashFunction {
 
     const blockSize = new hashFunctionConstructor().blockSize;
 
-    this.hash = (data) => new hashFunctionConstructor().update(data).digest();
+    this.hash = (data) => fixUint8Array(new hashFunctionConstructor().update(data).digest());
 
     let key = originalKey;
     if (key.length > blockSize) {
@@ -42,7 +44,7 @@ export class Hmac<H extends HashFunction> implements HashFunction {
     return this;
   }
 
-  public digest(): Uint8Array {
+  public digest(): Uint8Array<ArrayBuffer> {
     const innerHash = this.messageHasher.digest();
     return this.hash(new Uint8Array([...this.oKeyPad, ...innerHash]));
   }

packages/crypto/src/keccak.ts

@@ -1,3 +1,4 @@
+import { fixUint8Array } from "@cosmjs/encoding";
 import { keccak_256 } from "@noble/hashes/sha3.js";
 
 import { HashFunction } from "./hash";
@@ -19,12 +20,12 @@ export class Keccak256 implements HashFunction {
     return this;
   }
 
-  public digest(): Uint8Array {
-    return this.impl.digest();
+  public digest(): Uint8Array<ArrayBuffer> {
+    return fixUint8Array(this.impl.digest());
   }
 }
 
 /** Convenience function equivalent to `new Keccak256(data).digest()` */
-export function keccak256(data: Uint8Array): Uint8Array {
+export function keccak256(data: Uint8Array): Uint8Array<ArrayBuffer> {
   return new Keccak256(data).digest();
 }