ecash-lib 3.0.0 → 3.2.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';
@@ -24,6 +25,10 @@ export * from './io/writer.js';
 export * from './io/writerbytes.js';
 export * from './io/writerlength.js';
 export * from './token/alp.js';
+export * from './token/alp.parse.js';
 export * from './token/common.js';
 export * from './token/empp.js';
 export * from './token/slp.js';
+export * from './token/slp.parse.js';
+
+export * as payment from './payment';

package/src/io/bytes.ts

@@ -53,6 +53,14 @@ export class Bytes {
         return result;
     }
 
+    /** Read 6-byte little-endian integer */
+    public readU48(): bigint {
+        this.ensureSize(6);
+        const low = this.readU32('LE');
+        const high = this.readU16('LE');
+        return BigInt(low) | (BigInt(high) << 32n);
+    }
+
     /** Read 8-byte little-endian integer (uint64_t) */
     public readU64(endian?: Endian): bigint {
         this.ensureSize(8);
@@ -71,9 +79,10 @@ export class Bytes {
 
     private ensureSize(extraBytes: number) {
         if (this.data.length < this.idx + extraBytes) {
-            throw (
+            const bytesLeft = this.data.length - this.idx;
+            throw new Error(
                 `Not enough bytes: Tried reading ${extraBytes} byte(s), but ` +
-                `there are only ${this.data.length - this.idx} byte(s) left`
+                    `there are only ${bytesLeft} byte(s) left`,
             );
         }
     }

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) {