ecash-lib 1.5.1 → 2.0.0

package/src/hash.ts

@@ -12,35 +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;
+const HASHES: EcashLibHashes = {};
 
 export function sha256(data: Uint8Array): Uint8Array {
-    return HASHES.sha256(data);
+    return HASHES.sha256!(data);
 }
 export function sha256d(data: Uint8Array): Uint8Array {
-    return HASHES.sha256d(data);
+    return HASHES.sha256d!(data);
 }
 export function shaRmd160(data: Uint8Array): Uint8Array {
-    return 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;
+    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;
             }