@btc-vision/bitcoin 7.0.0-alpha.9 → 7.0.0-beta.0

package/src/payments/p2pkh.ts

@@ -8,13 +8,12 @@
  * @packageDocumentation
  */
 
-import * as bs58check from 'bs58check';
 import * as bcrypto from '../crypto.js';
 import { bitcoin as BITCOIN_NETWORK, type Network } from '../networks.js';
 import { decompressPublicKey } from '../pubkey.js';
 import * as bscript from '../script.js';
 import { type Bytes20, isPoint, type PublicKey, type Script, type Signature } from '../types.js';
-import { alloc, equals } from '../io/index.js';
+import { alloc, base58check, equals } from '../io/index.js';
 import { type P2PKHPayment, type PaymentOpts, PaymentType } from './types.js';
 
 const OPS = bscript.opcodes;
@@ -325,9 +324,9 @@ export class P2PKH {
     #getDecodedAddress(): { version: number; hash: Uint8Array } | undefined {
         if (!this.#decodedAddressComputed) {
             if (this.#inputAddress) {
-                const payload = new Uint8Array(bs58check.default.decode(this.#inputAddress));
+                const payload = new Uint8Array(base58check.decode(this.#inputAddress));
                 this.#decodedAddress = {
-                    version: payload[0]!,
+                    version: payload[0] as number,
                     hash: payload.subarray(1),
                 };
             }
@@ -358,7 +357,7 @@ export class P2PKH {
         const payload = alloc(21);
         payload[0] = this.#network.pubKeyHash;
         payload.set(h, 1);
-        return bs58check.default.encode(payload);
+        return base58check.encode(payload);
     }
 
     #computeHash(): Bytes20 | undefined {

package/src/payments/p2sh.ts

@@ -8,12 +8,11 @@
  * @packageDocumentation
  */
 
-import * as bs58check from 'bs58check';
 import * as bcrypto from '../crypto.js';
 import { bitcoin as BITCOIN_NETWORK, type Network } from '../networks.js';
 import * as bscript from '../script.js';
 import { type Bytes20, type Script, type Stack, stacksEqual } from '../types.js';
-import { alloc, equals } from '../io/index.js';
+import { alloc, base58check, equals } from '../io/index.js';
 import {
     type P2SHPayment,
     type Payment,
@@ -303,9 +302,9 @@ export class P2SH {
     #getDecodedAddress(): { version: number; hash: Uint8Array } | undefined {
         if (!this.#decodedAddressComputed) {
             if (this.#inputAddress) {
-                const payload = new Uint8Array(bs58check.default.decode(this.#inputAddress));
+                const payload = new Uint8Array(base58check.decode(this.#inputAddress));
                 this.#decodedAddress = {
-                    version: payload[0]!,
+                    version: payload[0] as number,
                     hash: payload.subarray(1),
                 };
             }
@@ -355,7 +354,7 @@ export class P2SH {
         const payload = alloc(21);
         payload[0] = this.#network.scriptHash;
         payload.set(h, 1);
-        return bs58check.default.encode(payload);
+        return base58check.encode(payload);
     }
 
     #computeHash(): Bytes20 | undefined {

package/src/payments/p2tr.ts

@@ -405,9 +405,10 @@ export class P2TR {
         if (!this.#witnessWithoutAnnexComputed) {
             if (this.#inputWitness && this.#inputWitness.length > 0) {
                 // Remove annex if present
+                const lastWitness = this.#inputWitness[this.#inputWitness.length - 1];
                 if (
                     this.#inputWitness.length >= 2 &&
-                    this.#inputWitness[this.#inputWitness.length - 1]![0] === ANNEX_PREFIX
+                    lastWitness && lastWitness[0] === ANNEX_PREFIX
                 ) {
                     this.#witnessWithoutAnnex = this.#inputWitness.slice(0, -1);
                 } else {
@@ -471,7 +472,10 @@ export class P2TR {
         }
         const witness = this.#getWitnessWithoutAnnex();
         if (witness && witness.length > 1) {
-            return witness[witness.length - 1]!.subarray(1, 33) as XOnlyPublicKey;
+            const lastWitness = witness[witness.length - 1];
+            if (lastWitness) {
+                return lastWitness.subarray(1, 33) as XOnlyPublicKey;
+            }
         }
         return undefined;
     }
@@ -484,9 +488,9 @@ export class P2TR {
 
         const w = this.#getWitnessWithoutAnnex();
         if (w && w.length > 1) {
-            const controlBlock = w[w.length - 1]!;
-            const leafVersion = controlBlock[0]! & TAPLEAF_VERSION_MASK;
-            const script = w[w.length - 2]!;
+            const controlBlock = w[w.length - 1] as Uint8Array;
+            const leafVersion = (controlBlock[0] as number) & TAPLEAF_VERSION_MASK;
+            const script = w[w.length - 2] as Uint8Array;
             const leafHash = tapleafHash({
                 output: script,
                 version: leafVersion,
@@ -526,10 +530,11 @@ export class P2TR {
         if (!witness || witness.length < 2) {
             return undefined;
         }
+        const lastWitness = witness[witness.length - 1] as Uint8Array;
         return {
             output: witness[witness.length - 2] as Script,
             witness: witness.slice(0, -2),
-            redeemVersion: witness[witness.length - 1]![0]! & TAPLEAF_VERSION_MASK,
+            redeemVersion: (lastWitness[0] as number) & TAPLEAF_VERSION_MASK,
         };
     }
 
@@ -688,12 +693,13 @@ export class P2TR {
         if (witness && witness.length > 0) {
             if (witness.length === 1) {
                 // Key-path spending
-                if (this.#inputSignature && !equals(this.#inputSignature, witness[0]!)) {
+                const firstWitness = witness[0] as Uint8Array;
+                if (this.#inputSignature && !equals(this.#inputSignature, firstWitness)) {
                     throw new TypeError('Signature mismatch');
                 }
             } else {
                 // Script-path spending
-                const controlBlock = witness[witness.length - 1]!;
+                const controlBlock = witness[witness.length - 1] as Uint8Array;
                 if (controlBlock.length < 33) {
                     throw new TypeError(
                         `The control-block length is too small. Got ${controlBlock.length}, expected min 33.`,
@@ -720,8 +726,9 @@ export class P2TR {
                     throw new TypeError('Invalid internalPubkey for p2tr witness');
                 }
 
-                const leafVersion = controlBlock[0]! & TAPLEAF_VERSION_MASK;
-                const script = witness[witness.length - 2]!;
+                const controlBlockFirstByte = controlBlock[0] as number;
+                const leafVersion = controlBlockFirstByte & TAPLEAF_VERSION_MASK;
+                const script = witness[witness.length - 2] as Uint8Array;
 
                 const leafHash = tapleafHash({
                     output: script,
@@ -738,7 +745,7 @@ export class P2TR {
                     throw new TypeError('Pubkey mismatch for p2tr witness');
                 }
 
-                if (outputKey.parity !== (controlBlock[0]! & 1)) {
+                if (outputKey.parity !== (controlBlockFirstByte & 1)) {
                     throw new Error('Incorrect parity');
                 }
             }

package/src/payments/p2wpkh.ts

@@ -454,21 +454,23 @@ export class P2WPKH {
             if (this.#inputWitness.length !== 2) {
                 throw new TypeError('Witness is invalid');
             }
-            if (!bscript.isCanonicalScriptSignature(this.#inputWitness[0]!)) {
+            const witnessSig = this.#inputWitness[0] as Uint8Array;
+            const witnessPubkey = this.#inputWitness[1] as Uint8Array;
+            if (!bscript.isCanonicalScriptSignature(witnessSig)) {
                 throw new TypeError('Witness has invalid signature');
             }
-            if (!isPoint(this.#inputWitness[1]!) || this.#inputWitness[1].length !== 33) {
+            if (!isPoint(witnessPubkey) || witnessPubkey.length !== 33) {
                 throw new TypeError('Witness has invalid pubkey');
             }
 
-            if (this.#inputSignature && !equals(this.#inputSignature, this.#inputWitness[0]!)) {
+            if (this.#inputSignature && !equals(this.#inputSignature, witnessSig)) {
                 throw new TypeError('Signature mismatch');
             }
-            if (this.#inputPubkey && !equals(this.#inputPubkey, this.#inputWitness[1])) {
+            if (this.#inputPubkey && !equals(this.#inputPubkey, witnessPubkey)) {
                 throw new TypeError('Pubkey mismatch');
             }
 
-            const pkh = bcrypto.hash160(this.#inputWitness[1]);
+            const pkh = bcrypto.hash160(witnessPubkey);
             if (hash.length > 0 && !equals(hash, pkh)) {
                 throw new TypeError('Hash mismatch');
             }

package/src/payments/p2wsh.ts

@@ -523,7 +523,7 @@ export class P2WSH {
         }
 
         if (this.#inputWitness && this.#inputWitness.length > 0) {
-            const wScript = this.#inputWitness[this.#inputWitness.length - 1]!;
+            const wScript = this.#inputWitness[this.#inputWitness.length - 1] as Uint8Array;
             if (
                 this.#inputRedeem &&
                 this.#inputRedeem.output &&

package/src/psbt/PsbtCache.ts

@@ -75,7 +75,7 @@ export class PsbtCache {
         if (!cached) {
             this.addNonWitnessTxCache(input, inputIndex, txFromBuffer);
         }
-        return this.nonWitnessUtxoTxCache[inputIndex]!;
+        return this.nonWitnessUtxoTxCache[inputIndex] as Transaction;
     }
 
     public getScriptFromUtxo(
@@ -99,7 +99,8 @@ export class PsbtCache {
             };
         } else if (input.nonWitnessUtxo !== undefined) {
             const nonWitnessUtxoTx = this.getNonWitnessUtxoTx(input, inputIndex, txFromBuffer);
-            const o = nonWitnessUtxoTx.outs[this.tx.ins[inputIndex]!.index]!;
+            const txIn = this.tx.ins[inputIndex] as Transaction['ins'][0];
+            const o = nonWitnessUtxoTx.outs[txIn.index] as Transaction['outs'][0];
             return { script: o.script, value: o.value };
         } else {
             throw new Error("Can't find pubkey in input without Utxo data");
@@ -192,7 +193,7 @@ export class PsbtCache {
     }
 
     public pubkeyInOutput(pubkey: PublicKey, output: PsbtOutput, outputIndex: number): boolean {
-        const script = this.tx.outs[outputIndex]!.script;
+        const script = (this.tx.outs[outputIndex] as Transaction['outs'][0]).script;
         const { meaningfulScript } = getMeaningfulScript(
             script,
             outputIndex,
@@ -207,7 +208,7 @@ export class PsbtCache {
         if (!finalScript) return;
         const decomp = bscript.decompile(finalScript);
         if (!decomp) return;
-        const lastItem = decomp[decomp.length - 1]!;
+        const lastItem = decomp[decomp.length - 1];
         if (!(lastItem instanceof Uint8Array) || isPubkeyLike(lastItem) || isSigLike(lastItem))
             return;
         const sDecomp = bscript.decompile(lastItem);
@@ -220,7 +221,8 @@ export class PsbtCache {
     ): Uint8Array | undefined {
         if (!finalScript) return;
         const decomp = scriptWitnessToWitnessStack(finalScript);
-        const lastItem = decomp[decomp.length - 1]!;
+        const lastItem = decomp[decomp.length - 1];
+        if (!lastItem) return;
         if (isPubkeyLike(lastItem)) return;
         const sDecomp = bscript.decompile(lastItem);
         if (!sDecomp) return;
@@ -240,10 +242,11 @@ export class PsbtCache {
     ): { fee: number; feeRate: number } {
         let inputAmount = 0n;
         inputs.forEach((input, idx) => {
+            const txIn = tx.ins[idx] as Transaction['ins'][0];
             if (mustFinalize && input.finalScriptSig)
-                tx.ins[idx]!.script = input.finalScriptSig as Script;
+                txIn.script = input.finalScriptSig as Script;
             if (mustFinalize && input.finalScriptWitness) {
-                tx.ins[idx]!.witness = scriptWitnessToWitnessStack(input.finalScriptWitness);
+                txIn.witness = scriptWitnessToWitnessStack(input.finalScriptWitness);
             }
             if (input.witnessUtxo) {
                 inputAmount += input.witnessUtxo.value;
@@ -251,8 +254,8 @@ export class PsbtCache {
                 if (!txFromBuffer)
                     throw new Error('txFromBuffer is required for nonWitnessUtxo inputs');
                 const nwTx = this.getNonWitnessUtxoTx(input, idx, txFromBuffer);
-                const vout = tx.ins[idx]!.index;
-                const out = nwTx.outs[vout]!;
+                const vout = txIn.index;
+                const out = nwTx.outs[vout] as Transaction['outs'][0];
                 inputAmount += out.value;
             }
         });
@@ -296,8 +299,8 @@ export class PsbtCache {
         } else {
             if (input.nonWitnessUtxo) {
                 const nonWitnessUtxoTx = this.getNonWitnessUtxoTx(input, inputIndex, txFromBuffer);
-                const prevoutIndex = this.tx.ins[inputIndex]!.index;
-                res.script = nonWitnessUtxoTx.outs[prevoutIndex]!.script;
+                const prevoutIndex = (this.tx.ins[inputIndex] as Transaction['ins'][0]).index;
+                res.script = (nonWitnessUtxoTx.outs[prevoutIndex] as Transaction['outs'][0]).script;
             } else if (input.witnessUtxo) {
                 res.script = input.witnessUtxo.script as Script;
             }

package/src/psbt/PsbtFinalizer.ts

@@ -175,23 +175,29 @@ function getPayment(script: Uint8Array, scriptType: string, partialSig: PartialS
                 signatures: sigs as Signature[],
             });
         }
-        case 'pubkey':
+        case 'pubkey': {
+            const sig0 = partialSig[0] as PartialSig;
             return payments.p2pk({
                 output: scriptBranded,
-                signature: partialSig[0]!.signature as Signature,
+                signature: sig0.signature as Signature,
             });
-        case 'pubkeyhash':
+        }
+        case 'pubkeyhash': {
+            const sig0 = partialSig[0] as PartialSig;
             return payments.p2pkh({
                 output: scriptBranded,
-                pubkey: partialSig[0]!.pubkey as PublicKey,
-                signature: partialSig[0]!.signature as Signature,
+                pubkey: sig0.pubkey as PublicKey,
+                signature: sig0.signature as Signature,
             });
-        case 'witnesspubkeyhash':
+        }
+        case 'witnesspubkeyhash': {
+            const sig0 = partialSig[0] as PartialSig;
             return payments.p2wpkh({
                 output: scriptBranded,
-                pubkey: partialSig[0]!.pubkey as PublicKey,
-                signature: partialSig[0]!.signature as Signature,
+                pubkey: sig0.pubkey as PublicKey,
+                signature: sig0.signature as Signature,
             });
+        }
         default:
             throw new Error(`Unknown script type: ${scriptType}`);
     }

package/src/psbt/PsbtSigner.ts

@@ -69,7 +69,8 @@ export class PsbtSigner {
                 this.#txFromBuffer,
             );
 
-            const prevoutHash = unsignedTx.ins[inputIndex]!.hash;
+            const txIn = unsignedTx.ins[inputIndex] as Transaction['ins'][0];
+            const prevoutHash = txIn.hash;
             const utxoHash = nonWitnessUtxoTx.getHash();
 
             if (!equals(prevoutHash, utxoHash)) {
@@ -78,8 +79,8 @@ export class PsbtSigner {
                 );
             }
 
-            const prevoutIndex = unsignedTx.ins[inputIndex]!.index;
-            prevout = nonWitnessUtxoTx.outs[prevoutIndex]!;
+            const prevoutIndex = txIn.index;
+            prevout = nonWitnessUtxoTx.outs[prevoutIndex] as Transaction['outs'][0];
         } else if (input.witnessUtxo) {
             prevout = {
                 script: input.witnessUtxo.script as Script,

package/src/psbt/PsbtTransaction.ts

@@ -3,7 +3,7 @@ import { fromHex, reverse } from '../io/index.js';
 import { Transaction } from '../transaction.js';
 import type { Bytes32 } from '../types.js';
 import { checkTxEmpty } from './validation.js';
-import type { TransactionInput, TransactionOutput } from './types.js';
+import type { PsbtTxOutput, TransactionInput } from './types.js';
 
 /**
  * Empty version-2 transaction with zero inputs and zero outputs.
@@ -56,7 +56,7 @@ export class PsbtTransaction implements ITransaction {
         this.tx.addInput(hash, input.index, input.sequence);
     }
 
-    public addOutput(output: TransactionOutput): void {
+    public addOutput(output: PsbtTxOutput): void {
         if (
             output.script === undefined ||
             output.value === undefined ||

package/src/psbt/bip371.ts

@@ -180,10 +180,11 @@ export function tapTreeToList(tree: Taptree): TapLeaf[] {
  * @returns the corresponding taptree, or throws an exception if the tree cannot be reconstructed
  */
 export function tapTreeFromList(leaves: TapLeaf[] = []): Taptree {
-    if (leaves.length === 1 && leaves[0]!.depth === 0)
+    const firstLeaf = leaves[0];
+    if (leaves.length === 1 && firstLeaf && firstLeaf.depth === 0)
         return {
-            output: new Uint8Array(leaves[0]!.script),
-            version: leaves[0]!.leafVersion,
+            output: new Uint8Array(firstLeaf.script),
+            version: firstLeaf.leafVersion,
         };
 
     return insertLeavesInTree(leaves);

package/src/psbt/utils.ts

@@ -73,7 +73,7 @@ export function sighashTypeToString(sighashType: number): string {
  */
 export function compressPubkey(pubkey: Uint8Array): Uint8Array {
     if (pubkey.length === 65) {
-        const parity = pubkey[64]! & 1;
+        const parity = (pubkey[64] as number) & 1;
         const newKey = new Uint8Array(pubkey.subarray(0, 33));
         newKey[0] = 2 | parity;
         return newKey;

package/src/psbt.ts

@@ -3,6 +3,7 @@ import type {
     PsbtGlobalUpdate,
     PsbtInput,
     PsbtInputUpdate,
+    PsbtOutput,
     PsbtOutputUpdate,
     TapKeySig,
     TapScriptSig,
@@ -79,6 +80,7 @@ export type {
     PsbtInputExtended,
     PsbtOutputExtended,
     PsbtOutputExtendedScript,
+    PsbtOutputExtendedAddress,
     HDSigner,
     HDSignerAsync,
     Signer,
@@ -348,7 +350,7 @@ export class Psbt {
         if (this.#cache.tx.ins.length <= inputIndex) {
             throw new Error('Input index too high');
         }
-        this.#cache.tx.ins[inputIndex]!.sequence = sequence;
+        (this.#cache.tx.ins[inputIndex] as { sequence: number }).sequence = sequence;
         this.#cache.invalidate('outputs');
         return this;
     }
@@ -386,11 +388,11 @@ export class Psbt {
               }
             : inputData;
         this.data.addInput(normalizedInputData);
-        const txIn = this.#cache.tx.ins[this.#cache.tx.ins.length - 1]!;
+        const txIn = this.#cache.tx.ins[this.#cache.tx.ins.length - 1] as Transaction['ins'][0];
         checkTxInputCache(this.#cache, txIn);
 
         const inputIndex = this.data.inputs.length - 1;
-        const input = this.data.inputs[inputIndex]!;
+        const input = this.data.inputs[inputIndex] as PsbtInput;
         if (input.nonWitnessUtxo) {
             this.#cache.addNonWitnessTxCache(input, inputIndex, txFromBuffer);
         }
@@ -558,7 +560,7 @@ export class Psbt {
         validator: ValidateSigFunction,
         pubkey?: PublicKey,
     ): boolean {
-        const input = this.data.inputs[inputIndex]!;
+        const input = this.data.inputs[inputIndex] as PsbtInput;
         if (isTaprootInput(input))
             return this.#validateSignaturesOfTaprootInput(inputIndex, validator, pubkey);
 
@@ -795,7 +797,7 @@ export class Psbt {
 
     public updateInput(inputIndex: number, updateData: PsbtInputUpdate): this {
         if (updateData.witnessScript) checkInvalidP2WSH(updateData.witnessScript);
-        checkTaprootInputFields(this.data.inputs[inputIndex]!, updateData, 'updateInput');
+        checkTaprootInputFields(this.data.inputs[inputIndex] as PsbtInput, updateData, 'updateInput');
         const normalizedUpdate = updateData.witnessUtxo
             ? {
                   ...updateData,
@@ -811,7 +813,7 @@ export class Psbt {
         this.data.updateInput(inputIndex, normalizedUpdate);
         if (updateData.nonWitnessUtxo) {
             this.#cache.addNonWitnessTxCache(
-                this.data.inputs[inputIndex]!,
+                this.data.inputs[inputIndex] as PsbtInput,
                 inputIndex,
                 txFromBuffer,
             );
@@ -820,7 +822,7 @@ export class Psbt {
     }
 
     public updateOutput(outputIndex: number, updateData: PsbtOutputUpdate): this {
-        const outputData = this.data.outputs[outputIndex]!;
+        const outputData = this.data.outputs[outputIndex] as PsbtOutput;
         checkTaprootOutputFields(outputData, updateData, 'updateOutput');
 
         this.data.updateOutput(outputIndex, updateData);
@@ -986,7 +988,7 @@ export class Psbt {
         validator: ValidateSigFunction,
         pubkey?: PublicKey,
     ): boolean {
-        const input = this.data.inputs[inputIndex]!;
+        const input = this.data.inputs[inputIndex] as PsbtInput;
         const tapKeySig = input?.tapKeySig;
         const tapScriptSig = input?.tapScriptSig;
         if (!input && !tapKeySig && !(tapScriptSig && !tapScriptSig.length))

package/src/push_data.ts

@@ -61,19 +61,19 @@ export function decode(
     size: number;
 } | null {
     const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-    const opcode = buffer[offset];
+    const opcode = buffer[offset] as number;
     let num: number;
     let size: number;
 
     // ~6 bit
-    if (opcode! < opcodes.OP_PUSHDATA1) {
-        num = opcode!;
+    if (opcode < opcodes.OP_PUSHDATA1) {
+        num = opcode;
         size = 1;
 
         // 8 bit
     } else if (opcode === opcodes.OP_PUSHDATA1) {
         if (offset + 2 > buffer.length) return null;
-        num = buffer[offset + 1]!;
+        num = buffer[offset + 1] as number;
         size = 2;
 
         // 16 bit
@@ -92,7 +92,7 @@ export function decode(
     }
 
     return {
-        opcode: opcode!,
+        opcode,
         number: num,
         size,
     };

package/src/react-native-quick-crypto.d.ts

@@ -0,0 +1,11 @@
+declare module 'react-native-quick-crypto' {
+    interface Hash {
+        update(data: Uint8Array | string): Hash;
+        digest(): Buffer;
+    }
+    interface QuickCrypto {
+        createHash(algorithm: string): Hash;
+    }
+    const QuickCrypto: QuickCrypto;
+    export default QuickCrypto;
+}

package/src/script.ts

@@ -41,8 +41,9 @@ export function countNonPushOnlyOPs(value: Stack): number {
 function asMinimalOP(buffer: Uint8Array): number | undefined {
     if (buffer.length === 0) return opcodes.OP_0;
     if (buffer.length !== 1) return undefined;
-    if (buffer[0]! >= 1 && buffer[0]! <= 16) return OP_INT_BASE + buffer[0]!;
-    if (buffer[0] === 0x81) return opcodes.OP_1NEGATE;
+    const firstByte = buffer[0] as number;
+    if (firstByte >= 1 && firstByte <= 16) return OP_INT_BASE + firstByte;
+    if (firstByte === 0x81) return opcodes.OP_1NEGATE;
     return undefined;
 }
 
@@ -129,7 +130,7 @@ export function decompile(buffer: Uint8Array | Stack): Array<number | Uint8Array
     let i = 0;
 
     while (i < buffer.length) {
-        const opcode = buffer[i]!;
+        const opcode = buffer[i] as number;
 
         // data chunk
         if (opcode > opcodes.OP_0 && opcode <= opcodes.OP_PUSHDATA4) {
@@ -248,7 +249,7 @@ export function isCanonicalPubKey(buffer: Uint8Array): boolean {
 
 export function isCanonicalScriptSignature(buffer: Uint8Array): boolean {
     if (!(buffer instanceof Uint8Array)) return false;
-    if (!isDefinedHashType(buffer[buffer.length - 1]!)) return false;
+    if (!isDefinedHashType(buffer[buffer.length - 1] as number)) return false;
 
     return bip66.check(buffer.subarray(0, -1));
 }

package/src/script_number.ts

@@ -16,8 +16,8 @@ export function decode(buffer: Buffer, maxLength?: number, minimal?: boolean): n
     if (length === 0) return 0;
     if (length > maxLength) throw new TypeError('Script number overflow');
     if (minimal) {
-        if ((buffer[length - 1]! & 0x7f) === 0) {
-            if (length <= 1 || (buffer[length - 2]! & 0x80) === 0)
+        if (((buffer[length - 1] as number) & 0x7f) === 0) {
+            if (length <= 1 || ((buffer[length - 2] as number) & 0x80) === 0)
                 throw new Error('Non-minimally encoded script number');
         }
     }
@@ -34,10 +34,10 @@ export function decode(buffer: Buffer, maxLength?: number, minimal?: boolean): n
     // 32-bit / 24-bit / 16-bit / 8-bit
     let result = 0;
     for (let i = 0; i < length; ++i) {
-        result |= buffer[i]! << (8 * i);
+        result |= (buffer[i] as number) << (8 * i);
     }
 
-    if (buffer[length - 1]! & 0x80) return -(result & ~(0x80 << (8 * (length - 1))));
+    if ((buffer[length - 1] as number) & 0x80) return -(result & ~(0x80 << (8 * (length - 1))));
     return result;
 }
 
@@ -62,10 +62,10 @@ export function encode(_number: number): Buffer {
         value >>= 8;
     }
 
-    if (buffer[size - 1]! & 0x80) {
+    if ((buffer[size - 1] as number) & 0x80) {
         buffer.writeUInt8(negative ? 0x80 : 0x00, size - 1);
     } else if (negative) {
-        buffer[size - 1]! |= 0x80;
+        buffer[size - 1] = (buffer[size - 1] as number) | 0x80;
     }
 
     return buffer;

package/src/script_signature.ts

@@ -24,7 +24,7 @@ function toDER(x: Uint8Array): Uint8Array {
     while (x[i] === 0) ++i;
     if (i === x.length) return ZERO;
     x = x.subarray(i);
-    if (x[0]! & 0x80) return concat([ZERO, x]);
+    if ((x[0] as number) & 0x80) return concat([ZERO, x]);
     return x;
 }
 
@@ -56,7 +56,7 @@ export interface ScriptSignature {
  * @throws Error if the hashType is invalid.
  */
 export function decode(buffer: Uint8Array): ScriptSignature {
-    const hashType = buffer[buffer.length - 1]!;
+    const hashType = buffer[buffer.length - 1] as number;
     if (!isDefinedHashType(hashType)) {
         throw new Error(`Invalid hashType ${hashType}`);
     }