@xchainjs/zcash-js 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 THORChain
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,71 @@
+# @xchainjs/zcash-js
+
+Zcash JavaScript library for XChainJS - a fork of @mayaprotocol/zcash-js with critical fixes.
+
+## Key Fixes
+
+### NU6.1 Consensus Branch ID (CRITICAL)
+
+This package includes the updated NU6.1 consensus branch ID (`0x4DEC4DF0`) which activated on November 24, 2025 at block height 3,146,400.
+
+The original @mayaprotocol/zcash-js package uses the outdated NU5 branch ID (`0xc8e71055`), causing all transactions to be rejected by the network with "bad-txns-wrong-version" errors.
+
+### Browser Compatibility
+
+- Replaced `blake2b-wasm` with `@noble/hashes/blake2b` - pure JavaScript implementation that works in browsers
+- Uses synchronous hashing instead of async WASM loading
+- No Node.js-specific APIs required
+
+## Usage
+
+```typescript
+import { buildTx, signAndFinalize, getFee } from '@xchainjs/zcash-js'
+
+// Build an unsigned transaction
+const tx = await buildTx(
+  currentHeight,
+  senderAddress,
+  recipientAddress,
+  amount, // in satoshis
+  utxos,
+  true, // isMainnet
+  'optional memo'
+)
+
+// Sign and finalize
+const signedTx = await signAndFinalize(
+  currentHeight,
+  privateKeyHex,
+  tx.inputs,
+  tx.outputs
+)
+
+// Broadcast the hex-encoded transaction
+const txHex = signedTx.toString('hex')
+```
+
+## API
+
+### `buildTx(height, from, to, amount, utxos, isMainnet, memo?)`
+
+Creates an unsigned transaction with automatic UTXO selection.
+
+### `signAndFinalize(height, privateKey, utxos, outputs)`
+
+Signs the transaction and returns the serialized transaction buffer.
+
+### `getFee(inputCount, outputCount, memo?)`
+
+Calculates the transaction fee using Zcash's ZIP 317 fee algorithm.
+
+## Network Upgrade History
+
+| Version | Branch ID | Activation |
+|---------|-----------|------------|
+| NU5 | 0xc8e71055 | May 2022 |
+| NU6 | 0xc8e71055 | Nov 2024 |
+| NU6.1 | 0x4DEC4DF0 | Nov 24, 2025 |
+
+## License
+
+MIT

package/lib/addr.d.ts

@@ -0,0 +1,5 @@
+export declare const testnetPrefix: number[];
+export declare const mainnetPrefix: number[];
+export declare function isValidAddr(address: string, prefix: number[] | Buffer | Uint8Array): boolean;
+export declare function pkToAddr(pk: Uint8Array, prefix: number[] | Uint8Array): string;
+export declare function skToAddr(sk: Uint8Array, prefix: number[] | Uint8Array): string;

package/lib/builder.d.ts

@@ -0,0 +1,4 @@
+import { Output, Tx, UTXO } from './types';
+export declare function getFee(inCount: number, outCount: number, memo?: string): number;
+export declare function buildTx(height: number, from: string, to: string, amount: number, utxos: UTXO[], isMainnet: boolean, memo?: string): Promise<Tx>;
+export declare function signAndFinalize(height: number, skb: string, utxos: UTXO[], outputs: Output[]): Promise<Buffer>;

package/lib/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types';
+export * from './addr';
+export * from './rpc';
+export * from './builder';
+export * from './script';

package/lib/index.esm.js

@@ -0,0 +1,517 @@
+import { secp256k1 } from '@noble/curves/secp256k1';
+import { ripemd160 } from '@noble/hashes/ripemd160';
+import { sha256 } from '@noble/hashes/sha2';
+import bs58check from 'bs58check';
+import axios from 'axios';
+import { JSONRPCClient } from 'json-rpc-2.0';
+import { blake2b } from '@noble/hashes/blake2b';
+import { sumBy, min } from 'lodash';
+
+const testnetPrefix = [0x1d, 0x25];
+const mainnetPrefix = [0x1c, 0xb8];
+function isValidAddr(address, prefix) {
+    try {
+        const addrb = bs58check.decode(address);
+        if (Buffer.from(addrb.slice(0, 2)).compare(Buffer.from(prefix)) != 0) {
+            throw new Error('Invalid prefix');
+        }
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+function pkToAddr(pk, prefix) {
+    const hash = sha256(pk);
+    const pkh = ripemd160(hash);
+    const addrb = Buffer.alloc(22);
+    Buffer.from(prefix).copy(addrb);
+    Buffer.from(pkh).copy(addrb, 2);
+    const addr = bs58check.encode(addrb);
+    return addr;
+}
+function skToAddr(sk, prefix) {
+    const pk = secp256k1.getPublicKey(sk, true);
+    return pkToAddr(pk, prefix);
+}
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+const RPC_TIMEOUT = 30000; // 30 seconds
+function makeClient(config) {
+    const client = new JSONRPCClient((jsonRPCRequest) => __awaiter(this, void 0, void 0, function* () {
+        const response = yield axios.post(config.server.host, jsonRPCRequest, {
+            headers: { 'Content-Type': 'application/json' },
+            auth: {
+                username: config.server.user,
+                password: config.server.password,
+            },
+            timeout: RPC_TIMEOUT,
+        });
+        client.receive(response.data);
+    }));
+    return client;
+}
+function getUTXOS(from, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const client = makeClient(config);
+        const utxos = yield client.request('getaddressutxos', [from]);
+        return utxos;
+    });
+}
+function waitForTransaction(txid_1, config_1) {
+    return __awaiter(this, arguments, void 0, function* (txid, config, maxAttempts = 30) {
+        const client = makeClient(config);
+        for (let i = 0; i < maxAttempts; i++) {
+            try {
+                const tx = yield client.request('gettransaction', [txid]);
+                if (tx && tx.confirmations > 0) {
+                    return;
+                }
+            }
+            catch (_a) {
+                // Transaction might not be in wallet
+            }
+            yield new Promise((resolve) => setTimeout(resolve, 1000));
+        }
+        throw new Error(`Transaction ${txid} not confirmed after ${maxAttempts} attempts`);
+    });
+}
+function sendRawTransaction(txb, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        try {
+            // Direct axios call to get better error details
+            const response = yield axios.post(config.server.host, {
+                jsonrpc: '2.0',
+                method: 'sendrawtransaction',
+                params: [txb.toString('hex')],
+                id: 1,
+            }, {
+                headers: { 'Content-Type': 'application/json' },
+                auth: {
+                    username: config.server.user,
+                    password: config.server.password,
+                },
+                timeout: RPC_TIMEOUT,
+            });
+            if (response.data.error) {
+                console.error('RPC Error:', response.data.error);
+                throw new Error(response.data.error.message);
+            }
+            return response.data.result;
+        }
+        catch (error) {
+            const axiosError = error;
+            if ((_b = (_a = axiosError.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.error) {
+                throw new Error(axiosError.response.data.error.message);
+            }
+            throw error;
+        }
+    });
+}
+
+function writeCompactInt(value) {
+    if (value < 0xfd) {
+        return Buffer.from([value]);
+    }
+    else if (value <= 0xffff) {
+        // 0xFD followed by 16-bit integer
+        const buffer = Buffer.alloc(3);
+        buffer[0] = 0xfd;
+        buffer.writeUInt16LE(value, 1);
+        return buffer;
+    }
+    else if (value <= 0xffffffff) {
+        // 0xFE followed by 32-bit integer
+        const buffer = Buffer.alloc(5);
+        buffer[0] = 0xfe;
+        buffer.writeUInt32LE(value, 1);
+        return buffer;
+    }
+    else {
+        // 0xFF followed by 64-bit integer
+        const buffer = Buffer.alloc(9);
+        buffer[0] = 0xff;
+        const bigValue = BigInt(value);
+        buffer.writeBigUInt64LE(bigValue, 1);
+        return buffer;
+    }
+}
+function pushData(length) {
+    const buf = Buffer.alloc(2);
+    let offset = 0;
+    if (length < 0x4c) {
+        buf[0] = length;
+        offset += 1;
+    }
+    else {
+        buf[0] = 0x4c;
+        buf[1] = length;
+        offset += 2;
+    }
+    return buf.subarray(0, offset);
+}
+
+function memoToScript(memo) {
+    const opr = Buffer.alloc(memo.length + 4);
+    opr[1] = 0x6a;
+    let offset = 2;
+    const pml = pushData(memo.length);
+    pml.copy(opr, offset);
+    offset += pml.length;
+    Buffer.from(memo).copy(opr, offset);
+    offset += memo.length;
+    opr[0] = offset - 1;
+    const script = opr.subarray(0, offset);
+    return script;
+}
+function addressToScript(address) {
+    const addrb = bs58check.decode(address);
+    const pkh = Buffer.alloc(20);
+    Buffer.from(addrb).copy(pkh, 0, 2);
+    const script = Buffer.alloc(26);
+    Buffer.from('1976a914', 'hex').copy(script);
+    Buffer.from(pkh).copy(script, 4);
+    Buffer.from('88ac', 'hex').copy(script, 24);
+    return script;
+}
+function writeSigScript(signature, pk) {
+    const buf = Buffer.alloc(5 + signature.length + pk.length);
+    let offset = 0;
+    const psl = pushData(signature.length + 1);
+    psl.copy(buf, offset);
+    offset += psl.length;
+    Buffer.from(signature).copy(buf, offset);
+    offset += signature.length;
+    buf[offset] = 1;
+    offset += 1;
+    const pkl = pushData(pk.length);
+    pkl.copy(buf, offset);
+    offset += pkl.length;
+    Buffer.from(pk).copy(buf, offset);
+    offset += pk.length;
+    return buf.subarray(0, offset);
+}
+
+// NU6.1 Consensus Branch ID - activated November 24, 2025 at block height 3146400
+// See ZIP 255: https://zips.z.cash/zip-0255
+const NU6_1_CONSENSUS_BRANCH_ID = 0x4dec4df0;
+// Version Group ID for transaction version 5
+const TX_VERSION_GROUP_ID = 0x26a7270a;
+// Transaction version 5 with overwinter flag
+const TX_VERSION = 0x80000005;
+const PKH_OUTPUT_SIZE = 34;
+const MARGINAL_FEE = 5000;
+const GRACE_ACTIONS = 2;
+function calculateFee(inCount, outCount) {
+    const logicalActions = inCount + outCount;
+    return MARGINAL_FEE * Math.max(GRACE_ACTIONS, logicalActions);
+}
+function getFee(inCount, outCount, memo) {
+    if (memo && memo.length > 0) {
+        const memoLenWithOverhead = memo.length + 2;
+        const memoOutputSlots = Math.floor((memoLenWithOverhead + PKH_OUTPUT_SIZE - 1) / PKH_OUTPUT_SIZE);
+        outCount += memoOutputSlots;
+    }
+    return calculateFee(inCount, outCount);
+}
+function selectUTXOS(utxos, amount, memo) {
+    let currentFee = 0;
+    const selected = [];
+    let remaining = amount;
+    for (const utxo of utxos) {
+        if (remaining == 0)
+            break;
+        selected.push(utxo);
+        const fee = getFee(selected.length, 2, memo);
+        const deltaFee = fee - currentFee;
+        currentFee = fee;
+        remaining += deltaFee;
+        const used = min([utxo.satoshis, remaining]);
+        remaining -= used;
+    }
+    return selected;
+}
+/**
+ * Create a blake2b hash with personalization string
+ */
+function blake2bWithPersonal(data, personal) {
+    const personalBytes = typeof personal === 'string' ? new TextEncoder().encode(personal) : personal;
+    // Pad personal to 16 bytes
+    const paddedPersonal = new Uint8Array(16);
+    paddedPersonal.set(personalBytes.slice(0, 16));
+    return blake2b(data, { dkLen: 32, personalization: paddedPersonal });
+}
+function buildTx(height, from, to, amount, utxos, isMainnet, memo) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const prefixb = isMainnet ? mainnetPrefix : testnetPrefix;
+        const prefix = Buffer.from(prefixb);
+        if (!isValidAddr(from, prefix))
+            throw new Error('Invalid "from" address');
+        if (!isValidAddr(to, prefix))
+            throw new Error('Invalid "to" address');
+        if (amount > 1e14)
+            throw new Error('Amount too large');
+        if (memo && memo.length > 80)
+            throw new Error('Memo too long');
+        const inputs = selectUTXOS(utxos, amount, memo);
+        const outputCount = memo ? 3 : 2; // change + to + memo (if exists)
+        const fee = getFee(inputs.length, outputCount, memo);
+        const change = sumBy(inputs, (u) => u.satoshis) - amount - fee;
+        if (change < 0)
+            throw new Error('Not enough funds');
+        const outputs = [];
+        outputs.push({
+            type: 'pkh',
+            address: from,
+            amount: change,
+        });
+        outputs.push({
+            type: 'pkh',
+            address: to,
+            amount: amount,
+        });
+        if (memo) {
+            outputs.push({
+                type: 'op_return',
+                memo: memo,
+            });
+        }
+        return {
+            height: height,
+            inputs: inputs,
+            outputs: outputs,
+            fee: fee,
+        };
+    });
+}
+function signAndFinalize(height, skb, utxos, outputs) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const sk = new Uint8Array(Buffer.from(skb, 'hex'));
+        const pk = secp256k1.getPublicKey(sk, true);
+        let offset = 0;
+        // HEADER with NU6.1 consensus branch ID
+        let buf = Buffer.alloc(20);
+        buf.writeUInt32LE(TX_VERSION, 0); // Transaction version 5 with overwinter flag
+        buf.writeUInt32LE(TX_VERSION_GROUP_ID, 4); // Version group ID
+        buf.writeUInt32LE(NU6_1_CONSENSUS_BRANCH_ID, 8); // NU6.1 consensus branch ID (FIXED!)
+        buf.writeUInt32LE(0x00000000, 12); // Lock time
+        buf.writeUInt32LE(height, 16); // Expiry height
+        const headerHash = Buffer.from(blake2bWithPersonal(buf, 'ZTxIdHeadersHash')).toString('hex');
+        buf = Buffer.alloc(36 * utxos.length);
+        for (const [i, utxo] of utxos.entries()) {
+            const txid = Buffer.from(utxo.txid, 'hex');
+            txid.reverse();
+            txid.copy(buf, 36 * i);
+            buf.writeUInt32LE(utxo.outputIndex, 36 * i + 32);
+        }
+        const prevoutputsHash = Buffer.from(blake2bWithPersonal(buf, 'ZTxIdPrevoutHash')).toString('hex');
+        buf = Buffer.alloc(4 * utxos.length);
+        for (const [i] of utxos.entries()) {
+            buf.writeInt32LE(-1, 4 * i);
+        }
+        const sequencesHash = Buffer.from(blake2bWithPersonal(buf, 'ZTxIdSequencHash')).toString('hex');
+        // Calculate the actual buffer size needed for outputs
+        let outputsBufferSize = 0;
+        for (const output of outputs) {
+            if (output.type === 'pkh') {
+                outputsBufferSize += 34; // 8 bytes amount + 26 bytes script
+            }
+            else if (output.type === 'op_return') {
+                outputsBufferSize += 8 + memoToScript(output.memo).length;
+            }
+        }
+        buf = Buffer.alloc(outputsBufferSize);
+        offset = 0;
+        for (const output of outputs) {
+            switch (output.type) {
+                case 'pkh': {
+                    buf.writeUIntLE(output.amount, offset, 6); // 6 is the max
+                    offset += 8;
+                    const pkhscript = addressToScript(output.address);
+                    pkhscript.copy(buf, offset);
+                    offset += 26;
+                    break;
+                }
+                case 'op_return': {
+                    offset += 8;
+                    const oprscript = memoToScript(output.memo);
+                    oprscript.copy(buf, offset);
+                    offset += oprscript.length;
+                    break;
+                }
+            }
+        }
+        const outputsHash = Buffer.from(blake2bWithPersonal(buf.subarray(0, offset), 'ZTxIdOutputsHash')).toString('hex');
+        buf = Buffer.alloc(8 * utxos.length);
+        for (const [i, utxo] of utxos.entries()) {
+            buf.writeUIntLE(utxo.satoshis, 8 * i, 6);
+        }
+        const amountsHash = Buffer.from(blake2bWithPersonal(buf, 'ZTxTrAmountsHash')).toString('hex');
+        buf = Buffer.alloc(26 * utxos.length);
+        for (const [i, utxo] of utxos.entries()) {
+            const script = addressToScript(utxo.address);
+            script.copy(buf, 26 * i);
+        }
+        const scriptsHash = Buffer.from(blake2bWithPersonal(buf, 'ZTxTrScriptsHash')).toString('hex');
+        const signatures = [];
+        for (const utxo of utxos) {
+            buf = Buffer.alloc(32 + 4 + 8 + 26 + 4);
+            offset = 0;
+            const txid = Buffer.from(utxo.txid, 'hex');
+            txid.reverse();
+            txid.copy(buf, offset);
+            offset += 32;
+            buf.writeUInt32LE(utxo.outputIndex, offset);
+            offset += 4;
+            buf.writeUIntLE(utxo.satoshis, offset, 6);
+            offset += 8;
+            const script = addressToScript(utxo.address);
+            script.copy(buf, offset);
+            offset += 26;
+            buf.writeInt32LE(-1, offset);
+            const txInHash = Buffer.from(blake2bWithPersonal(buf, 'Zcash___TxInHash')).toString('hex');
+            buf = Buffer.alloc(1 + 32 * 6);
+            offset = 1;
+            buf[0] = 1;
+            Buffer.from(prevoutputsHash, 'hex').copy(buf, offset);
+            offset += 32;
+            Buffer.from(amountsHash, 'hex').copy(buf, offset);
+            offset += 32;
+            Buffer.from(scriptsHash, 'hex').copy(buf, offset);
+            offset += 32;
+            Buffer.from(sequencesHash, 'hex').copy(buf, offset);
+            offset += 32;
+            Buffer.from(outputsHash, 'hex').copy(buf, offset);
+            offset += 32;
+            Buffer.from(txInHash, 'hex').copy(buf, offset);
+            offset += 32;
+            const transparentHash = Buffer.from(blake2bWithPersonal(buf, 'ZTxIdTranspaHash')).toString('hex');
+            buf = Buffer.alloc(32 * 4);
+            offset = 0;
+            Buffer.from(headerHash, 'hex').copy(buf, offset);
+            offset += 32;
+            Buffer.from(transparentHash, 'hex').copy(buf, offset);
+            offset += 32;
+            Buffer.from('6f2fc8f98feafd94e74a0df4bed74391ee0b5a69945e4ced8ca8a095206f00ae', 'hex').copy(buf, offset);
+            offset += 32;
+            Buffer.from('9fbe4ed13b0c08e671c11a3407d84e1117cd45028a2eee1b9feae78b48a6e2c1', 'hex').copy(buf, offset);
+            offset += 32;
+            // Create personalization with NU6.1 branch ID
+            const personal = Buffer.alloc(16);
+            Buffer.from('ZcashTxHash_').copy(personal);
+            personal.writeUInt32LE(NU6_1_CONSENSUS_BRANCH_ID, 12); // NU6.1 consensus branch ID (FIXED!)
+            const sigHash = blake2bWithPersonal(buf, personal);
+            const signature = secp256k1.sign(sigHash, sk, { lowS: true, prehash: false });
+            const signatureDER = signature.toDERRawBytes();
+            signatures.push(signatureDER);
+        }
+        // Build final transaction - calculate required buffer size dynamically
+        // Header: 20 bytes (version + versionGroupId + consensusBranchId + lockTime + expiryHeight)
+        // Per input: 32 (txid) + 4 (vout) + ~1 (compactInt) + ~110 (sigScript: 5 + ~72 sig + 33 pubkey) + 4 (sequence) = ~151 bytes
+        // Per output: 8 (amount) + ~26-80 (script) = ~34-88 bytes
+        // Trailing: 3 bytes (empty sapling/orchard bundles)
+        const maxSigScriptSize = 5 + 73 + 33; // overhead + max DER sig + compressed pubkey
+        const perInputSize = 32 + 4 + 3 + maxSigScriptSize + 4; // txid + vout + compactInt + sigScript + sequence
+        const perOutputSize = 8 + 80; // amount + max script size (memo can be up to 80 chars)
+        const headerSize = 20;
+        const trailingSize = 3;
+        const compactIntSize = 3; // max for reasonable counts
+        const txBufferSize = headerSize +
+            compactIntSize +
+            utxos.length * perInputSize +
+            compactIntSize +
+            outputs.length * perOutputSize +
+            trailingSize;
+        buf = Buffer.alloc(txBufferSize);
+        offset = 0;
+        buf.writeUInt32LE(TX_VERSION, offset); // Transaction version
+        offset += 4;
+        buf.writeUInt32LE(TX_VERSION_GROUP_ID, offset); // Version group ID
+        offset += 4;
+        buf.writeUInt32LE(NU6_1_CONSENSUS_BRANCH_ID, offset); // NU6.1 consensus branch ID (FIXED!)
+        offset += 4;
+        buf.writeUInt32LE(0x00000000, offset); // Lock time
+        offset += 4;
+        buf.writeUInt32LE(height, offset); // Expiry height
+        offset += 4;
+        const txinc = writeCompactInt(utxos.length);
+        txinc.copy(buf, offset);
+        offset += txinc.length;
+        for (const [i, utxo] of utxos.entries()) {
+            const txid = Buffer.from(utxo.txid, 'hex');
+            txid.reverse();
+            txid.copy(buf, offset);
+            offset += 32;
+            buf.writeUInt32LE(utxo.outputIndex, offset);
+            offset += 4;
+            const ss = writeSigScript(signatures[i], pk);
+            const ssl = writeCompactInt(ss.length);
+            ssl.copy(buf, offset);
+            offset += ssl.length;
+            ss.copy(buf, offset);
+            offset += ss.length;
+            buf.writeInt32LE(-1, offset);
+            offset += 4;
+        }
+        const txoutc = writeCompactInt(outputs.length);
+        txoutc.copy(buf, offset);
+        offset += txoutc.length;
+        for (const out of outputs) {
+            switch (out.type) {
+                case 'pkh': {
+                    buf.writeBigInt64LE(BigInt(out.amount), offset);
+                    offset += 8;
+                    const pkhscript = addressToScript(out.address);
+                    pkhscript.copy(buf, offset);
+                    offset += pkhscript.length;
+                    break;
+                }
+                case 'op_return': {
+                    offset += 8;
+                    const memoscript = memoToScript(out.memo);
+                    memoscript.copy(buf, offset);
+                    offset += memoscript.length;
+                    break;
+                }
+            }
+        }
+        // Add 000000 (empty sapling/orchard bundles)
+        offset += 3;
+        return buf.subarray(0, offset);
+    });
+}
+
+export { addressToScript, buildTx, getFee, getUTXOS, isValidAddr, mainnetPrefix, memoToScript, pkToAddr, sendRawTransaction, signAndFinalize, skToAddr, testnetPrefix, waitForTransaction, writeSigScript };
+//# sourceMappingURL=index.esm.js.map