@btc-vision/bitcoin 7.0.0-alpha.0 → 7.0.0-alpha.2

package/src/address.ts

@@ -9,10 +9,10 @@
  */
 import { bech32, bech32m } from 'bech32';
 import * as bs58check from 'bs58check';
-import { fromBech32, type Bech32Result } from './bech32utils.js';
+import { type Bech32Result, fromBech32 } from './bech32utils.js';
 import { alloc } from './io/index.js';
-import * as networks from './networks.js';
 import type { Network } from './networks.js';
+import * as networks from './networks.js';
 import { p2op } from './payments/p2op.js';
 import { p2pkh } from './payments/p2pkh.js';
 import { p2sh } from './payments/p2sh.js';
@@ -21,7 +21,14 @@ import { p2wpkh } from './payments/p2wpkh.js';
 import { p2wsh } from './payments/p2wsh.js';
 import * as bscript from './script.js';
 import { opcodes } from './script.js';
-import { isBytes20, isUInt8, toBytes20, toBytes32, type Bytes20, type XOnlyPublicKey, type Script } from './types.js';
+import {
+    type Bytes20,
+    isBytes20,
+    isUInt8,
+    toBytes20,
+    toBytes32,
+    type XOnlyPublicKey,
+} from './types.js';
 
 export { fromBech32, type Bech32Result };
 
@@ -180,27 +187,51 @@ export function toBech32(
 }
 
 /**
- * decode address from output script with network, return address if matched
+ * decode address from output script with network, return address if matched.
+ *
+ * Uses fast byte-pattern matching for common script types (P2PKH, P2SH,
+ * P2WPKH, P2WSH, P2TR) to avoid constructing payment objects and catching
+ * exceptions. Falls back to payment constructors for exotic types.
  */
 export function fromOutputScript(output: Uint8Array, network?: Network): string {
-    // TODO: Network
     network = network || networks.bitcoin;
+    const len = output.length;
+
+    // P2PKH: OP_DUP(0x76) OP_HASH160(0xa9) 0x14 <20-byte hash> OP_EQUALVERIFY(0x88) OP_CHECKSIG(0xac)
+    if (
+        len === 25 &&
+        output[0] === 0x76 &&
+        output[1] === 0xa9 &&
+        output[2] === 0x14 &&
+        output[23] === 0x88 &&
+        output[24] === 0xac
+    ) {
+        return toBase58Check(output.subarray(3, 23) as Bytes20, network.pubKeyHash);
+    }
 
-    try {
-        return p2pkh({ output: output as Script, network }).address as string;
-    } catch (e) {}
-    try {
-        return p2sh({ output: output as Script, network }).address as string;
-    } catch (e) {}
-    try {
-        return p2wpkh({ output: output as Script, network }).address as string;
-    } catch (e) {}
-    try {
-        return p2wsh({ output: output as Script, network }).address as string;
-    } catch (e) {}
-    try {
-        return p2tr({ output: output as Script, network }).address as string;
-    } catch (e) {}
+    // P2SH: OP_HASH160(0xa9) 0x14 <20-byte hash> OP_EQUAL(0x87)
+    if (len === 23 && output[0] === 0xa9 && output[1] === 0x14 && output[22] === 0x87) {
+        return toBase58Check(output.subarray(2, 22) as Bytes20, network.scriptHash);
+    }
+
+    // P2WPKH: OP_0(0x00) 0x14 <20-byte hash>
+    if (len === 22 && output[0] === 0x00 && output[1] === 0x14) {
+        return toBech32(output.subarray(2, 22), 0, network.bech32);
+    }
+
+    // P2WSH: OP_0(0x00) 0x20 <32-byte hash>
+    if (len === 34 && output[0] === 0x00 && output[1] === 0x20) {
+        return toBech32(output.subarray(2, 34), 0, network.bech32);
+    }
+
+    // P2TR: OP_1(0x51) 0x20 <32-byte x-only pubkey>
+    if (len === 34 && output[0] === 0x51 && output[1] === 0x20) {
+        const words = bech32m.toWords(output.subarray(2, 34));
+        words.unshift(1);
+        return bech32m.encode(network.bech32, words);
+    }
+
+    // Fallback for exotic types
     try {
         return toFutureOPNetAddress(output, network);
     } catch (e) {}
@@ -282,7 +313,8 @@ export function toOutputScript(
                     return p2wsh({ hash: toBytes32(decodeBech32.data) }).output as Uint8Array;
             } else if (decodeBech32.version === 1) {
                 if (decodeBech32.data.length === 32)
-                    return p2tr({ pubkey: decodeBech32.data as XOnlyPublicKey }).output as Uint8Array;
+                    return p2tr({ pubkey: decodeBech32.data as XOnlyPublicKey })
+                        .output as Uint8Array;
             } else if (decodeBech32.version === FUTURE_OPNET_VERSION) {
                 if (!network.bech32Opnet) throw new Error(address + ' has an invalid prefix');
                 return p2op({

package/src/block.ts

@@ -1,5 +1,15 @@
 import * as bcrypto from './crypto.js';
-import { BinaryReader, BinaryWriter, varuint, equals, fromHex, alloc, compare, toHex, reverse } from './io/index.js';
+import {
+    alloc,
+    BinaryReader,
+    BinaryWriter,
+    compare,
+    equals,
+    fromHex,
+    reverse,
+    toHex,
+    varuint,
+} from './io/index.js';
 import { fastMerkleRoot } from './merkle.js';
 import { Transaction } from './transaction.js';
 import type { Bytes32 } from './types.js';
@@ -70,10 +80,7 @@ export class Block {
         if (buffer.length === 80) return block;
 
         const readTransaction = (): Transaction => {
-            const tx = Transaction.fromBuffer(
-                reader.data.subarray(reader.offset),
-                true,
-            );
+            const tx = Transaction.fromBuffer(reader.data.subarray(reader.offset), true);
             reader.offset += tx.byteLength();
             return tx;
         };
@@ -158,9 +165,9 @@ export class Block {
         // There is no rule for the index of the output, so use filter to find it.
         // The root is prepended with 0xaa21a9ed so check for 0x6a24aa21a9ed
         // If multiple commits are found, the output with highest index is assumed.
-        const witnessCommits = this.transactions[0]!.outs
-            .filter((out) => equals(out.script.subarray(0, 6), WITNESS_COMMIT_PREFIX))
-            .map((out) => out.script.subarray(6, 38));
+        const witnessCommits = this.transactions[0]!.outs.filter((out) =>
+            equals(out.script.subarray(0, 6), WITNESS_COMMIT_PREFIX),
+        ).map((out) => out.script.subarray(6, 38));
         if (witnessCommits.length === 0) return null;
         // Use the commit with the highest output (should only be one though)
         const result = witnessCommits[witnessCommits.length - 1];

package/src/branded.ts

@@ -1,18 +1,20 @@
 /**
  * Branded type definitions for type-safe primitives.
  *
+ * Re-exported from @btc-vision/ecpair to ensure cross-package type compatibility.
+ *
  * @packageDocumentation
  */
-
-declare const __brand: unique symbol;
-type Brand<T, B extends string> = T & { readonly [__brand]: B };
-
-export type Bytes32 = Brand<Uint8Array, 'Bytes32'>;
-export type Bytes20 = Brand<Uint8Array, 'Bytes20'>;
-export type PublicKey = Brand<Uint8Array, 'PublicKey'>;
-export type XOnlyPublicKey = Brand<Uint8Array, 'XOnlyPublicKey'>;
-export type Satoshi = Brand<bigint, 'Satoshi'>;
-export type PrivateKey = Brand<Uint8Array, 'PrivateKey'>;
-export type Signature = Brand<Uint8Array, 'Signature'>;
-export type SchnorrSignature = Brand<Uint8Array, 'SchnorrSignature'>;
-export type Script = Brand<Uint8Array, 'Script'>;
+export type {
+    Brand,
+    Bytes32,
+    Bytes20,
+    PublicKey,
+    XOnlyPublicKey,
+    Satoshi,
+    PrivateKey,
+    Signature,
+    SchnorrSignature,
+    MessageHash,
+    Script,
+} from '@btc-vision/ecpair';

package/src/crypto.ts

@@ -7,7 +7,7 @@
 import { ripemd160 as _ripemd160, sha1 as _sha1 } from '@noble/hashes/legacy.js';
 import { sha256 as _sha256 } from '@noble/hashes/sha2.js';
 import { concat } from './io/index.js';
-import type { Bytes32, Bytes20 } from './types.js';
+import type { Bytes20, Bytes32 } from './types.js';
 
 /**
  * Computes RIPEMD-160 hash of the input.

package/src/ecc/context.ts

@@ -5,7 +5,7 @@
  * @packageDocumentation
  */
 import type { EccLib } from './types.js';
-import { fromHex, equals } from '../io/index.js';
+import { equals, fromHex } from '../io/index.js';
 import type { Bytes32, XOnlyPublicKey } from '../types.js';
 
 /**
@@ -35,6 +35,13 @@ export class EccContext {
         this.#lib = lib;
     }
 
+    /**
+     * The underlying ECC library instance.
+     */
+    get lib(): EccLib {
+        return this.#lib;
+    }
+
     /**
      * Initializes the ECC context with the provided library.
      * The library is verified before being set as active.
@@ -52,6 +59,10 @@ export class EccContext {
      * ```
      */
     static init(lib: EccLib): EccContext {
+        // Skip re-verification if same lib is already initialized
+        if (EccContext.#instance && EccContext.#instance.#lib === lib) {
+            return EccContext.#instance;
+        }
         verifyEcc(lib);
         EccContext.#instance = new EccContext(lib);
         return EccContext.#instance;
@@ -113,13 +124,6 @@ export class EccContext {
     static isInitialized(): boolean {
         return EccContext.#instance !== undefined;
     }
-
-    /**
-     * The underlying ECC library instance.
-     */
-    get lib(): EccLib {
-        return this.#lib;
-    }
 }
 
 /**
@@ -177,32 +181,64 @@ export function getEccLib(): EccLib {
 // ============================================================================
 
 interface TweakAddVector {
-    pubkey: string;
-    tweak: string;
+    pubkey: Uint8Array;
+    tweak: Uint8Array;
     parity: 0 | 1 | -1;
-    result: string | null;
+    result: Uint8Array | null;
+}
+
+// Lazily decoded test vectors (decoded once on first verification)
+let _tweakVectors: TweakAddVector[] | undefined;
+let _validPoints: Uint8Array[] | undefined;
+let _invalidPoints: Uint8Array[] | undefined;
+
+function getTweakVectors(): TweakAddVector[] {
+    if (!_tweakVectors) {
+        _tweakVectors = [
+            {
+                pubkey: fromHex('79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'),
+                tweak: fromHex('fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140'),
+                parity: -1,
+                result: null,
+            },
+            {
+                pubkey: fromHex('1617d38ed8d8657da4d4761e8057bc396ea9e4b9d29776d4be096016dbd2509b'),
+                tweak: fromHex('a8397a935f0dfceba6ba9618f6451ef4d80637abf4e6af2669fbc9de6a8fd2ac'),
+                parity: 1,
+                result: fromHex('e478f99dab91052ab39a33ea35fd5e6e4933f4d28023cd597c9a1f6760346adf'),
+            },
+            {
+                pubkey: fromHex('2c0b7cf95324a07d05398b240174dc0c2be444d96b159aa6c7f7b1e668680991'),
+                tweak: fromHex('823c3cd2142744b075a87eade7e1b8678ba308d566226a0056ca2b7a76f86b47'),
+                parity: 0,
+                result: fromHex('9534f8dc8c6deda2dc007655981c78b49c5d96c778fbf363462a11ec9dfd948c'),
+            },
+        ];
+    }
+    return _tweakVectors;
+}
+
+function getValidPoints(): Uint8Array[] {
+    if (!_validPoints) {
+        _validPoints = [
+            fromHex('79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'),
+            fromHex('fffffffffffffffffffffffffffffffffffffffffffffffffffffffeeffffc2e'),
+            fromHex('f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9'),
+            fromHex('0000000000000000000000000000000000000000000000000000000000000001'),
+        ];
+    }
+    return _validPoints;
 }
 
-const TWEAK_ADD_VECTORS: TweakAddVector[] = [
-    {
-        pubkey: '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',
-        tweak: 'fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140',
-        parity: -1,
-        result: null,
-    },
-    {
-        pubkey: '1617d38ed8d8657da4d4761e8057bc396ea9e4b9d29776d4be096016dbd2509b',
-        tweak: 'a8397a935f0dfceba6ba9618f6451ef4d80637abf4e6af2669fbc9de6a8fd2ac',
-        parity: 1,
-        result: 'e478f99dab91052ab39a33ea35fd5e6e4933f4d28023cd597c9a1f6760346adf',
-    },
-    {
-        pubkey: '2c0b7cf95324a07d05398b240174dc0c2be444d96b159aa6c7f7b1e668680991',
-        tweak: '823c3cd2142744b075a87eade7e1b8678ba308d566226a0056ca2b7a76f86b47',
-        parity: 0,
-        result: '9534f8dc8c6deda2dc007655981c78b49c5d96c778fbf363462a11ec9dfd948c',
-    },
-];
+function getInvalidPoints(): Uint8Array[] {
+    if (!_invalidPoints) {
+        _invalidPoints = [
+            fromHex('0000000000000000000000000000000000000000000000000000000000000000'),
+            fromHex('fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f'),
+        ];
+    }
+    return _invalidPoints;
+}
 
 /**
  * Verifies that the ECC library implementation is correct.
@@ -216,29 +252,17 @@ function verifyEcc(ecc: EccLib): void {
         throw new Error('ECC library missing isXOnlyPoint function');
     }
 
-    // Test isXOnlyPoint with valid points
-    const validPoints = [
-        '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',
-        'fffffffffffffffffffffffffffffffffffffffffffffffffffffffeeffffc2e',
-        'f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9',
-        '0000000000000000000000000000000000000000000000000000000000000001',
-    ];
-
-    for (const hex of validPoints) {
-        if (!ecc.isXOnlyPoint(fromHex(hex))) {
-            throw new Error(`ECC library isXOnlyPoint failed for valid point: ${hex}`);
+    // Test isXOnlyPoint with valid points (pre-decoded)
+    for (const point of getValidPoints()) {
+        if (!ecc.isXOnlyPoint(point)) {
+            throw new Error('ECC library isXOnlyPoint failed for a valid point');
         }
     }
 
-    // Test isXOnlyPoint with invalid points
-    const invalidPoints = [
-        '0000000000000000000000000000000000000000000000000000000000000000',
-        'fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f',
-    ];
-
-    for (const hex of invalidPoints) {
-        if (ecc.isXOnlyPoint(fromHex(hex))) {
-            throw new Error(`ECC library isXOnlyPoint should reject invalid point: ${hex}`);
+    // Test isXOnlyPoint with invalid points (pre-decoded)
+    for (const point of getInvalidPoints()) {
+        if (ecc.isXOnlyPoint(point)) {
+            throw new Error('ECC library isXOnlyPoint should reject invalid point');
         }
     }
 
@@ -247,30 +271,27 @@ function verifyEcc(ecc: EccLib): void {
         throw new Error('ECC library missing xOnlyPointAddTweak function');
     }
 
-    for (const vector of TWEAK_ADD_VECTORS) {
-        const result = ecc.xOnlyPointAddTweak(fromHex(vector.pubkey) as XOnlyPublicKey, fromHex(vector.tweak) as Bytes32);
+    for (const vector of getTweakVectors()) {
+        const result = ecc.xOnlyPointAddTweak(
+            vector.pubkey as XOnlyPublicKey,
+            vector.tweak as Bytes32,
+        );
 
         if (vector.result === null) {
             if (result !== null) {
                 throw new Error(
-                    `ECC library xOnlyPointAddTweak should return null for: ${vector.pubkey}`,
+                    'ECC library xOnlyPointAddTweak should return null for test vector',
                 );
             }
         } else {
             if (result === null) {
-                throw new Error(
-                    `ECC library xOnlyPointAddTweak returned null unexpectedly for: ${vector.pubkey}`,
-                );
+                throw new Error('ECC library xOnlyPointAddTweak returned null unexpectedly');
             }
             if (result.parity !== vector.parity) {
-                throw new Error(
-                    `ECC library xOnlyPointAddTweak parity mismatch for: ${vector.pubkey}`,
-                );
+                throw new Error('ECC library xOnlyPointAddTweak parity mismatch');
             }
-            if (!equals(result.xOnlyPubkey, fromHex(vector.result))) {
-                throw new Error(
-                    `ECC library xOnlyPointAddTweak result mismatch for: ${vector.pubkey}`,
-                );
+            if (!equals(result.xOnlyPubkey, vector.result)) {
+                throw new Error('ECC library xOnlyPointAddTweak result mismatch');
             }
         }
     }

package/src/ecc/types.ts

@@ -5,14 +5,7 @@
  * @packageDocumentation
  */
 
-import type {
-    Bytes32,
-    PrivateKey,
-    PublicKey,
-    Signature,
-    SchnorrSignature,
-    XOnlyPublicKey,
-} from '../branded.js';
+import type { Bytes32, PrivateKey, PublicKey, SchnorrSignature, Signature, XOnlyPublicKey, } from '../branded.js';
 
 /**
  * Parity of the y-coordinate for an x-only public key.

package/src/index.ts

@@ -17,6 +17,18 @@ import * as payments from './payments/index.js';
 import * as script from './script.js';
 import * as crypto from './crypto.js';
 import * as Transaction from './transaction.js';
+// Custom error types
+import {
+    AddressError,
+    BitcoinError,
+    EccError,
+    InvalidInputError,
+    InvalidOutputError,
+    PsbtError,
+    ScriptError,
+    SignatureError,
+    ValidationError,
+} from './errors.js';
 
 export * as address from './address.js';
 export * as crypto from './crypto.js';
@@ -27,7 +39,42 @@ export * as script from './script.js';
 export { Block } from './block.js';
 /** @hidden */
 export * from './crypto.js';
-export * from './psbt.js';
+export {
+    Psbt,
+    PsbtCache,
+    PsbtSigner,
+    PsbtFinalizer,
+    PsbtTransaction,
+    transactionFromBuffer,
+    getFinalScripts,
+    prepareFinalScripts,
+} from './psbt.js';
+export type {
+    TransactionInput,
+    PsbtTxInput,
+    TransactionOutput,
+    PsbtTxOutput,
+    ValidateSigFunction,
+    PsbtBaseExtended,
+    PsbtOptsOptional,
+    PsbtOpts,
+    PsbtInputExtended,
+    PsbtOutputExtended,
+    PsbtOutputExtendedScript,
+    HDSigner,
+    HDSignerAsync,
+    SignerAlternative,
+    Signer,
+    SignerAsync,
+    TaprootHashCheckSigner,
+    PsbtCacheInterface,
+    TxCacheNumberKey,
+    ScriptType,
+    AllScriptType,
+    GetScriptReturn,
+    FinalScriptsFunc,
+    FinalTaprootScriptsFunc,
+} from './psbt.js';
 /** @hidden */
 export { opcodes } from './opcodes.js';
 export { Transaction } from './transaction.js';
@@ -140,19 +187,6 @@ export {
 } from './types.js';
 export type { XOnlyPointAddTweakResult } from './ecc/types.js';
 
-// Custom error types
-import {
-    BitcoinError,
-    ValidationError,
-    InvalidInputError,
-    InvalidOutputError,
-    ScriptError,
-    PsbtError,
-    EccError,
-    AddressError,
-    SignatureError,
-} from './errors.js';
-
 export {
     BitcoinError,
     ValidationError,

package/src/io/BinaryReader.ts

@@ -70,24 +70,6 @@ export class BinaryReader {
         this.#offset = offset;
     }
 
-    /**
-     * Creates a BinaryReader from a hex string.
-     *
-     * @param hex - Hex string (with or without 0x prefix)
-     * @returns A new BinaryReader instance
-     *
-     * @example
-     * ```typescript
-     * import { BinaryReader } from '@btc-vision/bitcoin';
-     *
-     * const reader = BinaryReader.fromHex('01000000');
-     * const version = reader.readInt32LE(); // 1
-     * ```
-     */
-    public static fromHex(hex: string): BinaryReader {
-        return new BinaryReader(fromHex(hex));
-    }
-
     /**
      * Current read position in the buffer.
      */
@@ -129,6 +111,24 @@ export class BinaryReader {
         return this.#data;
     }
 
+    /**
+     * Creates a BinaryReader from a hex string.
+     *
+     * @param hex - Hex string (with or without 0x prefix)
+     * @returns A new BinaryReader instance
+     *
+     * @example
+     * ```typescript
+     * import { BinaryReader } from '@btc-vision/bitcoin';
+     *
+     * const reader = BinaryReader.fromHex('01000000');
+     * const version = reader.readInt32LE(); // 1
+     * ```
+     */
+    public static fromHex(hex: string): BinaryReader {
+        return new BinaryReader(fromHex(hex));
+    }
+
     /**
      * Reads an 8-bit unsigned integer.
      *

package/src/io/BinaryWriter.ts

@@ -91,26 +91,6 @@ export class BinaryWriter {
         this.#view = new DataView(this.#data.buffer, this.#data.byteOffset, this.#data.byteLength);
     }
 
-    /**
-     * Creates a BinaryWriter with automatic capacity management.
-     *
-     * Initial capacity is 256 bytes, grows as needed.
-     *
-     * @returns A new GrowableBinaryWriter instance
-     *
-     * @example
-     * ```typescript
-     * import { BinaryWriter } from '@btc-vision/bitcoin';
-     *
-     * const writer = BinaryWriter.growable();
-     * writer.writeUInt32LE(1);
-     * writer.writeBytes(new Uint8Array(1000)); // Automatically grows
-     * ```
-     */
-    public static growable(initialCapacity: number = 256): GrowableBinaryWriter {
-        return new GrowableBinaryWriter(initialCapacity);
-    }
-
     /**
      * Current write position in the buffer.
      */
@@ -152,6 +132,26 @@ export class BinaryWriter {
         return this.#data;
     }
 
+    /**
+     * Creates a BinaryWriter with automatic capacity management.
+     *
+     * Initial capacity is 256 bytes, grows as needed.
+     *
+     * @returns A new GrowableBinaryWriter instance
+     *
+     * @example
+     * ```typescript
+     * import { BinaryWriter } from '@btc-vision/bitcoin';
+     *
+     * const writer = BinaryWriter.growable();
+     * writer.writeUInt32LE(1);
+     * writer.writeBytes(new Uint8Array(1000)); // Automatically grows
+     * ```
+     */
+    public static growable(initialCapacity: number = 256): GrowableBinaryWriter {
+        return new GrowableBinaryWriter(initialCapacity);
+    }
+
     /**
      * Writes an 8-bit unsigned integer.
      *
@@ -583,29 +583,6 @@ export class GrowableBinaryWriter {
         return this.#data.length;
     }
 
-    /**
-     * Ensures the buffer has enough space for additional bytes.
-     *
-     * @param additionalBytes - Number of additional bytes needed
-     */
-    #ensureCapacity(additionalBytes: number): void {
-        const required = this.#offset + additionalBytes;
-        if (required <= this.#data.length) {
-            return;
-        }
-
-        // Grow by at least 2x or to required size
-        let newCapacity = this.#data.length * 2;
-        while (newCapacity < required) {
-            newCapacity *= 2;
-        }
-
-        const newData = new Uint8Array(newCapacity);
-        newData.set(this.#data.subarray(0, this.#offset));
-        this.#data = newData;
-        this.#view = new DataView(this.#data.buffer);
-    }
-
     public writeUInt8(value: number): this {
         this.#ensureCapacity(1);
         this.#data[this.#offset++] = value & 0xff;
@@ -693,4 +670,27 @@ export class GrowableBinaryWriter {
     public toHex(): string {
         return toHex(this.finish());
     }
+
+    /**
+     * Ensures the buffer has enough space for additional bytes.
+     *
+     * @param additionalBytes - Number of additional bytes needed
+     */
+    #ensureCapacity(additionalBytes: number): void {
+        const required = this.#offset + additionalBytes;
+        if (required <= this.#data.length) {
+            return;
+        }
+
+        // Grow by at least 2x or to required size
+        let newCapacity = this.#data.length * 2;
+        while (newCapacity < required) {
+            newCapacity *= 2;
+        }
+
+        const newData = new Uint8Array(newCapacity);
+        newData.set(this.#data.subarray(0, this.#offset));
+        this.#data = newData;
+        this.#view = new DataView(this.#data.buffer);
+    }
 }