ecash-lib 1.5.2-rc → 2.1.0

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

@@ -21,6 +21,8 @@ export function ecc_schnorrSign(a: number, b: number, c: number, d: number, e: n
 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;

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

@@ -21,6 +21,8 @@ export function ecc_schnorrSign(a: number, b: number, c: number, d: number, e: n
 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;

package/src/ffi/ecash_lib_wasm_browser.d.ts

@@ -74,6 +74,28 @@ export class Ecc {
 * @returns {Uint8Array}
 */
   pubkeyAdd(a: Uint8Array, b: Uint8Array): Uint8Array;
+/**
+* Create a compact ECDSA signature (65 bytes), which allows reconstructing
+* the used public key.
+* The format is one header byte, followed by two times 32 bytes for the
+* serialized r and s values.
+* The header byte: 0x1B = first key with even y,
+*                  0x1C = first key with odd y,
+*                  0x1D = second key with even y,
+*                  0x1E = second key with odd y,
+*                  add 0x04 for compressed keys.
+* @param {Uint8Array} seckey
+* @param {Uint8Array} msg
+* @returns {Uint8Array}
+*/
+  signRecoverable(seckey: Uint8Array, msg: Uint8Array): Uint8Array;
+/**
+* Recover the public key of a signature signed by signRecoverable.
+* @param {Uint8Array} sig
+* @param {Uint8Array} msg
+* @returns {Uint8Array}
+*/
+  recoverSig(sig: Uint8Array, msg: Uint8Array): Uint8Array;
 }
 /**
 * Instance to calculate SHA256 in a streaming fashion
@@ -150,6 +172,8 @@ export interface InitOutput {
   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;

package/src/ffi/ecash_lib_wasm_browser.js

@@ -329,6 +329,70 @@ export class Ecc {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+    * Create a compact ECDSA signature (65 bytes), which allows reconstructing
+    * the used public key.
+    * The format is one header byte, followed by two times 32 bytes for the
+    * serialized r and s values.
+    * The header byte: 0x1B = first key with even y,
+    *                  0x1C = first key with odd y,
+    *                  0x1D = second key with even y,
+    *                  0x1E = second key with odd y,
+    *                  add 0x04 for compressed keys.
+    * @param {Uint8Array} seckey
+    * @param {Uint8Array} msg
+    * @returns {Uint8Array}
+    */
+    signRecoverable(seckey, msg) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(seckey, wasm.__wbindgen_export_0);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArray8ToWasm0(msg, wasm.__wbindgen_export_0);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.ecc_signRecoverable(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            var r3 = getInt32Memory0()[retptr / 4 + 3];
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v3 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export_1(r0, r1 * 1, 1);
+            return v3;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * Recover the public key of a signature signed by signRecoverable.
+    * @param {Uint8Array} sig
+    * @param {Uint8Array} msg
+    * @returns {Uint8Array}
+    */
+    recoverSig(sig, msg) {
+        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;
+            wasm.ecc_recoverSig(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            var r3 = getInt32Memory0()[retptr / 4 + 3];
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v3 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export_1(r0, r1 * 1, 1);
+            return v3;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
 }
 
 const Sha256HFinalization = (typeof FinalizationRegistry === 'undefined')

package/src/ffi/ecash_lib_wasm_nodejs.d.ts

@@ -74,6 +74,28 @@ export class Ecc {
 * @returns {Uint8Array}
 */
   pubkeyAdd(a: Uint8Array, b: Uint8Array): Uint8Array;
+/**
+* Create a compact ECDSA signature (65 bytes), which allows reconstructing
+* the used public key.
+* The format is one header byte, followed by two times 32 bytes for the
+* serialized r and s values.
+* The header byte: 0x1B = first key with even y,
+*                  0x1C = first key with odd y,
+*                  0x1D = second key with even y,
+*                  0x1E = second key with odd y,
+*                  add 0x04 for compressed keys.
+* @param {Uint8Array} seckey
+* @param {Uint8Array} msg
+* @returns {Uint8Array}
+*/
+  signRecoverable(seckey: Uint8Array, msg: Uint8Array): Uint8Array;
+/**
+* Recover the public key of a signature signed by signRecoverable.
+* @param {Uint8Array} sig
+* @param {Uint8Array} msg
+* @returns {Uint8Array}
+*/
+  recoverSig(sig: Uint8Array, msg: Uint8Array): Uint8Array;
 }
 /**
 * Instance to calculate SHA256 in a streaming fashion

package/src/ffi/ecash_lib_wasm_nodejs.js

@@ -332,6 +332,70 @@ class Ecc {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+    * Create a compact ECDSA signature (65 bytes), which allows reconstructing
+    * the used public key.
+    * The format is one header byte, followed by two times 32 bytes for the
+    * serialized r and s values.
+    * The header byte: 0x1B = first key with even y,
+    *                  0x1C = first key with odd y,
+    *                  0x1D = second key with even y,
+    *                  0x1E = second key with odd y,
+    *                  add 0x04 for compressed keys.
+    * @param {Uint8Array} seckey
+    * @param {Uint8Array} msg
+    * @returns {Uint8Array}
+    */
+    signRecoverable(seckey, msg) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(seckey, wasm.__wbindgen_export_0);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArray8ToWasm0(msg, wasm.__wbindgen_export_0);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.ecc_signRecoverable(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            var r3 = getInt32Memory0()[retptr / 4 + 3];
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v3 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export_1(r0, r1 * 1, 1);
+            return v3;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * Recover the public key of a signature signed by signRecoverable.
+    * @param {Uint8Array} sig
+    * @param {Uint8Array} msg
+    * @returns {Uint8Array}
+    */
+    recoverSig(sig, msg) {
+        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;
+            wasm.ecc_recoverSig(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            var r3 = getInt32Memory0()[retptr / 4 + 3];
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v3 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export_1(r0, r1 * 1, 1);
+            return v3;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
 }
 module.exports.Ecc = Ecc;
 

package/src/hash.ts

@@ -2,8 +2,6 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-import type { Ecc } from './ecc';
-
 export interface Hasher {
     update: (data: Uint8Array) => void;
     finalize: () => Uint8Array;
@@ -14,57 +12,40 @@ export interface Hasher {
 type HasherClass = { new (): Hasher };
 
 interface EcashLibHashes {
-    sha256: (data: Uint8Array) => Uint8Array;
-    sha256d: (data: Uint8Array) => Uint8Array;
-    shaRmd160: (data: Uint8Array) => Uint8Array;
-    sha512: (data: Uint8Array) => Uint8Array;
-    Sha256H: HasherClass;
-    Sha512H: HasherClass;
+    sha256?: (data: Uint8Array) => Uint8Array;
+    sha256d?: (data: Uint8Array) => Uint8Array;
+    shaRmd160?: (data: Uint8Array) => Uint8Array;
+    sha512?: (data: Uint8Array) => Uint8Array;
+    Sha256H?: HasherClass;
+    Sha512H?: HasherClass;
 }
 
-let HASHES: EcashLibHashes;
-
-type GlobalThis = typeof globalThis;
-
-export interface GlobalThisExt extends GlobalThis {
-    ecashlib: {
-        HASHES: EcashLibHashes;
-        Ecc: { new (): Ecc };
-    };
-}
+const HASHES: EcashLibHashes = {};
 
 export function sha256(data: Uint8Array): Uint8Array {
-    return (globalThis as unknown as GlobalThisExt).ecashlib.HASHES.sha256(
-        data,
-    );
+    return HASHES.sha256!(data);
 }
 export function sha256d(data: Uint8Array): Uint8Array {
-    return (globalThis as unknown as GlobalThisExt).ecashlib.HASHES.sha256d(
-        data,
-    );
+    return HASHES.sha256d!(data);
 }
 export function shaRmd160(data: Uint8Array): Uint8Array {
-    return (globalThis as unknown as GlobalThisExt).ecashlib.HASHES.shaRmd160(
-        data,
-    );
+    return HASHES.shaRmd160!(data);
 }
 export function sha512(data: Uint8Array): Uint8Array {
-    return HASHES.sha512(data);
+    return HASHES.sha512!(data);
 }
 export function sha256Hasher(): Hasher {
-    return new HASHES.Sha256H();
+    return new HASHES.Sha256H!();
 }
 export function sha512Hasher(): Hasher {
-    return new HASHES.Sha512H();
+    return new HASHES.Sha512H!();
 }
 
 export function __setHashes(hashes: EcashLibHashes) {
-    HASHES = hashes;
-
-    Object.assign(globalThis, {
-        ecashlib: {
-            ...((globalThis as Record<string, any>).ecashlib || {}),
-            HASHES: hashes,
-        },
-    } as Partial<GlobalThisExt>);
+    HASHES.sha256 = hashes.sha256;
+    HASHES.sha256d = hashes.sha256d;
+    HASHES.shaRmd160 = hashes.shaRmd160;
+    HASHES.sha512 = hashes.sha512;
+    HASHES.Sha256H = hashes.Sha256H;
+    HASHES.Sha512H = hashes.Sha512H;
 }

package/src/hdwallet.ts

@@ -21,7 +21,6 @@ export class HdNode {
     private _parentFingerprint: number;
 
     public constructor(params: {
-        ecc: Ecc;
         seckey: Uint8Array | undefined;
         pubkey: Uint8Array;
         chainCode: Uint8Array;
@@ -29,7 +28,7 @@ export class HdNode {
         index: number;
         parentFingerprint: number;
     }) {
-        this._ecc = params.ecc;
+        this._ecc = new Ecc();
         this._seckey = params.seckey;
         this._pubkey = params.pubkey;
         this._chainCode = params.chainCode;
@@ -113,7 +112,6 @@ export class HdNode {
             seckey = undefined;
         }
         return new HdNode({
-            ecc: this._ecc,
             seckey: seckey,
             pubkey: pubkey,
             chainCode: hashedRight,
@@ -154,14 +152,12 @@ export class HdNode {
     }
 
     public static fromPrivateKey(
-        ecc: Ecc,
         seckey: Uint8Array,
         chainCode: Uint8Array,
     ): HdNode {
         return new HdNode({
-            ecc,
             seckey: seckey,
-            pubkey: ecc.derivePubkey(seckey),
+            pubkey: new Ecc().derivePubkey(seckey),
             chainCode,
             depth: 0,
             index: 0,
@@ -169,13 +165,13 @@ export class HdNode {
         });
     }
 
-    public static fromSeed(ecc: Ecc, seed: Uint8Array): HdNode {
+    public static fromSeed(seed: Uint8Array): HdNode {
         if (seed.length < 16 || seed.length > 64) {
             throw new TypeError('Seed must be between 16 and 64 bytes long');
         }
         const hashed = hmacSha512(strToBytes('Bitcoin seed'), seed);
         const hashedLeft = hashed.slice(0, 32);
         const hashedRight = hashed.slice(32);
-        return HdNode.fromPrivateKey(ecc, hashedLeft, hashedRight);
+        return HdNode.fromPrivateKey(hashedLeft, hashedRight);
     }
 }

package/src/initBrowser.ts

@@ -2,30 +2,23 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-import { __setEcc } from './ecc.js';
-import __wbg_init, * as ffi from './ffi/ecash_lib_wasm_browser.js';
+import * as ffi from './ffi/ecash_lib_wasm_browser.js';
 import { __setHashes } from './hash.js';
+import { __setEcc } from './ecc.js';
+
+import { ECASH_LIB_WASM_BASE64 } from './ffi/ecash_lib_wasm_bg_browser.js';
+
+const wasmRaw = Uint8Array.from(atob(ECASH_LIB_WASM_BASE64), c =>
+    c.charCodeAt(0),
+);
+ffi.initSync(wasmRaw);
 
-/**
- * Load and initialize the WASM module for Web.
- *
- * Some bundlers can't handle WebAssembly yet (at the time of writing, vite).
- * If you run into "CompileError: expected magic word 00 61 73 6d", you can
- * provide a custom WASM URL or module:
- * import ecashLibWasmUrl from 'ecash-lib/dist/ffi/ecash_lib_wasm_bg_browser.wasm?url';
- * await initWasm(ecashLibWasmUrl);
- **/
-export async function initWasm(
-    module_or_path?: ffi.InitInput | Promise<ffi.InitInput>,
-) {
-    await __wbg_init(module_or_path);
-    __setEcc(ffi.Ecc);
-    __setHashes({
-        sha256: ffi.sha256,
-        sha256d: ffi.sha256d,
-        shaRmd160: ffi.shaRmd160,
-        sha512: ffi.sha512,
-        Sha256H: ffi.Sha256H,
-        Sha512H: ffi.Sha512H,
-    });
-}
+__setEcc(new ffi.Ecc());
+__setHashes({
+    sha256: ffi.sha256,
+    sha256d: ffi.sha256d,
+    shaRmd160: ffi.shaRmd160,
+    sha512: ffi.sha512,
+    Sha256H: ffi.Sha256H,
+    Sha512H: ffi.Sha512H,
+});

package/src/initNodeJs.ts

@@ -6,15 +6,12 @@ import { __setEcc } from './ecc.js';
 import * as ffi from './ffi/ecash_lib_wasm_nodejs.js';
 import { __setHashes } from './hash.js';
 
-/** Load and initialize the WASM module for NodeJS */
-export async function initWasm(_dummy?: any) {
-    __setEcc(ffi.Ecc);
-    __setHashes({
-        sha256: ffi.sha256,
-        sha256d: ffi.sha256d,
-        shaRmd160: ffi.shaRmd160,
-        sha512: ffi.sha512,
-        Sha256H: ffi.Sha256H,
-        Sha512H: ffi.Sha512H,
-    });
-}
+__setEcc(new ffi.Ecc());
+__setHashes({
+    sha256: ffi.sha256,
+    sha256d: ffi.sha256d,
+    shaRmd160: ffi.shaRmd160,
+    sha512: ffi.sha512,
+    Sha256H: ffi.Sha256H,
+    Sha512H: ffi.Sha512H,
+});

package/src/test/testRunner.ts

@@ -23,19 +23,13 @@ const ANYONE_SCRIPT = Script.fromOps([pushBytesOp(fromHex('01'.repeat(100)))]);
 const ANYONE_SCRIPT_SIG = Script.fromOps([pushBytesOp(ANYONE_SCRIPT.bytecode)]);
 
 export class TestRunner {
-    public ecc: Ecc;
     public runner: ChildProcess;
     public chronik: ChronikClient;
     private coinsTxid: string | undefined;
     private coinValue: number | undefined;
     private lastUsedOutIdx: number;
 
-    private constructor(
-        ecc: Ecc,
-        runner: ChildProcess,
-        chronik: ChronikClient,
-    ) {
-        this.ecc = ecc;
+    private constructor(runner: ChildProcess, chronik: ChronikClient) {
         this.runner = runner;
         this.chronik = chronik;
         this.coinsTxid = undefined;
@@ -114,8 +108,6 @@ export class TestRunner {
             }
         });
 
-        const ecc = new Ecc();
-
         // We got the coins, can fan out now
         await (events as any).once(statusEvent, 'ready');
 
@@ -123,7 +115,7 @@ export class TestRunner {
             throw new Event('Chronik is undefined');
         }
 
-        return new TestRunner(ecc, runner, chronik);
+        return new TestRunner(runner, chronik);
     }
 
     public async setupCoins(
@@ -195,7 +187,7 @@ export class TestRunner {
                 Script.fromOps([OP_RETURN]), // burn leftover
             ],
         });
-        const setupTx = setupTxBuilder.sign(this.ecc, 1000, 546);
+        const setupTx = setupTxBuilder.sign({ feePerKb: 1000, dustLimit: 546 });
         return (await this.chronik.broadcastTx(setupTx.ser())).txid;
     }
 

package/src/txBuilder.ts

@@ -120,7 +120,12 @@ export class TxBuilder {
     }
 
     /** Sign the tx built by this builder and return a Tx */
-    public sign(ecc: Ecc, feePerKb?: number, dustLimit?: number): Tx {
+    public sign(params?: {
+        ecc?: Ecc;
+        feePerKb?: number;
+        dustLimit?: number;
+    }): Tx {
+        const ecc = params?.ecc ?? new Ecc();
         const { fixedOutputSum, leftoverIdx, outputs } = this.prepareOutputs();
         const inputs = this.inputs.map(input => copyTxInput(input.input));
         const updateSignatories = (ecc: Ecc, unsignedTx: UnsignedTx) => {
@@ -145,15 +150,15 @@ export class TxBuilder {
                     'Using a leftover output requires setting SignData.value for all inputs',
                 );
             }
-            if (feePerKb === undefined) {
+            if (params?.feePerKb === undefined) {
                 throw new Error(
                     'Using a leftover output requires setting feePerKb',
                 );
             }
-            if (!Number.isInteger(feePerKb)) {
+            if (!Number.isInteger(params.feePerKb)) {
                 throw new Error('feePerKb must be an integer');
             }
-            if (dustLimit === undefined) {
+            if (params?.dustLimit === undefined) {
                 throw new Error(
                     'Using a leftover output requires setting dustLimit',
                 );
@@ -169,16 +174,16 @@ export class TxBuilder {
             // Must use dummy here because ECDSA sigs could be too small for fee calc
             updateSignatories(new EccDummy(), dummyUnsignedTx);
             let txSize = dummyUnsignedTx.tx.serSize();
-            let txFee = calcTxFee(txSize, feePerKb);
+            let txFee = calcTxFee(txSize, params.feePerKb);
             const leftoverValue = inputSum - (fixedOutputSum + txFee);
-            if (leftoverValue < dustLimit) {
+            if (leftoverValue < params.dustLimit) {
                 // inputs cannot pay for a dust leftover -> remove & recalc
                 outputs.splice(leftoverIdx, 1);
                 dummyUnsignedTx.tx.outputs = outputs;
                 // Must update signatories again as they might depend on outputs
                 updateSignatories(new EccDummy(), dummyUnsignedTx);
                 txSize = dummyUnsignedTx.tx.serSize();
-                txFee = calcTxFee(txSize, feePerKb);
+                txFee = calcTxFee(txSize, params.feePerKb);
             } else {
                 outputs[leftoverIdx].value = leftoverValue;
             }

package/.nyc_output/0fc40ca6-d52c-45eb-b31b-2601ce70b887.json

@@ -1 +0,0 @@
-{}

package/.nyc_output/ac5be6db-4e40-41f8-8b84-7598d4747e57.json

@@ -1 +0,0 @@
-{}

package/.nyc_output/b316d46f-5ea0-4e98-884a-bfbf9cc1d0f8.json

@@ -1 +0,0 @@
-{}