ecash-lib 2.1.0 → 3.1.0

package/src/ffi/ecash_lib_wasm_bg_browser.wasm.d.ts

@@ -1,6 +1,18 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
+export function ecc_new(): number;
+export function ecc_derivePubkey(a: number, b: number, c: number, d: number): void;
+export function ecc_ecdsaSign(a: number, b: number, c: number, d: number, e: number, f: number): void;
+export function ecc_ecdsaVerify(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number): void;
+export function ecc_schnorrSign(a: number, b: number, c: number, d: number, e: number, f: number): void;
+export function ecc_schnorrVerify(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number): void;
+export function ecc_isValidSeckey(a: number, b: number, c: number): number;
+export function ecc_seckeyAdd(a: number, b: number, c: number, d: number, e: number, f: number): void;
+export function ecc_pubkeyAdd(a: number, b: number, c: number, d: number, e: number, f: number): void;
+export function ecc_signRecoverable(a: number, b: number, c: number, d: number, e: number, f: number): void;
+export function ecc_recoverSig(a: number, b: number, c: number, d: number, e: number, f: number): void;
+export function __wbg_ecc_free(a: number): void;
 export function sha512h_new(): number;
 export function sha512h_update(a: number, b: number, c: number): void;
 export function sha512h_finalize(a: number, b: number): void;
@@ -14,21 +26,11 @@ export function sha512(a: number, b: number, c: number): void;
 export function sha256d(a: number, b: number, c: number): void;
 export function sha256(a: number, b: number, c: number): void;
 export function shaRmd160(a: number, b: number, c: number): void;
-export function ecc_new(): number;
-export function ecc_derivePubkey(a: number, b: number, c: number, d: number): void;
-export function ecc_ecdsaSign(a: number, b: number, c: number, d: number, e: number, f: number): void;
-export function ecc_schnorrSign(a: number, b: number, c: number, d: number, e: number, f: number): void;
-export function ecc_isValidSeckey(a: number, b: number, c: number): number;
-export function ecc_seckeyAdd(a: number, b: number, c: number, d: number, e: number, f: number): void;
-export function ecc_pubkeyAdd(a: number, b: number, c: number, d: number, e: number, f: number): void;
-export function ecc_signRecoverable(a: number, b: number, c: number, d: number, e: number, f: number): void;
-export function ecc_recoverSig(a: number, b: number, c: number, d: number, e: number, f: number): void;
-export function __wbg_ecc_free(a: number): void;
 export function ecash_secp256k1_context_create(a: number): number;
 export function ecash_secp256k1_context_destroy(a: number): void;
 export function secp256k1_default_illegal_callback_fn(a: number, b: number): void;
 export function secp256k1_default_error_callback_fn(a: number, b: number): void;
 export function __wbg_sha512h_free(a: number): void;
-export function __wbindgen_export_0(a: number, b: number): number;
 export function __wbindgen_add_to_stack_pointer(a: number): number;
+export function __wbindgen_export_0(a: number, b: number): number;
 export function __wbindgen_export_1(a: number, b: number, c: number): void;

package/src/ffi/ecash_lib_wasm_bg_nodejs.wasm.d.ts

@@ -1,6 +1,18 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
+export function ecc_new(): number;
+export function ecc_derivePubkey(a: number, b: number, c: number, d: number): void;
+export function ecc_ecdsaSign(a: number, b: number, c: number, d: number, e: number, f: number): void;
+export function ecc_ecdsaVerify(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number): void;
+export function ecc_schnorrSign(a: number, b: number, c: number, d: number, e: number, f: number): void;
+export function ecc_schnorrVerify(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number): void;
+export function ecc_isValidSeckey(a: number, b: number, c: number): number;
+export function ecc_seckeyAdd(a: number, b: number, c: number, d: number, e: number, f: number): void;
+export function ecc_pubkeyAdd(a: number, b: number, c: number, d: number, e: number, f: number): void;
+export function ecc_signRecoverable(a: number, b: number, c: number, d: number, e: number, f: number): void;
+export function ecc_recoverSig(a: number, b: number, c: number, d: number, e: number, f: number): void;
+export function __wbg_ecc_free(a: number): void;
 export function sha512h_new(): number;
 export function sha512h_update(a: number, b: number, c: number): void;
 export function sha512h_finalize(a: number, b: number): void;
@@ -14,21 +26,11 @@ export function sha512(a: number, b: number, c: number): void;
 export function sha256d(a: number, b: number, c: number): void;
 export function sha256(a: number, b: number, c: number): void;
 export function shaRmd160(a: number, b: number, c: number): void;
-export function ecc_new(): number;
-export function ecc_derivePubkey(a: number, b: number, c: number, d: number): void;
-export function ecc_ecdsaSign(a: number, b: number, c: number, d: number, e: number, f: number): void;
-export function ecc_schnorrSign(a: number, b: number, c: number, d: number, e: number, f: number): void;
-export function ecc_isValidSeckey(a: number, b: number, c: number): number;
-export function ecc_seckeyAdd(a: number, b: number, c: number, d: number, e: number, f: number): void;
-export function ecc_pubkeyAdd(a: number, b: number, c: number, d: number, e: number, f: number): void;
-export function ecc_signRecoverable(a: number, b: number, c: number, d: number, e: number, f: number): void;
-export function ecc_recoverSig(a: number, b: number, c: number, d: number, e: number, f: number): void;
-export function __wbg_ecc_free(a: number): void;
 export function ecash_secp256k1_context_create(a: number): number;
 export function ecash_secp256k1_context_destroy(a: number): void;
 export function secp256k1_default_illegal_callback_fn(a: number, b: number): void;
 export function secp256k1_default_error_callback_fn(a: number, b: number): void;
 export function __wbg_sha512h_free(a: number): void;
-export function __wbindgen_export_0(a: number, b: number): number;
 export function __wbindgen_add_to_stack_pointer(a: number): number;
+export function __wbindgen_export_0(a: number, b: number): number;
 export function __wbindgen_export_1(a: number, b: number, c: number): void;

package/src/ffi/ecash_lib_wasm_browser.d.ts

@@ -47,6 +47,13 @@ export class Ecc {
 */
   ecdsaSign(seckey: Uint8Array, msg: Uint8Array): Uint8Array;
 /**
+* Verify an ECDSA signature.
+* @param {Uint8Array} sig
+* @param {Uint8Array} msg
+* @param {Uint8Array} pk
+*/
+  ecdsaVerify(sig: Uint8Array, msg: Uint8Array, pk: Uint8Array): void;
+/**
 * Sign a Schnorr signature.
 * @param {Uint8Array} seckey
 * @param {Uint8Array} msg
@@ -54,6 +61,13 @@ export class Ecc {
 */
   schnorrSign(seckey: Uint8Array, msg: Uint8Array): Uint8Array;
 /**
+* Verify a Schnorr signature.
+* @param {Uint8Array} sig
+* @param {Uint8Array} msg
+* @param {Uint8Array} pk
+*/
+  schnorrVerify(sig: Uint8Array, msg: Uint8Array, pk: Uint8Array): void;
+/**
 * Return whether the given secret key is valid, i.e. whether is of correct
 * length (32 bytes) and is on the curve.
 * @param {Uint8Array} seckey
@@ -152,6 +166,18 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 
 export interface InitOutput {
   readonly memory: WebAssembly.Memory;
+  readonly ecc_new: () => number;
+  readonly ecc_derivePubkey: (a: number, b: number, c: number, d: number) => void;
+  readonly ecc_ecdsaSign: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly ecc_ecdsaVerify: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+  readonly ecc_schnorrSign: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly ecc_schnorrVerify: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+  readonly ecc_isValidSeckey: (a: number, b: number, c: number) => number;
+  readonly ecc_seckeyAdd: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly ecc_pubkeyAdd: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly ecc_signRecoverable: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly ecc_recoverSig: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly __wbg_ecc_free: (a: number) => void;
   readonly sha512h_new: () => number;
   readonly sha512h_update: (a: number, b: number, c: number) => void;
   readonly sha512h_finalize: (a: number, b: number) => void;
@@ -165,23 +191,13 @@ export interface InitOutput {
   readonly sha256d: (a: number, b: number, c: number) => void;
   readonly sha256: (a: number, b: number, c: number) => void;
   readonly shaRmd160: (a: number, b: number, c: number) => void;
-  readonly ecc_new: () => number;
-  readonly ecc_derivePubkey: (a: number, b: number, c: number, d: number) => void;
-  readonly ecc_ecdsaSign: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-  readonly ecc_schnorrSign: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-  readonly ecc_isValidSeckey: (a: number, b: number, c: number) => number;
-  readonly ecc_seckeyAdd: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-  readonly ecc_pubkeyAdd: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-  readonly ecc_signRecoverable: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-  readonly ecc_recoverSig: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-  readonly __wbg_ecc_free: (a: number) => void;
   readonly ecash_secp256k1_context_create: (a: number) => number;
   readonly ecash_secp256k1_context_destroy: (a: number) => void;
   readonly secp256k1_default_illegal_callback_fn: (a: number, b: number) => void;
   readonly secp256k1_default_error_callback_fn: (a: number, b: number) => void;
   readonly __wbg_sha512h_free: (a: number) => void;
-  readonly __wbindgen_export_0: (a: number, b: number) => number;
   readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+  readonly __wbindgen_export_0: (a: number, b: number) => number;
   readonly __wbindgen_export_1: (a: number, b: number, c: number) => void;
 }
 

package/src/ffi/ecash_lib_wasm_browser.js

@@ -51,6 +51,20 @@ function getInt32Memory0() {
     return cachedInt32Memory0;
 }
 
+function getObject(idx) { return heap[idx]; }
+
+function dropObject(idx) {
+    if (idx < 132) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
@@ -139,20 +153,6 @@ export function shaRmd160(data) {
     }
 }
 
-function getObject(idx) { return heap[idx]; }
-
-function dropObject(idx) {
-    if (idx < 132) return;
-    heap[idx] = heap_next;
-    heap_next = idx;
-}
-
-function takeObject(idx) {
-    const ret = getObject(idx);
-    dropObject(idx);
-    return ret;
-}
-
 const EccFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_ecc_free(ptr >>> 0));
@@ -234,6 +234,31 @@ export class Ecc {
         }
     }
     /**
+    * Verify an ECDSA signature.
+    * @param {Uint8Array} sig
+    * @param {Uint8Array} msg
+    * @param {Uint8Array} pk
+    */
+    ecdsaVerify(sig, msg, pk) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(sig, wasm.__wbindgen_export_0);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArray8ToWasm0(msg, wasm.__wbindgen_export_0);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArray8ToWasm0(pk, wasm.__wbindgen_export_0);
+            const len2 = WASM_VECTOR_LEN;
+            wasm.ecc_ecdsaVerify(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
     * Sign a Schnorr signature.
     * @param {Uint8Array} seckey
     * @param {Uint8Array} msg
@@ -262,6 +287,31 @@ export class Ecc {
         }
     }
     /**
+    * Verify a Schnorr signature.
+    * @param {Uint8Array} sig
+    * @param {Uint8Array} msg
+    * @param {Uint8Array} pk
+    */
+    schnorrVerify(sig, msg, pk) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(sig, wasm.__wbindgen_export_0);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArray8ToWasm0(msg, wasm.__wbindgen_export_0);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArray8ToWasm0(pk, wasm.__wbindgen_export_0);
+            const len2 = WASM_VECTOR_LEN;
+            wasm.ecc_schnorrVerify(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
     * Return whether the given secret key is valid, i.e. whether is of correct
     * length (32 bytes) and is on the curve.
     * @param {Uint8Array} seckey

package/src/ffi/ecash_lib_wasm_nodejs.d.ts

@@ -47,6 +47,13 @@ export class Ecc {
 */
   ecdsaSign(seckey: Uint8Array, msg: Uint8Array): Uint8Array;
 /**
+* Verify an ECDSA signature.
+* @param {Uint8Array} sig
+* @param {Uint8Array} msg
+* @param {Uint8Array} pk
+*/
+  ecdsaVerify(sig: Uint8Array, msg: Uint8Array, pk: Uint8Array): void;
+/**
 * Sign a Schnorr signature.
 * @param {Uint8Array} seckey
 * @param {Uint8Array} msg
@@ -54,6 +61,13 @@ export class Ecc {
 */
   schnorrSign(seckey: Uint8Array, msg: Uint8Array): Uint8Array;
 /**
+* Verify a Schnorr signature.
+* @param {Uint8Array} sig
+* @param {Uint8Array} msg
+* @param {Uint8Array} pk
+*/
+  schnorrVerify(sig: Uint8Array, msg: Uint8Array, pk: Uint8Array): void;
+/**
 * Return whether the given secret key is valid, i.e. whether is of correct
 * length (32 bytes) and is on the curve.
 * @param {Uint8Array} seckey

package/src/ffi/ecash_lib_wasm_nodejs.js

@@ -54,6 +54,20 @@ function getInt32Memory0() {
     return cachedInt32Memory0;
 }
 
+function getObject(idx) { return heap[idx]; }
+
+function dropObject(idx) {
+    if (idx < 132) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
@@ -142,20 +156,6 @@ module.exports.shaRmd160 = function(data) {
     }
 };
 
-function getObject(idx) { return heap[idx]; }
-
-function dropObject(idx) {
-    if (idx < 132) return;
-    heap[idx] = heap_next;
-    heap_next = idx;
-}
-
-function takeObject(idx) {
-    const ret = getObject(idx);
-    dropObject(idx);
-    return ret;
-}
-
 const EccFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_ecc_free(ptr >>> 0));
@@ -237,6 +237,31 @@ class Ecc {
         }
     }
     /**
+    * Verify an ECDSA signature.
+    * @param {Uint8Array} sig
+    * @param {Uint8Array} msg
+    * @param {Uint8Array} pk
+    */
+    ecdsaVerify(sig, msg, pk) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(sig, wasm.__wbindgen_export_0);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArray8ToWasm0(msg, wasm.__wbindgen_export_0);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArray8ToWasm0(pk, wasm.__wbindgen_export_0);
+            const len2 = WASM_VECTOR_LEN;
+            wasm.ecc_ecdsaVerify(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
     * Sign a Schnorr signature.
     * @param {Uint8Array} seckey
     * @param {Uint8Array} msg
@@ -265,6 +290,31 @@ class Ecc {
         }
     }
     /**
+    * Verify a Schnorr signature.
+    * @param {Uint8Array} sig
+    * @param {Uint8Array} msg
+    * @param {Uint8Array} pk
+    */
+    schnorrVerify(sig, msg, pk) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(sig, wasm.__wbindgen_export_0);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArray8ToWasm0(msg, wasm.__wbindgen_export_0);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArray8ToWasm0(pk, wasm.__wbindgen_export_0);
+            const len2 = WASM_VECTOR_LEN;
+            wasm.ecc_schnorrVerify(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
     * Return whether the given secret key is valid, i.e. whether is of correct
     * length (32 bytes) and is on the curve.
     * @param {Uint8Array} seckey

package/src/hdwallet.ts

@@ -139,6 +139,7 @@ export class HdNode {
             splitPath = splitPath.slice(1);
         }
 
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
         let hd: HdNode = this;
         for (const step of splitPath) {
             if (step.slice(-1) === `'`) {

package/src/index.ts

@@ -8,6 +8,7 @@ export * from './hash.js';
 export * from './op.js';
 export * from './opcode.js';
 export * from './script.js';
+export * from './messages.js';
 export * from './mnemonic.js';
 export * from './hdwallet.js';
 export * from './address/address.js';

package/src/messages.ts

@@ -0,0 +1,125 @@
+// Copyright (c) 2025 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+import { sha256d, shaRmd160 } from './hash';
+import { Ecc } from './ecc';
+import { WriterBytes } from './io/writerbytes';
+import { writeVarSize } from './io/varsize';
+import { toHex } from './io/hex';
+import { Address } from './address/address';
+
+/**
+ * messages.ts
+ *
+ * Sign and verify messages
+ */
+
+const ECASH_MSG_SIGNING_PREFIX = '\x16eCash Signed Message:\n';
+
+/**
+ * Messages are prepared in a standard way before signing and verifying
+ *
+ * - The raw message (e.g., "Hello, world!") is encoded as a UTF-8 byte array
+ * - The prefixed message is constructed as:
+ *
+ *   [prefix][message_length][message]
+ *
+ *   where message_length is a variable-length integer (varint) encoding the
+ *   byte length of the message
+ *
+ * We keep the "magicHash" name used in bitcoinjs-message as we do the same thing here
+ * with eCash tools
+ *
+ * ref https://github.com/bitcoinjs/bitcoinjs-message/blob/master/index.js#L57
+ */
+export const magicHash = (
+    message: string,
+    messagePrefix = ECASH_MSG_SIGNING_PREFIX,
+): Uint8Array => {
+    const encoder = new TextEncoder();
+
+    // Convert prefix to Uint8Array
+    const prefixBytes = encoder.encode(messagePrefix);
+
+    // Convert message to Uint8Array
+    const messageBytes = encoder.encode(message);
+
+    // Calculate the maximum possible size of the varint for message length
+    const maxVarintSize =
+        messageBytes.length <= 0xfc
+            ? 1
+            : messageBytes.length <= 0xffff
+            ? 3
+            : messageBytes.length <= 0xffffffff
+            ? 5
+            : 9;
+
+    // Create a WriterBytes instance with enough capacity
+    const writer = new WriterBytes(
+        prefixBytes.length + maxVarintSize + messageBytes.length,
+    );
+
+    // Write the prefix
+    writer.putBytes(prefixBytes);
+
+    // Write the message length as a varint
+    writeVarSize(messageBytes.length, writer);
+
+    // Write the message
+    writer.putBytes(messageBytes);
+
+    // Return double SHA-256 hash
+    return sha256d(writer.data);
+};
+
+/**
+ * Sign a message
+ *
+ * While there is not an official BIP or spec here, there is
+ * a de facto standard
+ *
+ * See implementation in bitcoinjs-lib and electrum
+ */
+export const signMsg = (
+    msg: string,
+    sk: Uint8Array,
+    prefix = ECASH_MSG_SIGNING_PREFIX,
+): string => {
+    const preparedMsg = magicHash(msg, prefix);
+    const sig = new Ecc().signRecoverable(sk, preparedMsg);
+
+    // Convert Uint8Array to binary string and encode with btoa
+    const binaryString = String.fromCharCode(...sig);
+    return btoa(binaryString);
+};
+
+/**
+ * Verify that a given message and signature
+ * came from a given address
+ */
+export const verifyMsg = (
+    msg: string,
+    signature: string,
+    address: string,
+    prefix = ECASH_MSG_SIGNING_PREFIX,
+): boolean => {
+    try {
+        const preparedMsg = magicHash(msg, prefix);
+
+        // Decode base64 signature to binary string and convert to Uint8Array
+        const binaryString = atob(signature);
+        const sig = new Uint8Array(binaryString.length);
+        for (let i = 0; i < binaryString.length; i++) {
+            sig[i] = binaryString.charCodeAt(i);
+        }
+        const recoveredPk = new Ecc().recoverSig(sig, preparedMsg);
+        // Get recovered hash as a hex string and compare to tested hash
+        const recoveredHash = toHex(shaRmd160(recoveredPk));
+        const testedHash = Address.fromCashAddress(address).hash;
+        return recoveredHash === testedHash;
+    } catch (err) {
+        console.error(`Error verifying signature`, err);
+        return false;
+    }
+};

package/src/op.ts

@@ -33,6 +33,8 @@ export function isPushOp(op: any): op is PushOp {
     if (!op || typeof op !== 'object') {
         return false;
     }
+
+    // eslint-disable-next-line no-prototype-builtins
     if (!op.hasOwnProperty('opcode') || !op.hasOwnProperty('data')) {
         return false;
     }
@@ -137,8 +139,8 @@ export function pushNumberOp(value: number | bigint): Op {
     // Prepare number for encoding. The algorithm below replicates the one used
     // in `src/script/script.h` intentionally to avoid discrepancies.
     const auxValue = BigInt(value);
-    let bytes: number[] = [];
-    let negative = auxValue < 0;
+    const bytes: number[] = [];
+    const negative = auxValue < 0;
     let absvalue = negative ? ~auxValue + 1n : auxValue;
 
     // Encode value in little endian byte order by iteratively pushing the
@@ -151,7 +153,7 @@ export function pushNumberOp(value: number | bigint): Op {
     // The MSB will encode the sign which means that, if the previous encoding
     // of the absolute value uses that bit, a new byte must be added to encode
     // the sign. If bit is not set, then it must be set for negative numbers.
-    let last = bytes[bytes.length - 1];
+    const last = bytes[bytes.length - 1];
     if (last & 0x80) {
         bytes.push(negative ? 0x80 : 0x00);
     } else if (negative) {

package/src/sigHashType.ts

@@ -48,8 +48,8 @@ export class SigHashType {
                 outputFlags == 1
                     ? SigHashTypeOutputs.ALL
                     : outputFlags == 2
-                      ? SigHashTypeOutputs.NONE
-                      : SigHashTypeOutputs.SINGLE,
+                    ? SigHashTypeOutputs.NONE
+                    : SigHashTypeOutputs.SINGLE,
         });
     }
 

package/src/test/testRunner.ts

@@ -5,7 +5,6 @@
 import type { ChronikClient } from 'chronik-client';
 import type { ChildProcess } from 'node:child_process';
 
-import { Ecc } from '../ecc.js';
 import { shaRmd160 } from '../hash.js';
 import { fromHex, toHex } from '../io/hex.js';
 import { pushBytesOp } from '../op.js';
@@ -26,7 +25,7 @@ export class TestRunner {
     public runner: ChildProcess;
     public chronik: ChronikClient;
     private coinsTxid: string | undefined;
-    private coinValue: number | undefined;
+    private coinValue: bigint | undefined;
     private lastUsedOutIdx: number;
 
     private constructor(runner: ChildProcess, chronik: ChronikClient) {
@@ -120,7 +119,7 @@ export class TestRunner {
 
     public async setupCoins(
         numCoins: number,
-        coinValue: number,
+        coinValue: bigint,
     ): Promise<void> {
         const opTrueScriptHash = shaRmd160(OP_TRUE_SCRIPT.bytecode);
         const utxos = (
@@ -135,19 +134,19 @@ export class TestRunner {
                 sequence: 0xffffffff,
             })),
         });
-        const utxosValue = utxos.reduce((a, b) => a + b.value, 0);
+        const utxosValue = utxos.reduce((a, b) => a + b.sats, 0n);
         for (let i = 0; i < numCoins; ++i) {
             tx.outputs.push({
-                value: coinValue,
+                sats: coinValue,
                 script: anyoneP2sh,
             });
         }
         tx.outputs.push({
-            value: 0,
+            sats: 0n,
             script: Script.fromOps([OP_RETURN]),
         });
-        tx.outputs[tx.outputs.length - 1].value =
-            utxosValue - numCoins * coinValue - tx.serSize();
+        tx.outputs[tx.outputs.length - 1].sats =
+            utxosValue - BigInt(numCoins) * coinValue - BigInt(tx.serSize());
 
         this.coinsTxid = (await this.chronik.broadcastTx(tx.ser())).txid;
         this.coinValue = coinValue;
@@ -164,11 +163,11 @@ export class TestRunner {
     }
 
     public async sendToScript(
-        value: number | number[],
+        sats: bigint | bigint[],
         script: Script,
     ): Promise<string> {
         const coinValue = this.coinValue!;
-        const values = Array.isArray(value) ? value : [value];
+        const satsArr = Array.isArray(sats) ? sats : [sats];
         const setupTxBuilder = new TxBuilder({
             inputs: [
                 {
@@ -177,17 +176,20 @@ export class TestRunner {
                         script: ANYONE_SCRIPT_SIG,
                         sequence: 0xffffffff,
                         signData: {
-                            value: coinValue,
+                            sats: coinValue,
                         },
                     },
                 },
             ],
             outputs: [
-                ...values.map(value => ({ value, script })),
+                ...satsArr.map(sats => ({ sats, script })),
                 Script.fromOps([OP_RETURN]), // burn leftover
             ],
         });
-        const setupTx = setupTxBuilder.sign({ feePerKb: 1000, dustLimit: 546 });
+        const setupTx = setupTxBuilder.sign({
+            feePerKb: 1000n,
+            dustSats: 546n,
+        });
         return (await this.chronik.broadcastTx(setupTx.ser())).txid;
     }