xpi-ts 0.2.0

package/dist/lib/bitcore/transaction/output.d.ts

@@ -0,0 +1,48 @@
+import { BufferWriter } from '../encoding/bufferwriter.js';
+import { BufferReader } from '../encoding/bufferreader.js';
+import { Script } from '../script.js';
+import { BN } from '../crypto/bn.js';
+export interface OutputData {
+    satoshis?: number | bigint | BN | string;
+    script?: Script | Buffer | string;
+    scriptBuffer?: Buffer;
+}
+export interface OutputObject {
+    satoshis: number;
+    script: string;
+    asm: string;
+}
+export declare class Output {
+    satoshis: number;
+    private _satoshisBN;
+    private _scriptBuffer;
+    private _script?;
+    constructor(args: OutputData);
+    static create(args: OutputData): Output;
+    private _parseSatoshis;
+    get satoshisBN(): BN;
+    set satoshisBN(value: BN);
+    get script(): Script;
+    get scriptBuffer(): Buffer;
+    setScriptFromBuffer(buffer: Buffer): void;
+    setScript(script: Script | Buffer | string): Output;
+    getXPI(): number;
+    setXPI(xpi: number): Output;
+    isValid(): boolean;
+    isDust(dustThreshold?: number): boolean;
+    invalidSatoshis(): string | false;
+    isOpReturn(): boolean;
+    toObject(): OutputObject;
+    toJSON: () => OutputObject;
+    inspect(): string;
+    static fromBufferReader(br: BufferReader): Output;
+    toBuffer(): Buffer;
+    toBufferWriter(writer?: BufferWriter): BufferWriter;
+    getSize(): number;
+    clone(): Output;
+    static fromObject(data: OutputData): Output;
+    isPayToPublicKeyHash(): boolean;
+    isPayToScriptHash(): boolean;
+    getAddress(): string | null;
+}
+//# sourceMappingURL=output.d.ts.map

package/dist/lib/bitcore/transaction/output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output.d.ts","sourceRoot":"","sources":["../../../../lib/bitcore/transaction/output.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAA;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAA;AAG1D,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AACrC,OAAO,EAAE,EAAE,EAAE,MAAM,iBAAiB,CAAA;AAIpC,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,EAAE,GAAG,MAAM,CAAA;IACxC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAA;IACjC,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,GAAG,EAAE,MAAM,CAAA;CACZ;AAKD,qBAAa,MAAM;IAEjB,QAAQ,EAAG,MAAM,CAAA;IACjB,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,OAAO,CAAC,CAAQ;gBAEZ,IAAI,EAAE,UAAU;IA0B5B,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM;IAOvC,OAAO,CAAC,cAAc;IAiCtB,IAAI,UAAU,IAAI,EAAE,CAEnB;IAKD,IAAI,UAAU,CAAC,KAAK,EAAE,EAAE,EAOvB;IAKD,IAAI,MAAM,IAAI,MAAM,CAOnB;IAKD,IAAI,YAAY,IAAI,MAAM,CAEzB;IAKD,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAiBzC,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM;IAoBnD,MAAM,IAAI,MAAM;IAOhB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAS3B,OAAO,IAAI,OAAO;IAWlB,MAAM,CAAC,aAAa,GAAE,MAAY,GAAG,OAAO;IAO5C,eAAe,IAAI,MAAM,GAAG,KAAK;IAgBjC,UAAU,IAAI,OAAO;IAerB,QAAQ,IAAI,YAAY;IAWxB,MAAM,QAXM,YAAY,CAWF;IAKtB,OAAO,IAAI,MAAM;IAajB,MAAM,CAAC,gBAAgB,CAAC,EAAE,EAAE,YAAY,GAAG,MAAM;IAejD,QAAQ,IAAI,MAAM;IAWlB,cAAc,CAAC,MAAM,CAAC,EAAE,YAAY,GAAG,YAAY;IAcnD,OAAO,IAAI,MAAM;IAWjB,KAAK,IAAI,MAAM;IAUf,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM;IAO3C,oBAAoB,IAAI,OAAO;IAO/B,iBAAiB,IAAI,OAAO;IAO5B,UAAU,IAAI,MAAM,GAAG,IAAI;CAQ5B"}

package/dist/lib/bitcore/transaction/output.js

@@ -0,0 +1,231 @@
+import { Preconditions } from '../util/preconditions.js';
+import { BitcoreError } from '../errors.js';
+import { BufferWriter } from '../encoding/bufferwriter.js';
+import { JSUtil } from '../util/js.js';
+import { Script } from '../script.js';
+import { BN } from '../crypto/bn.js';
+const MAX_SAFE_INTEGER = 0x1fffffffffffff;
+export class Output {
+    satoshis;
+    _satoshisBN;
+    _scriptBuffer;
+    _script;
+    constructor(args) {
+        if (typeof args === 'object' && args !== null) {
+            if (args.satoshis !== undefined) {
+                this.satoshis = this._parseSatoshis(args.satoshis);
+            }
+            else {
+                this.satoshis = 0;
+                this._satoshisBN = new BN(0);
+            }
+            if (Buffer.isBuffer(args.script)) {
+                this._scriptBuffer = args.script;
+            }
+            else if (args.scriptBuffer !== undefined) {
+                this._scriptBuffer = args.scriptBuffer;
+            }
+            else if (args.script !== undefined) {
+                this.setScript(args.script);
+            }
+            else {
+                this._scriptBuffer = Buffer.alloc(0);
+            }
+        }
+        else {
+            throw new TypeError('Unrecognized argument for Output');
+        }
+    }
+    static create(args) {
+        return new Output(args);
+    }
+    _parseSatoshis(value) {
+        if (value instanceof BN) {
+            this._satoshisBN = value;
+            return value.toNumber();
+        }
+        else if (typeof value === 'string') {
+            const num = parseInt(value);
+            Preconditions.checkArgument(JSUtil.isNaturalNumber(num), 'Output satoshis is not a natural number');
+            this._satoshisBN = new BN(num);
+            return num;
+        }
+        else if (typeof value === 'bigint') {
+            const num = Number(value);
+            Preconditions.checkArgument(JSUtil.isNaturalNumber(num), 'Output satoshis is not a natural number');
+            this._satoshisBN = new BN(num);
+            return num;
+        }
+        else {
+            Preconditions.checkArgument(JSUtil.isNaturalNumber(value), 'Output satoshis is not a natural number');
+            this._satoshisBN = new BN(value);
+            return value;
+        }
+    }
+    get satoshisBN() {
+        return this._satoshisBN;
+    }
+    set satoshisBN(value) {
+        this._satoshisBN = value;
+        this.satoshis = value.toNumber();
+        Preconditions.checkState(JSUtil.isNaturalNumber(this.satoshis), 'Output satoshis is not a natural number');
+    }
+    get script() {
+        if (this._script) {
+            return this._script;
+        }
+        else {
+            this.setScriptFromBuffer(this._scriptBuffer);
+            return this._script;
+        }
+    }
+    get scriptBuffer() {
+        return this._scriptBuffer;
+    }
+    setScriptFromBuffer(buffer) {
+        this._scriptBuffer = buffer;
+        try {
+            this._script = Script.fromBuffer(this._scriptBuffer);
+            this._script._isOutput = true;
+        }
+        catch (e) {
+            if (e instanceof BitcoreError.Script.InvalidBuffer) {
+                this._script = undefined;
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    setScript(script) {
+        if (script instanceof Script) {
+            this._scriptBuffer = script.toBuffer();
+            this._script = script;
+            this._script._isOutput = true;
+        }
+        else if (typeof script === 'string') {
+            this._script = Script.fromString(script);
+            this._scriptBuffer = this._script.toBuffer();
+            this._script._isOutput = true;
+        }
+        else if (Buffer.isBuffer(script)) {
+            this.setScriptFromBuffer(script);
+        }
+        else {
+            throw new TypeError('Invalid argument type: script');
+        }
+        return this;
+    }
+    getXPI() {
+        return this.satoshis / 1000000;
+    }
+    setXPI(xpi) {
+        this.satoshis = Math.round(xpi * 1000000);
+        this._satoshisBN = new BN(this.satoshis);
+        return this;
+    }
+    isValid() {
+        return (this.satoshis >= 0 &&
+            this.satoshis <= 21000000 * 1000000 &&
+            this._scriptBuffer.length > 0);
+    }
+    isDust(dustThreshold = 546) {
+        return this.satoshis < dustThreshold;
+    }
+    invalidSatoshis() {
+        if (this.satoshis > MAX_SAFE_INTEGER) {
+            return 'transaction txout satoshis greater than max safe integer';
+        }
+        if (this.satoshis !== this._satoshisBN.toNumber()) {
+            return 'transaction txout satoshis has corrupted value';
+        }
+        if (this.satoshis < 0) {
+            return 'transaction txout negative';
+        }
+        return false;
+    }
+    isOpReturn() {
+        if (!this._script) {
+            this.setScriptFromBuffer(this._scriptBuffer);
+        }
+        return !!(this._script &&
+            this._script.chunks.length > 0 &&
+            this._script.chunks[0].opcodenum === 0x6a);
+    }
+    toObject() {
+        return {
+            satoshis: this.satoshis,
+            script: this._scriptBuffer.toString('hex'),
+            asm: this.script.toASM(),
+        };
+    }
+    toJSON = this.toObject;
+    inspect() {
+        let scriptStr;
+        if (this.script) {
+            scriptStr = this.script.inspect();
+        }
+        else {
+            scriptStr = this._scriptBuffer.toString('hex');
+        }
+        return '<Output (' + this.satoshis + ' sats) ' + scriptStr + '>';
+    }
+    static fromBufferReader(br) {
+        const obj = {};
+        obj.satoshis = br.readUInt64LEBN();
+        const size = br.readVarintNum();
+        if (size !== 0) {
+            obj.script = br.read(size);
+        }
+        else {
+            obj.script = Buffer.from([]);
+        }
+        return new Output(obj);
+    }
+    toBuffer() {
+        const bw = new BufferWriter();
+        bw.writeUInt64LEBN(this._satoshisBN);
+        bw.writeVarintNum(this._scriptBuffer.length);
+        bw.write(this._scriptBuffer);
+        return bw.concat();
+    }
+    toBufferWriter(writer) {
+        if (!writer) {
+            writer = new BufferWriter();
+        }
+        writer.writeUInt64LEBN(this._satoshisBN);
+        const script = this._scriptBuffer;
+        writer.writeVarintNum(script.length);
+        writer.write(script);
+        return writer;
+    }
+    getSize() {
+        return (8 +
+            BufferWriter.varintBufNum(this._scriptBuffer.length).length +
+            this._scriptBuffer.length);
+    }
+    clone() {
+        return new Output({
+            satoshis: this.satoshis,
+            script: this.script.clone(),
+        });
+    }
+    static fromObject(data) {
+        return new Output(data);
+    }
+    isPayToPublicKeyHash() {
+        return this.script.isPayToPublicKeyHash();
+    }
+    isPayToScriptHash() {
+        return this.script.isPayToScriptHash();
+    }
+    getAddress() {
+        try {
+            const addressInfo = this.script.getAddressInfo();
+            return addressInfo ? addressInfo.toString() : null;
+        }
+        catch (e) {
+            return null;
+        }
+    }
+}

package/dist/lib/bitcore/transaction/sighash.d.ts

@@ -0,0 +1,32 @@
+import { Signature } from '../crypto/signature.js';
+import { Script } from '../script.js';
+import { Output } from './output.js';
+import { BufferWriter } from '../encoding/bufferwriter.js';
+import { BN } from '../crypto/bn.js';
+import { PrivateKey } from '../privatekey.js';
+import { PublicKey } from '../publickey.js';
+export interface TransactionLike {
+    inputs: Array<{
+        prevTxId: Buffer;
+        outputIndex: number;
+        sequenceNumber: number;
+        script?: Script | null;
+    }>;
+    outputs: Array<{
+        satoshis: number;
+        script?: Script;
+        toBufferWriter(writer: BufferWriter): void;
+    }>;
+    spentOutputs?: Output[];
+    toBuffer(): Buffer;
+    version?: number;
+    nLockTime?: number;
+}
+declare function sighash(transaction: TransactionLike, sighashType: number, inputNumber: number, subscript: Script, satoshisBN?: BN, flags?: number): Buffer;
+declare function sign(transaction: TransactionLike, privateKey: PrivateKey, sighashType: number, inputIndex: number, subscript: Script, satoshisBN?: BN, flags?: number, signingMethod?: 'ecdsa' | 'schnorr'): Signature;
+declare function verify(transaction: TransactionLike, signature: Signature, publicKey: PublicKey, inputIndex: number, subscript: Script, satoshisBN?: BN, flags?: number, signingMethod?: 'ecdsa' | 'schnorr'): boolean;
+export declare const DEFAULT_SIGN_FLAGS: number;
+export declare const SIGHASH_SINGLE_BUG = "0000000000000000000000000000000000000000000000000000000000000001";
+export declare const BITS_64_ON = "ffffffffffffffff";
+export { sighash, sign, verify };
+//# sourceMappingURL=sighash.d.ts.map

package/dist/lib/bitcore/transaction/sighash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sighash.d.ts","sourceRoot":"","sources":["../../../../lib/bitcore/transaction/sighash.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;AAClD,OAAO,EAAE,MAAM,EAAS,MAAM,cAAc,CAAA;AAC5C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAGpC,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAA;AAC1D,OAAO,EAAE,EAAE,EAAE,MAAM,iBAAiB,CAAA;AAOpC,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAI3C,MAAM,WAAW,eAAe;IAE9B,MAAM,EAAE,KAAK,CAAC;QACZ,QAAQ,EAAE,MAAM,CAAA;QAChB,WAAW,EAAE,MAAM,CAAA;QACnB,cAAc,EAAE,MAAM,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KACvB,CAAC,CAAA;IACF,OAAO,EAAE,KAAK,CAAC;QACb,QAAQ,EAAE,MAAM,CAAA;QAChB,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,cAAc,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,CAAA;KAC3C,CAAC,CAAA;IACF,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;IACvB,QAAQ,IAAI,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAsZD,iBAAS,OAAO,CACd,WAAW,EAAE,eAAe,EAC5B,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,UAAU,CAAC,EAAE,EAAE,EACf,KAAK,CAAC,EAAE,MAAM,GACb,MAAM,CA6HR;AAwBD,iBAAS,IAAI,CACX,WAAW,EAAE,eAAe,EAC5B,UAAU,EAAE,UAAU,EACtB,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,UAAU,CAAC,EAAE,EAAE,EACf,KAAK,CAAC,EAAE,MAAM,EACd,aAAa,CAAC,EAAE,OAAO,GAAG,SAAS,GAClC,SAAS,CAwBX;AAoBD,iBAAS,MAAM,CACb,WAAW,EAAE,eAAe,EAC5B,SAAS,EAAE,SAAS,EACpB,SAAS,EAAE,SAAS,EACpB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,UAAU,CAAC,EAAE,EAAE,EACf,KAAK,CAAC,EAAE,MAAM,EACd,aAAa,CAAC,EAAE,OAAO,GAAG,SAAS,GAClC,OAAO,CA8BT;AA4DD,eAAO,MAAM,kBAAkB,QAA2B,CAAA;AAK1D,eAAO,MAAM,kBAAkB,qEAA2B,CAAA;AAC1D,eAAO,MAAM,UAAU,qBAAmB,CAAA;AAK1C,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAA"}

package/dist/lib/bitcore/transaction/sighash.js

@@ -0,0 +1,335 @@
+import { Signature } from '../crypto/signature.js';
+import { Script, empty } from '../script.js';
+import { Output } from './output.js';
+import { BufferReader } from '../encoding/bufferreader.js';
+import { BufferWriter } from '../encoding/bufferwriter.js';
+import { BN } from '../crypto/bn.js';
+import { Hash } from '../crypto/hash.js';
+import { ECDSA } from '../crypto/ecdsa.js';
+import { Schnorr } from '../crypto/schnorr.js';
+import { Preconditions } from '../util/preconditions.js';
+import { BufferUtil } from '../util/buffer.js';
+import { Interpreter } from '../script/interpreter.js';
+import { Transaction } from './transaction.js';
+import { Input } from './input.js';
+const SIGHASH_SINGLE_BUG_CONST = '0000000000000000000000000000000000000000000000000000000000000001';
+const BITS_64_ON_CONST = 'ffffffffffffffff';
+const NULL_HASH = Buffer.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex');
+const SIGHASH_ALGORITHM_MASK = 0x60;
+const DEFAULT_SIGN_FLAGS_CONST = 1 << 16;
+function GetForkId() {
+    return 0;
+}
+function getMerkleRoot(hashes) {
+    if (hashes.length === 0) {
+        return { root: NULL_HASH, height: 0 };
+    }
+    let currentHashes = [...hashes];
+    let height = 1;
+    while (currentHashes.length > 1) {
+        height++;
+        const newHashes = [];
+        for (let i = 0; i < currentHashes.length; i += 2) {
+            const left = currentHashes[i];
+            const right = i + 1 < currentHashes.length ? currentHashes[i + 1] : NULL_HASH;
+            const combined = Buffer.concat([left, right]);
+            const pairHash = Hash.sha256sha256(combined);
+            newHashes.push(pairHash);
+        }
+        currentHashes = newHashes;
+    }
+    return { root: currentHashes[0], height };
+}
+function sighashForLotus(transaction, sighashType, inputNumber, spentOutputs, executedScriptHash, codeseparatorPos = 0xffffffff) {
+    Preconditions.checkArgument(spentOutputs.length === transaction.inputs.length, 'Must provide spent output for each input');
+    Preconditions.checkArgument(inputNumber < transaction.inputs.length, 'Input index out of range');
+    const baseType = sighashType & 0x03;
+    const unusedBits = sighashType & 0x1c;
+    if (baseType === 0 || unusedBits !== 0) {
+        throw new Error('Invalid sighash type for SIGHASH_LOTUS');
+    }
+    const input = transaction.inputs[inputNumber];
+    const writer = new BufferWriter();
+    writer.writeUInt32LE(sighashType >>> 0);
+    const spendType = executedScriptHash ? 2 : 0;
+    const inputHashWriter = new BufferWriter();
+    inputHashWriter.writeUInt8(spendType);
+    inputHashWriter.writeReverse(input.prevTxId);
+    inputHashWriter.writeUInt32LE(input.outputIndex);
+    inputHashWriter.writeUInt32LE(input.sequenceNumber);
+    const spentOutput = spentOutputs[inputNumber];
+    inputHashWriter.writeUInt64LEBN(new BN(spentOutput.satoshis));
+    inputHashWriter.writeVarLengthBuffer(spentOutput.scriptBuffer);
+    const inputHash = Hash.sha256sha256(inputHashWriter.toBuffer());
+    writer.write(inputHash);
+    if (executedScriptHash) {
+        Preconditions.checkArgument(executedScriptHash.length === 32, 'executed_script_hash must be 32 bytes');
+        writer.writeUInt32LE(codeseparatorPos);
+        writer.write(executedScriptHash);
+    }
+    if (!(sighashType & Signature.SIGHASH_ANYONECANPAY)) {
+        writer.writeUInt32LE(inputNumber);
+        const spentOutputHashes = spentOutputs.map(output => {
+            const w = new BufferWriter();
+            w.writeUInt64LEBN(new BN(output.satoshis));
+            w.writeVarLengthBuffer(output.scriptBuffer);
+            return Hash.sha256sha256(w.toBuffer());
+        });
+        const spentOutputsMerkle = getMerkleRoot(spentOutputHashes);
+        writer.write(spentOutputsMerkle.root);
+        const totalInputAmount = spentOutputs.reduce((sum, output) => sum + output.satoshis, 0);
+        writer.writeUInt64LEBN(new BN(totalInputAmount));
+    }
+    if (baseType === Signature.SIGHASH_ALL) {
+        const totalOutputAmount = transaction.outputs.reduce((sum, output) => sum + output.satoshis, 0);
+        writer.writeUInt64LEBN(new BN(totalOutputAmount));
+    }
+    writer.writeUInt32LE(transaction.version || 2);
+    if (!(sighashType & Signature.SIGHASH_ANYONECANPAY)) {
+        const inputHashes = transaction.inputs.map(inp => {
+            const w = new BufferWriter();
+            w.writeReverse(inp.prevTxId);
+            w.writeUInt32LE(inp.outputIndex);
+            w.writeUInt32LE(inp.sequenceNumber);
+            return Hash.sha256sha256(w.toBuffer());
+        });
+        const inputsMerkle = getMerkleRoot(inputHashes);
+        writer.write(inputsMerkle.root);
+        writer.writeUInt8(inputsMerkle.height);
+    }
+    if (baseType === Signature.SIGHASH_SINGLE) {
+        if (inputNumber >= transaction.outputs.length) {
+            throw new Error('SIGHASH_SINGLE: no corresponding output for input');
+        }
+        const w = new BufferWriter();
+        transaction.outputs[inputNumber].toBufferWriter(w);
+        const outputHash = Hash.sha256sha256(w.toBuffer());
+        writer.write(outputHash);
+    }
+    if (baseType === Signature.SIGHASH_ALL) {
+        const outputHashes = transaction.outputs.map(output => {
+            const w = new BufferWriter();
+            output.toBufferWriter(w);
+            return Hash.sha256sha256(w.toBuffer());
+        });
+        const outputsMerkle = getMerkleRoot(outputHashes);
+        writer.write(outputsMerkle.root);
+        writer.writeUInt8(outputsMerkle.height);
+    }
+    writer.writeUInt32LE(transaction.nLockTime || 0);
+    return Hash.sha256sha256(writer.toBuffer());
+}
+function sighashForForkId(transaction, sighashType, inputNumber, subscript, satoshisBN) {
+    const input = transaction.inputs[inputNumber];
+    Preconditions.checkArgument(satoshisBN instanceof BN, 'For ForkId=0 signatures, satoshis or complete input must be provided');
+    let hashPrevouts = BufferUtil.emptyBuffer(32);
+    let hashSequence = BufferUtil.emptyBuffer(32);
+    let hashOutputs = BufferUtil.emptyBuffer(32);
+    if (!(sighashType & Signature.SIGHASH_ANYONECANPAY)) {
+        hashPrevouts = GetPrevoutHash(transaction);
+    }
+    if (!(sighashType & Signature.SIGHASH_ANYONECANPAY) &&
+        (sighashType & 31) !== Signature.SIGHASH_SINGLE &&
+        (sighashType & 31) !== Signature.SIGHASH_NONE) {
+        hashSequence = GetSequenceHash(transaction);
+    }
+    if ((sighashType & 31) !== Signature.SIGHASH_SINGLE &&
+        (sighashType & 31) !== Signature.SIGHASH_NONE) {
+        hashOutputs = GetOutputsHash(transaction);
+    }
+    else if ((sighashType & 31) === Signature.SIGHASH_SINGLE &&
+        inputNumber < transaction.outputs.length) {
+        hashOutputs = GetOutputsHash(transaction, inputNumber);
+    }
+    const writer = new BufferWriter();
+    writer.writeUInt32LE(transaction.version || 2);
+    writer.write(hashPrevouts);
+    writer.write(hashSequence);
+    writer.writeReverse(input.prevTxId);
+    writer.writeUInt32LE(input.outputIndex);
+    writer.writeVarintNum(subscript.toBuffer().length);
+    writer.write(subscript.toBuffer());
+    writer.writeUInt64LEBN(satoshisBN);
+    writer.writeUInt32LENumber(input.sequenceNumber);
+    writer.write(hashOutputs);
+    writer.writeUInt32LE(transaction.nLockTime || 0);
+    writer.writeUInt32LE(sighashType >>> 0);
+    const buf = writer.toBuffer();
+    const hash = Hash.sha256sha256(buf);
+    return new BufferReader(hash).read(32);
+}
+function sighashLegacy(transaction, sighashType, inputNumber, subscript) {
+    const input = transaction.inputs[inputNumber];
+    function getHash(w) {
+        const buf = w.toBuffer();
+        return Hash.sha256sha256(buf);
+    }
+    const writer = new BufferWriter();
+    writer.writeUInt32LE(2);
+    writer.writeVarintNum(transaction.inputs.length);
+    for (let i = 0; i < transaction.inputs.length; i++) {
+        const txInput = transaction.inputs[i];
+        writer.writeReverse(txInput.prevTxId);
+        writer.writeUInt32LE(txInput.outputIndex);
+        if (i === inputNumber) {
+            writer.writeVarLengthBuffer(subscript.toBuffer());
+        }
+        else {
+            writer.writeVarintNum(0);
+        }
+        writer.writeUInt32LENumber(txInput.sequenceNumber);
+    }
+    writer.writeVarintNum(transaction.outputs.length);
+    if ((sighashType & 31) !== Signature.SIGHASH_SINGLE &&
+        (sighashType & 31) !== Signature.SIGHASH_NONE) {
+        for (const output of transaction.outputs) {
+            output.toBufferWriter(writer);
+        }
+    }
+    else if ((sighashType & 31) === Signature.SIGHASH_SINGLE &&
+        inputNumber < transaction.outputs.length) {
+        transaction.outputs[inputNumber].toBufferWriter(writer);
+    }
+    writer.writeUInt32LE(transaction.nLockTime || 0);
+    writer.writeUInt32LE(sighashType);
+    return getHash(writer);
+}
+function sighash(transaction, sighashType, inputNumber, subscript, satoshisBN, flags) {
+    if (flags === undefined) {
+        flags = DEFAULT_SIGN_FLAGS_CONST;
+    }
+    const txcopy = Transaction.shallowCopy(transaction);
+    subscript = new Script(subscript);
+    if (flags & Interpreter.SCRIPT_ENABLE_REPLAY_PROTECTION) {
+        const forkValue = sighashType >> 8;
+        const newForkValue = 0xff0000 | (forkValue ^ 0xdead);
+        sighashType = (newForkValue << 8) | (sighashType & 0xff);
+    }
+    const algorithmBits = sighashType & SIGHASH_ALGORITHM_MASK;
+    if (algorithmBits === Signature.SIGHASH_LOTUS &&
+        flags & Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID) {
+        const spentOutputs = transaction.spentOutputs;
+        if (!spentOutputs || spentOutputs.length !== transaction.inputs.length) {
+            throw new Error('SIGHASH_LOTUS requires spent outputs for all inputs (ensure all inputs have output information)');
+        }
+        return sighashForLotus(txcopy, sighashType, inputNumber, spentOutputs);
+    }
+    if (algorithmBits === Signature.SIGHASH_FORKID &&
+        flags & Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID) {
+        return sighashForForkId(txcopy, sighashType, inputNumber, subscript, satoshisBN);
+    }
+    subscript.removeCodeseparators();
+    for (let i = 0; i < txcopy.inputs.length; i++) {
+        txcopy.inputs[i] = new Input({
+            prevTxId: txcopy.inputs[i].prevTxId,
+            outputIndex: txcopy.inputs[i].outputIndex,
+            sequenceNumber: txcopy.inputs[i].sequenceNumber,
+            script: empty(),
+        });
+    }
+    txcopy.inputs[inputNumber] = new Input({
+        prevTxId: txcopy.inputs[inputNumber].prevTxId,
+        outputIndex: txcopy.inputs[inputNumber].outputIndex,
+        sequenceNumber: txcopy.inputs[inputNumber].sequenceNumber,
+        script: subscript,
+    });
+    if ((sighashType & 31) === Signature.SIGHASH_NONE ||
+        (sighashType & 31) === Signature.SIGHASH_SINGLE) {
+        for (let i = 0; i < txcopy.inputs.length; i++) {
+            if (i !== inputNumber) {
+                txcopy.inputs[i].sequenceNumber = 0;
+            }
+        }
+    }
+    if ((sighashType & 31) === Signature.SIGHASH_NONE) {
+        txcopy.outputs = [];
+    }
+    else if ((sighashType & 31) === Signature.SIGHASH_SINGLE) {
+        if (inputNumber >= txcopy.outputs.length) {
+            return Buffer.from(SIGHASH_SINGLE_BUG_CONST, 'hex');
+        }
+        txcopy.outputs.length = inputNumber + 1;
+        for (let i = 0; i < inputNumber; i++) {
+            txcopy.outputs[i] = new Output({
+                satoshis: BN.fromBuffer(Buffer.from(BITS_64_ON_CONST, 'hex')),
+                script: empty(),
+            });
+        }
+    }
+    if (sighashType & Signature.SIGHASH_ANYONECANPAY) {
+        txcopy.inputs = [txcopy.inputs[inputNumber]];
+    }
+    const buf = new BufferWriter()
+        .write(txcopy.toBuffer())
+        .writeInt32LE(sighashType >>> 0)
+        .toBuffer();
+    const hash = Hash.sha256sha256(buf);
+    return new BufferReader(hash).readReverse(32);
+}
+function sign(transaction, privateKey, sighashType, inputIndex, subscript, satoshisBN, flags, signingMethod) {
+    const hashbuf = sighash(transaction, sighashType, inputIndex, subscript, satoshisBN, flags);
+    signingMethod = signingMethod || 'ecdsa';
+    let sig;
+    if (signingMethod === 'schnorr') {
+        sig = Schnorr.sign(hashbuf, privateKey, 'big');
+        sig.nhashtype = sighashType;
+        return sig;
+    }
+    else if (signingMethod === 'ecdsa') {
+        sig = ECDSA.sign(hashbuf, privateKey, 'big');
+        sig.nhashtype = sighashType;
+        return sig;
+    }
+    else {
+        throw new Error('Invalid signing method. Must be "ecdsa" or "schnorr"');
+    }
+}
+function verify(transaction, signature, publicKey, inputIndex, subscript, satoshisBN, flags, signingMethod) {
+    Preconditions.checkArgument(transaction !== undefined, 'Transaction is required');
+    Preconditions.checkArgument(signature !== undefined && signature.nhashtype !== undefined, 'Signature with nhashtype is required');
+    const hashbuf = sighash(transaction, signature.nhashtype, inputIndex, subscript, satoshisBN, flags);
+    signingMethod = signingMethod || 'ecdsa';
+    if (signingMethod === 'schnorr') {
+        return Schnorr.verify(hashbuf, signature, publicKey, 'big');
+    }
+    else if (signingMethod === 'ecdsa') {
+        return ECDSA.verify(hashbuf, signature, publicKey, 'big');
+    }
+    else {
+        throw new Error('Invalid signing method. Must be "ecdsa" or "schnorr"');
+    }
+}
+function GetPrevoutHash(tx) {
+    const writer = new BufferWriter();
+    for (const input of tx.inputs) {
+        writer.writeReverse(input.prevTxId);
+        writer.writeUInt32LE(input.outputIndex);
+    }
+    const buf = writer.toBuffer();
+    return Hash.sha256sha256(buf);
+}
+function GetSequenceHash(tx) {
+    const writer = new BufferWriter();
+    for (const input of tx.inputs) {
+        writer.writeUInt32LENumber(input.sequenceNumber);
+    }
+    const buf = writer.toBuffer();
+    return Hash.sha256sha256(buf);
+}
+function GetOutputsHash(tx, n) {
+    const writer = new BufferWriter();
+    if (n === undefined) {
+        for (const output of tx.outputs) {
+            output.toBufferWriter(writer);
+        }
+    }
+    else {
+        tx.outputs[n].toBufferWriter(writer);
+    }
+    const buf = writer.toBuffer();
+    return Hash.sha256sha256(buf);
+}
+export const DEFAULT_SIGN_FLAGS = DEFAULT_SIGN_FLAGS_CONST;
+export const SIGHASH_SINGLE_BUG = SIGHASH_SINGLE_BUG_CONST;
+export const BITS_64_ON = BITS_64_ON_CONST;
+export { sighash, sign, verify };