ecash-lib 0.2.0-rc → 0.2.0

package/README.md

@@ -1,21 +1,84 @@
 # ecash-lib
 
-Library for eCash transaction building.
+Library for [eCash](https://e.cash) transaction building.
+
+-   Compatible: Works on the browser using webpack, on NodeJS, jest etc.
+-   Fast: Accelerated using the highly optimized secp256k1 library compiled to WebAssembly
+-   Simple to use: Describe the tx to build in one TxBuilder object, and build the tx with just one `sign` call
+-   SLP/ALP enabled: Functions to build the SLP/ALP eMPP scripts
+-   Flexible: The "Signatory" mechanism can accommodate anything from simple wallet transfers to complex Script covenants, e.g. eCash Agora
+-   Schnorr: eCash lib supports Schnorr and ECDSA signatures
+-   Precise leftover ("change") computation: The tx size estimator will be exact for Schnorr signatures and very close for ECDSA signatures, even for complex scripts
 
 ## Usage
 
+This library works for both browser and NodeJS.
+
+### Installation
+
+`npm install --save ecash-lib`
+
+### Setup
+
+To use this library, you first have to initialize the WebAssembly module:
+
 ```ts
-import { Tx, Script, fromHex, toHex } from 'ecash-lib';
+import { initWasm } from 'ecash-lib';
+await initWasm();
+```
+
+After that, to sign signatures, you need an "Ecc" instance:
+
+```ts
+import { Ecc } from 'ecash-lib';
+const ecc = new Ecc();
+```
 
-const tx = new Tx({
+**Note: You should only call this function once, as it's fairly expensive to setup, it internally precomputes some elliptic curve field elements, which takes some time**
+
+### Usage
+
+Now you're ready to sign your first transactions:
+
+```ts
+import {
+    Ecc,
+    P2PKHSignatory,
+    Script,
+    TxBuilder,
+    fromHex,
+    initWasm,
+    shaRmd160,
+    toHex,
+} from 'ecash-lib';
+
+// Download and compile WebAssembly
+await initWasm();
+// Build a signature context for elliptic curve cryptography (ECC)
+const ecc = new Ecc();
+const walletSk = fromHex(
+    'e6ae1669c47d092eff3eb652bea535331c338e29f34be709bc4055655cd0e950',
+);
+const walletPk = ecc.derivePubkey(walletSk);
+const walletPkh = shaRmd160(walletPk);
+const walletP2pkh = Script.p2pkh(walletPkh);
+// TxId with unspent funds for the above wallet
+const walletUtxo = {
+    txid: '0000000000000000000000000000000000000000000000000000000000000000',
+    outIdx: 0,
+};
+// Tx builder
+const txBuild = new TxBuilder({
     inputs: [
         {
-            prevOut: {
-                txid: new Uint8Array(32),
-                outIdx: 0,
+            inputs: {
+                prevOut: walletUtxo,
+                signData: {
+                    value: 1000,
+                    outputScript: walletP2pkh,
+                },
             },
-            script: new Script(),
-            sequence: 0xffffffff,
+            signatory: P2PKHSignatory(walletSk, walletPk, ALL_BIP143),
         },
     ],
     outputs: [
@@ -23,15 +86,17 @@ const tx = new Tx({
             value: 0,
             script: new Script(fromHex('6a68656c6c6f')),
         },
-        {
-            value: 546,
-            script: new Script(
-                fromHex('a914d37c4c809fe9840e7bfa77b86bd47163f6fb6c6087'),
-            ),
-        },
+        walletP2pkh,
     ],
 });
-
+const tx = txBuild.sign(ecc, 1000, 546);
 const rawTx = tx.ser();
 console.log(toHex(rawTx));
 ```
+
+## Changelog
+
+-   0.1.1 - Validation that feePerKb is an integer
+-   0.1.2 - Upgrade dependencies [D16373](https://reviews.bitcoinabc.org/D16373)
+-   0.1.3 - Export `slpAmount` function [D16379](https://reviews.bitcoinabc.org/D16379)
+-   0.2.0 - Add `Script.fromAddress` method to convert cashaddr addresses to `Script`

package/dist/{src/ecc.d.ts → ecc.d.ts}

@@ -1,4 +1,3 @@
-import * as ffi from './ffi/ecash_lib_wasm.js';
 /** Interface to abstract over Elliptic Curve Cryptography */
 export interface Ecc {
     /** Derive a public key from secret key. */
@@ -9,11 +8,16 @@ export interface Ecc {
     schnorrSign(seckey: Uint8Array, msg: Uint8Array): Uint8Array;
 }
 /** Ecc implementation using WebAssembly */
-export declare const EccWasm: typeof ffi.Ecc;
+export declare let Ecc: {
+    new (): Ecc;
+};
 /** Dummy Ecc impl that always returns 0, useful for measuring tx size */
 export declare class EccDummy implements Ecc {
     derivePubkey(_seckey: Uint8Array): Uint8Array;
     ecdsaSign(_seckey: Uint8Array, _msg: Uint8Array): Uint8Array;
     schnorrSign(_seckey: Uint8Array, _msg: Uint8Array): Uint8Array;
 }
+export declare function __setEcc(ecc: {
+    new (): Ecc;
+}): void;
 //# sourceMappingURL=ecc.d.ts.map

package/dist/ecc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ecc.d.ts","sourceRoot":"","sources":["../src/ecc.ts"],"names":[],"mappings":"AAIA,6DAA6D;AAC7D,MAAM,WAAW,GAAG;IAChB,2CAA2C;IAC3C,YAAY,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU,CAAC;IAE7C,8DAA8D;IAC9D,SAAS,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,GAAG,UAAU,CAAC;IAE3D,+DAA+D;IAC/D,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,GAAG,UAAU,CAAC;CAChE;AAED,2CAA2C;AAC3C,eAAO,IAAI,GAAG,EAAE;IAAE,QAAQ,GAAG,CAAA;CAAE,CAAC;AAEhC,yEAAyE;AACzE,qBAAa,QAAS,YAAW,GAAG;IAChC,YAAY,CAAC,OAAO,EAAE,UAAU,GAAG,UAAU;IAI7C,SAAS,CAAC,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,GAAG,UAAU;IAI5D,WAAW,CAAC,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,GAAG,UAAU;CAGjE;AAED,wBAAgB,QAAQ,CAAC,GAAG,EAAE;IAAE,QAAQ,GAAG,CAAA;CAAE,QAE5C"}

package/dist/{src/ecc.js → ecc.js}

@@ -1,13 +1,11 @@
+"use strict";
 // Copyright (c) 2024 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
-// These files are generated in "ecash-lib-wasm" via build-wasm.sh or
-// dockerbuild.sh.
-import * as ffi from './ffi/ecash_lib_wasm.js';
-/** Ecc implementation using WebAssembly */
-export const EccWasm = ffi.Ecc;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__setEcc = exports.EccDummy = exports.Ecc = void 0;
 /** Dummy Ecc impl that always returns 0, useful for measuring tx size */
-export class EccDummy {
+class EccDummy {
     derivePubkey(_seckey) {
         return new Uint8Array(33);
     }
@@ -18,4 +16,9 @@ export class EccDummy {
         return new Uint8Array(64);
     }
 }
+exports.EccDummy = EccDummy;
+function __setEcc(ecc) {
+    exports.Ecc = ecc;
+}
+exports.__setEcc = __setEcc;
 //# sourceMappingURL=ecc.js.map

package/dist/ecc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ecc.js","sourceRoot":"","sources":["../src/ecc.ts"],"names":[],"mappings":";AAAA,4CAA4C;AAC5C,mEAAmE;AACnE,sEAAsE;;;AAiBtE,yEAAyE;AACzE,MAAa,QAAQ;IACjB,YAAY,CAAC,OAAmB;QAC5B,OAAO,IAAI,UAAU,CAAC,EAAE,CAAC,CAAC;IAC9B,CAAC;IAED,SAAS,CAAC,OAAmB,EAAE,IAAgB;QAC3C,OAAO,IAAI,UAAU,CAAC,EAAE,CAAC,CAAC;IAC9B,CAAC;IAED,WAAW,CAAC,OAAmB,EAAE,IAAgB;QAC7C,OAAO,IAAI,UAAU,CAAC,EAAE,CAAC,CAAC;IAC9B,CAAC;CACJ;AAZD,4BAYC;AAED,SAAgB,QAAQ,CAAC,GAAoB;IACzC,WAAG,GAAG,GAAG,CAAC;AACd,CAAC;AAFD,4BAEC"}

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

@@ -0,0 +1,16 @@
+/* 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_schnorrSign(a: number, b: number, c: number, d: number, e: number, f: number): void;
+export function __wbg_ecc_free(a: 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 secp256k1_default_illegal_callback_fn(a: number, b: number): void;
+export function secp256k1_default_error_callback_fn(a: number, b: number): void;
+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/dist/ffi/{ecash_lib_wasm.js → ecash_lib_wasm_browser.js}

@@ -321,7 +321,7 @@ async function __wbg_init(input) {
     if (wasm !== undefined) return wasm;
 
     if (typeof input === 'undefined') {
-        input = new URL('ecash_lib_wasm_bg.wasm', import.meta.url);
+        input = new URL('ecash_lib_wasm_bg_browser.wasm', import.meta.url);
     }
     const imports = __wbg_get_imports();
 

package/dist/ffi/ecash_lib_wasm_nodejs.d.ts

@@ -0,0 +1,50 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+* Calculate SHA256(SHA256(data)).
+* @param {Uint8Array} data
+* @returns {Uint8Array}
+*/
+export function sha256d(data: Uint8Array): Uint8Array;
+/**
+* Calculate SHA256(data).
+* @param {Uint8Array} data
+* @returns {Uint8Array}
+*/
+export function sha256(data: Uint8Array): Uint8Array;
+/**
+* Calculate RIPEMD160(SHA256(data)), commonly used as address hash.
+* @param {Uint8Array} data
+* @returns {Uint8Array}
+*/
+export function shaRmd160(data: Uint8Array): Uint8Array;
+/**
+* ECC signatures with libsecp256k1.
+*/
+export class Ecc {
+  free(): void;
+/**
+* Create a new Ecc instance.
+*/
+  constructor();
+/**
+* Derive a public key from secret key.
+* @param {Uint8Array} seckey
+* @returns {Uint8Array}
+*/
+  derivePubkey(seckey: Uint8Array): Uint8Array;
+/**
+* Sign an ECDSA signature.
+* @param {Uint8Array} seckey
+* @param {Uint8Array} msg
+* @returns {Uint8Array}
+*/
+  ecdsaSign(seckey: Uint8Array, msg: Uint8Array): Uint8Array;
+/**
+* Sign a Schnorr signature.
+* @param {Uint8Array} seckey
+* @param {Uint8Array} msg
+* @returns {Uint8Array}
+*/
+  schnorrSign(seckey: Uint8Array, msg: Uint8Array): Uint8Array;
+}

package/dist/ffi/ecash_lib_wasm_nodejs.js

@@ -0,0 +1,265 @@
+let imports = {};
+imports['__wbindgen_placeholder__'] = module.exports;
+let wasm;
+const { TextDecoder } = require(`util`);
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+let cachedUint8Memory0 = null;
+
+function getUint8Memory0() {
+    if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
+        cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8Memory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
+}
+
+const heap = new Array(128).fill(undefined);
+
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+let WASM_VECTOR_LEN = 0;
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8Memory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+let cachedInt32Memory0 = null;
+
+function getInt32Memory0() {
+    if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
+        cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
+    }
+    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);
+}
+/**
+* Calculate SHA256(SHA256(data)).
+* @param {Uint8Array} data
+* @returns {Uint8Array}
+*/
+module.exports.sha256d = function(data) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export_0);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.sha256d(retptr, ptr0, len0);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        var v2 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export_1(r0, r1 * 1, 1);
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+/**
+* Calculate SHA256(data).
+* @param {Uint8Array} data
+* @returns {Uint8Array}
+*/
+module.exports.sha256 = function(data) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export_0);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.sha256(retptr, ptr0, len0);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        var v2 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export_1(r0, r1 * 1, 1);
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+/**
+* Calculate RIPEMD160(SHA256(data)), commonly used as address hash.
+* @param {Uint8Array} data
+* @returns {Uint8Array}
+*/
+module.exports.shaRmd160 = function(data) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export_0);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.shaRmd160(retptr, ptr0, len0);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        var v2 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export_1(r0, r1 * 1, 1);
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+const EccFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_ecc_free(ptr >>> 0));
+/**
+* ECC signatures with libsecp256k1.
+*/
+class Ecc {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        EccFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_ecc_free(ptr);
+    }
+    /**
+    * Create a new Ecc instance.
+    */
+    constructor() {
+        const ret = wasm.ecc_new();
+        this.__wbg_ptr = ret >>> 0;
+        return this;
+    }
+    /**
+    * Derive a public key from secret key.
+    * @param {Uint8Array} seckey
+    * @returns {Uint8Array}
+    */
+    derivePubkey(seckey) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(seckey, wasm.__wbindgen_export_0);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.ecc_derivePubkey(retptr, this.__wbg_ptr, ptr0, len0);
+            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 v2 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export_1(r0, r1 * 1, 1);
+            return v2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * Sign an ECDSA signature.
+    * @param {Uint8Array} seckey
+    * @param {Uint8Array} msg
+    * @returns {Uint8Array}
+    */
+    ecdsaSign(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_ecdsaSign(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);
+        }
+    }
+    /**
+    * Sign a Schnorr signature.
+    * @param {Uint8Array} seckey
+    * @param {Uint8Array} msg
+    * @returns {Uint8Array}
+    */
+    schnorrSign(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_schnorrSign(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;
+
+module.exports.__wbindgen_string_new = function(arg0, arg1) {
+    const ret = getStringFromWasm0(arg0, arg1);
+    return addHeapObject(ret);
+};
+
+module.exports.__wbindgen_throw = function(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+};
+
+const path = require('path').join(__dirname, 'ecash_lib_wasm_bg_nodejs.wasm');
+const bytes = require('fs').readFileSync(path);
+
+const wasmModule = new WebAssembly.Module(bytes);
+const wasmInstance = new WebAssembly.Instance(wasmModule, imports);
+wasm = wasmInstance.exports;
+module.exports.__wasm = wasm;
+

package/dist/hash.d.ts

@@ -0,0 +1,11 @@
+interface EcashLibHashes {
+    sha256: (data: Uint8Array) => Uint8Array;
+    sha256d: (data: Uint8Array) => Uint8Array;
+    shaRmd160: (data: Uint8Array) => Uint8Array;
+}
+export declare function sha256(data: Uint8Array): Uint8Array;
+export declare function sha256d(data: Uint8Array): Uint8Array;
+export declare function shaRmd160(data: Uint8Array): Uint8Array;
+export declare function __setHashes(hashes: EcashLibHashes): void;
+export {};
+//# sourceMappingURL=hash.d.ts.map

package/dist/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../src/hash.ts"],"names":[],"mappings":"AAIA,UAAU,cAAc;IACpB,MAAM,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,UAAU,CAAC;IACzC,OAAO,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,UAAU,CAAC;IAC1C,SAAS,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,UAAU,CAAC;CAC/C;AAID,wBAAgB,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAEnD;AACD,wBAAgB,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAEpD;AACD,wBAAgB,SAAS,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAEtD;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,cAAc,QAEjD"}

package/dist/hash.js

@@ -0,0 +1,24 @@
+"use strict";
+// Copyright (c) 2024 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__setHashes = exports.shaRmd160 = exports.sha256d = exports.sha256 = void 0;
+let HASHES;
+function sha256(data) {
+    return HASHES.sha256(data);
+}
+exports.sha256 = sha256;
+function sha256d(data) {
+    return HASHES.sha256d(data);
+}
+exports.sha256d = sha256d;
+function shaRmd160(data) {
+    return HASHES.shaRmd160(data);
+}
+exports.shaRmd160 = shaRmd160;
+function __setHashes(hashes) {
+    HASHES = hashes;
+}
+exports.__setHashes = __setHashes;
+//# sourceMappingURL=hash.js.map

package/dist/hash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.js","sourceRoot":"","sources":["../src/hash.ts"],"names":[],"mappings":";AAAA,4CAA4C;AAC5C,mEAAmE;AACnE,sEAAsE;;;AAQtE,IAAI,MAAsB,CAAC;AAE3B,SAAgB,MAAM,CAAC,IAAgB;IACnC,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;AAC/B,CAAC;AAFD,wBAEC;AACD,SAAgB,OAAO,CAAC,IAAgB;IACpC,OAAO,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;AAChC,CAAC;AAFD,0BAEC;AACD,SAAgB,SAAS,CAAC,IAAgB;IACtC,OAAO,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;AAClC,CAAC;AAFD,8BAEC;AAED,SAAgB,WAAW,CAAC,MAAsB;IAC9C,MAAM,GAAG,MAAM,CAAC;AACpB,CAAC;AAFD,kCAEC"}

package/dist/{src/index.d.ts → index.d.ts}

@@ -1,6 +1,5 @@
 export * from './ecc.js';
 export * from './hash.js';
-export * from './init.js';
 export * from './op.js';
 export * from './opcode.js';
 export * from './script.js';
@@ -11,8 +10,13 @@ export * from './unsignedTx.js';
 export * from './io/bytes.js';
 export * from './io/hex.js';
 export * from './io/int.js';
+export * from './io/str.js';
 export * from './io/varsize.js';
 export * from './io/writer.js';
 export * from './io/writerbytes.js';
 export * from './io/writerlength.js';
+export * from './token/alp.js';
+export * from './token/common.js';
+export * from './token/empp.js';
+export * from './token/slp.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,SAAS,CAAC;AACxB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,41 @@
+"use strict";
+// Copyright (c) 2024 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ecc.js"), exports);
+__exportStar(require("./hash.js"), exports);
+__exportStar(require("./op.js"), exports);
+__exportStar(require("./opcode.js"), exports);
+__exportStar(require("./script.js"), exports);
+__exportStar(require("./sigHashType.js"), exports);
+__exportStar(require("./tx.js"), exports);
+__exportStar(require("./txBuilder.js"), exports);
+__exportStar(require("./unsignedTx.js"), exports);
+__exportStar(require("./io/bytes.js"), exports);
+__exportStar(require("./io/hex.js"), exports);
+__exportStar(require("./io/int.js"), exports);
+__exportStar(require("./io/str.js"), exports);
+__exportStar(require("./io/varsize.js"), exports);
+__exportStar(require("./io/writer.js"), exports);
+__exportStar(require("./io/writerbytes.js"), exports);
+__exportStar(require("./io/writerlength.js"), exports);
+__exportStar(require("./token/alp.js"), exports);
+__exportStar(require("./token/common.js"), exports);
+__exportStar(require("./token/empp.js"), exports);
+__exportStar(require("./token/slp.js"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA,4CAA4C;AAC5C,mEAAmE;AACnE,sEAAsE;;;;;;;;;;;;;;;;AAEtE,2CAAyB;AACzB,4CAA0B;AAC1B,0CAAwB;AACxB,8CAA4B;AAC5B,8CAA4B;AAC5B,mDAAiC;AACjC,0CAAwB;AACxB,iDAA+B;AAC/B,kDAAgC;AAChC,gDAA8B;AAC9B,8CAA4B;AAC5B,8CAA4B;AAC5B,8CAA4B;AAC5B,kDAAgC;AAChC,iDAA+B;AAC/B,sDAAoC;AACpC,uDAAqC;AACrC,iDAA+B;AAC/B,oDAAkC;AAClC,kDAAgC;AAChC,iDAA+B"}

package/dist/indexBrowser.d.ts

@@ -0,0 +1,3 @@
+export * from './index.js';
+export * from './initBrowser.js';
+//# sourceMappingURL=indexBrowser.d.ts.map

package/dist/indexBrowser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexBrowser.d.ts","sourceRoot":"","sources":["../src/indexBrowser.ts"],"names":[],"mappings":"AAIA,cAAc,YAAY,CAAC;AAC3B,cAAc,kBAAkB,CAAC"}

package/dist/indexBrowser.js

@@ -0,0 +1,22 @@
+"use strict";
+// Copyright (c) 2024 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./index.js"), exports);
+__exportStar(require("./initBrowser.js"), exports);
+//# sourceMappingURL=indexBrowser.js.map

package/dist/indexBrowser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexBrowser.js","sourceRoot":"","sources":["../src/indexBrowser.ts"],"names":[],"mappings":";AAAA,4CAA4C;AAC5C,mEAAmE;AACnE,sEAAsE;;;;;;;;;;;;;;;;AAEtE,6CAA2B;AAC3B,mDAAiC"}