@btc-vision/bitcoin 6.3.1 → 6.3.2

package/build/transaction.js

@@ -0,0 +1,445 @@
+import { BufferReader, BufferWriter, reverseBuffer, varuint } from './bufferutils.js';
+import * as bcrypto from './crypto.js';
+import * as bscript from './script.js';
+import { OPS as opcodes } from './script.js';
+import * as types from './types.js';
+const { typeforce } = types;
+function varSliceSize(someScript) {
+    const length = someScript.length;
+    return varuint.encodingLength(length) + length;
+}
+function vectorSize(someVector) {
+    const length = someVector.length;
+    return (varuint.encodingLength(length) +
+        someVector.reduce((sum, witness) => {
+            return sum + varSliceSize(witness);
+        }, 0));
+}
+const EMPTY_BUFFER = Buffer.allocUnsafe(0);
+const EMPTY_WITNESS = [];
+const ZERO = Buffer.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex');
+const ONE = Buffer.from('0000000000000000000000000000000000000000000000000000000000000001', 'hex');
+const VALUE_UINT64_MAX = Buffer.from('ffffffffffffffff', 'hex');
+const BLANK_OUTPUT = {
+    script: EMPTY_BUFFER,
+    valueBuffer: VALUE_UINT64_MAX,
+};
+function isOutput(out) {
+    return out.value !== undefined;
+}
+export class Transaction {
+    constructor() {
+        this.version = 1;
+        this.locktime = 0;
+        this.ins = [];
+        this.outs = [];
+    }
+    static fromBuffer(buffer, _NO_STRICT) {
+        const bufferReader = new BufferReader(buffer);
+        const tx = new Transaction();
+        tx.version = bufferReader.readInt32();
+        const marker = bufferReader.readUInt8();
+        const flag = bufferReader.readUInt8();
+        let hasWitnesses = false;
+        if (marker === Transaction.ADVANCED_TRANSACTION_MARKER &&
+            flag === Transaction.ADVANCED_TRANSACTION_FLAG) {
+            hasWitnesses = true;
+        }
+        else {
+            bufferReader.offset -= 2;
+        }
+        const vinLen = bufferReader.readVarInt();
+        for (let i = 0; i < vinLen; ++i) {
+            const hash = bufferReader.readSlice(32);
+            const index = bufferReader.readUInt32();
+            const script = bufferReader.readVarSlice();
+            const sequence = bufferReader.readUInt32();
+            tx.ins.push({
+                hash: hash,
+                index: index,
+                script: script,
+                sequence: sequence,
+                witness: EMPTY_WITNESS,
+            });
+        }
+        const voutLen = bufferReader.readVarInt();
+        for (let i = 0; i < voutLen; ++i) {
+            tx.outs.push({
+                value: bufferReader.readUInt64(),
+                script: bufferReader.readVarSlice(),
+            });
+        }
+        if (hasWitnesses) {
+            for (let i = 0; i < vinLen; ++i) {
+                tx.ins[i].witness = bufferReader.readVector();
+            }
+            if (!tx.hasWitnesses())
+                throw new Error('Transaction has superfluous witness data');
+        }
+        tx.locktime = bufferReader.readUInt32();
+        if (_NO_STRICT)
+            return tx;
+        if (bufferReader.offset !== buffer.length)
+            throw new Error('Transaction has unexpected data');
+        return tx;
+    }
+    static fromHex(hex) {
+        return Transaction.fromBuffer(Buffer.from(hex, 'hex'), false);
+    }
+    static isCoinbaseHash(buffer) {
+        typeforce(types.Hash256bit, buffer);
+        for (let i = 0; i < 32; ++i) {
+            if (buffer[i] !== 0)
+                return false;
+        }
+        return true;
+    }
+    isCoinbase() {
+        return this.ins.length === 1 && Transaction.isCoinbaseHash(this.ins[0].hash);
+    }
+    addInput(hash, index, sequence, scriptSig) {
+        typeforce(types.tuple(types.Hash256bit, types.UInt32, types.maybe(types.UInt32), types.maybe(types.Buffer)), arguments);
+        if (types.Null(sequence)) {
+            sequence = Transaction.DEFAULT_SEQUENCE;
+        }
+        return (this.ins.push({
+            hash,
+            index,
+            script: scriptSig || EMPTY_BUFFER,
+            sequence: sequence,
+            witness: EMPTY_WITNESS,
+        }) - 1);
+    }
+    addOutput(scriptPubKey, value) {
+        typeforce(types.tuple(types.Buffer, types.Satoshi), arguments);
+        return (this.outs.push({
+            script: scriptPubKey,
+            value,
+        }) - 1);
+    }
+    hasWitnesses() {
+        return this.ins.some((x) => {
+            return x.witness.length !== 0;
+        });
+    }
+    weight() {
+        const base = this.byteLength(false);
+        const total = this.byteLength(true);
+        return base * 3 + total;
+    }
+    virtualSize() {
+        return Math.ceil(this.weight() / 4);
+    }
+    byteLength(_ALLOW_WITNESS = true) {
+        const hasWitnesses = _ALLOW_WITNESS && this.hasWitnesses();
+        return ((hasWitnesses ? 10 : 8) +
+            varuint.encodingLength(this.ins.length) +
+            varuint.encodingLength(this.outs.length) +
+            this.ins.reduce((sum, input) => {
+                return sum + 40 + varSliceSize(input.script);
+            }, 0) +
+            this.outs.reduce((sum, output) => {
+                return sum + 8 + varSliceSize(output.script);
+            }, 0) +
+            (hasWitnesses
+                ? this.ins.reduce((sum, input) => {
+                    return sum + vectorSize(input.witness);
+                }, 0)
+                : 0));
+    }
+    clone() {
+        const newTx = new Transaction();
+        newTx.version = this.version;
+        newTx.locktime = this.locktime;
+        newTx.ins = this.ins.map((txIn) => {
+            return {
+                hash: txIn.hash,
+                index: txIn.index,
+                script: txIn.script,
+                sequence: txIn.sequence,
+                witness: txIn.witness,
+            };
+        });
+        newTx.outs = this.outs.map((txOut) => {
+            return {
+                script: txOut.script,
+                value: txOut.value,
+            };
+        });
+        return newTx;
+    }
+    hashForSignature(inIndex, prevOutScript, hashType) {
+        typeforce(types.tuple(types.UInt32, types.Buffer, types.Number), arguments);
+        if (inIndex >= this.ins.length)
+            return ONE;
+        const ourScript = bscript.compile(bscript.decompile(prevOutScript).filter((x) => {
+            return x !== opcodes.OP_CODESEPARATOR;
+        }));
+        const txTmp = this.clone();
+        if ((hashType & 0x1f) === Transaction.SIGHASH_NONE) {
+            txTmp.outs = [];
+            txTmp.ins.forEach((input, i) => {
+                if (i === inIndex)
+                    return;
+                input.sequence = 0;
+            });
+        }
+        else if ((hashType & 0x1f) === Transaction.SIGHASH_SINGLE) {
+            if (inIndex >= this.outs.length)
+                return ONE;
+            txTmp.outs.length = inIndex + 1;
+            for (let i = 0; i < inIndex; i++) {
+                txTmp.outs[i] = BLANK_OUTPUT;
+            }
+            txTmp.ins.forEach((input, y) => {
+                if (y === inIndex)
+                    return;
+                input.sequence = 0;
+            });
+        }
+        if (hashType & Transaction.SIGHASH_ANYONECANPAY) {
+            txTmp.ins = [txTmp.ins[inIndex]];
+            txTmp.ins[0].script = ourScript;
+        }
+        else {
+            txTmp.ins.forEach((input) => {
+                input.script = EMPTY_BUFFER;
+            });
+            txTmp.ins[inIndex].script = ourScript;
+        }
+        const buffer = Buffer.allocUnsafe(txTmp.byteLength(false) + 4);
+        buffer.writeInt32LE(hashType, buffer.length - 4);
+        txTmp.__toBuffer(buffer, 0, false);
+        return bcrypto.hash256(buffer);
+    }
+    hashForWitnessV1(inIndex, prevOutScripts, values, hashType, leafHash, annex) {
+        typeforce(types.tuple(types.UInt32, typeforce.arrayOf(types.Buffer), typeforce.arrayOf(types.Satoshi), types.UInt32), arguments);
+        if (values.length !== this.ins.length || prevOutScripts.length !== this.ins.length) {
+            throw new Error('Must supply prevout script and value for all inputs');
+        }
+        const outputType = hashType === Transaction.SIGHASH_DEFAULT
+            ? Transaction.SIGHASH_ALL
+            : hashType & Transaction.SIGHASH_OUTPUT_MASK;
+        const inputType = hashType & Transaction.SIGHASH_INPUT_MASK;
+        const isAnyoneCanPay = inputType === Transaction.SIGHASH_ANYONECANPAY;
+        const isNone = outputType === Transaction.SIGHASH_NONE;
+        const isSingle = outputType === Transaction.SIGHASH_SINGLE;
+        let hashPrevouts = EMPTY_BUFFER;
+        let hashAmounts = EMPTY_BUFFER;
+        let hashScriptPubKeys = EMPTY_BUFFER;
+        let hashSequences = EMPTY_BUFFER;
+        let hashOutputs = EMPTY_BUFFER;
+        if (!isAnyoneCanPay) {
+            let bufferWriter = BufferWriter.withCapacity(36 * this.ins.length);
+            this.ins.forEach((txIn) => {
+                bufferWriter.writeSlice(txIn.hash);
+                bufferWriter.writeUInt32(txIn.index);
+            });
+            hashPrevouts = bcrypto.sha256(bufferWriter.end());
+            bufferWriter = BufferWriter.withCapacity(8 * this.ins.length);
+            values.forEach((value) => bufferWriter.writeUInt64(value));
+            hashAmounts = bcrypto.sha256(bufferWriter.end());
+            bufferWriter = BufferWriter.withCapacity(prevOutScripts.map(varSliceSize).reduce((a, b) => a + b));
+            prevOutScripts.forEach((prevOutScript) => bufferWriter.writeVarSlice(prevOutScript));
+            hashScriptPubKeys = bcrypto.sha256(bufferWriter.end());
+            bufferWriter = BufferWriter.withCapacity(4 * this.ins.length);
+            this.ins.forEach((txIn) => bufferWriter.writeUInt32(txIn.sequence));
+            hashSequences = bcrypto.sha256(bufferWriter.end());
+        }
+        if (!(isNone || isSingle)) {
+            if (!this.outs.length)
+                throw new Error('Add outputs to the transaction before signing.');
+            const txOutsSize = this.outs
+                .map((output) => 8 + varSliceSize(output.script))
+                .reduce((a, b) => a + b);
+            const bufferWriter = BufferWriter.withCapacity(txOutsSize);
+            this.outs.forEach((out) => {
+                bufferWriter.writeUInt64(out.value);
+                bufferWriter.writeVarSlice(out.script);
+            });
+            hashOutputs = bcrypto.sha256(bufferWriter.end());
+        }
+        else if (isSingle && inIndex < this.outs.length) {
+            const output = this.outs[inIndex];
+            const bufferWriter = BufferWriter.withCapacity(8 + varSliceSize(output.script));
+            bufferWriter.writeUInt64(output.value);
+            bufferWriter.writeVarSlice(output.script);
+            hashOutputs = bcrypto.sha256(bufferWriter.end());
+        }
+        const spendType = (leafHash ? 2 : 0) + (annex ? 1 : 0);
+        const sigMsgSize = 174 -
+            (isAnyoneCanPay ? 49 : 0) -
+            (isNone ? 32 : 0) +
+            (annex ? 32 : 0) +
+            (leafHash ? 37 : 0);
+        const sigMsgWriter = BufferWriter.withCapacity(sigMsgSize);
+        sigMsgWriter.writeUInt8(hashType);
+        sigMsgWriter.writeInt32(this.version);
+        sigMsgWriter.writeUInt32(this.locktime);
+        sigMsgWriter.writeSlice(hashPrevouts);
+        sigMsgWriter.writeSlice(hashAmounts);
+        sigMsgWriter.writeSlice(hashScriptPubKeys);
+        sigMsgWriter.writeSlice(hashSequences);
+        if (!(isNone || isSingle)) {
+            sigMsgWriter.writeSlice(hashOutputs);
+        }
+        sigMsgWriter.writeUInt8(spendType);
+        if (isAnyoneCanPay) {
+            const input = this.ins[inIndex];
+            sigMsgWriter.writeSlice(input.hash);
+            sigMsgWriter.writeUInt32(input.index);
+            sigMsgWriter.writeUInt64(values[inIndex]);
+            sigMsgWriter.writeVarSlice(prevOutScripts[inIndex]);
+            sigMsgWriter.writeUInt32(input.sequence);
+        }
+        else {
+            sigMsgWriter.writeUInt32(inIndex);
+        }
+        if (annex) {
+            const bufferWriter = BufferWriter.withCapacity(varSliceSize(annex));
+            bufferWriter.writeVarSlice(annex);
+            sigMsgWriter.writeSlice(bcrypto.sha256(bufferWriter.end()));
+        }
+        if (isSingle) {
+            sigMsgWriter.writeSlice(hashOutputs);
+        }
+        if (leafHash) {
+            sigMsgWriter.writeSlice(leafHash);
+            sigMsgWriter.writeUInt8(0);
+            sigMsgWriter.writeUInt32(0xffffffff);
+        }
+        return bcrypto.taggedHash('TapSighash', Buffer.concat([Buffer.from([0x00]), sigMsgWriter.end()]));
+    }
+    hashForWitnessV0(inIndex, prevOutScript, value, hashType) {
+        typeforce(types.tuple(types.UInt32, types.Buffer, types.Satoshi, types.UInt32), arguments);
+        let tbuffer = Buffer.from([]);
+        let bufferWriter;
+        let hashOutputs = ZERO;
+        let hashPrevouts = ZERO;
+        let hashSequence = ZERO;
+        if (!(hashType & Transaction.SIGHASH_ANYONECANPAY)) {
+            tbuffer = Buffer.allocUnsafe(36 * this.ins.length);
+            bufferWriter = new BufferWriter(tbuffer, 0);
+            this.ins.forEach((txIn) => {
+                bufferWriter.writeSlice(txIn.hash);
+                bufferWriter.writeUInt32(txIn.index);
+            });
+            hashPrevouts = bcrypto.hash256(tbuffer);
+        }
+        if (!(hashType & Transaction.SIGHASH_ANYONECANPAY) &&
+            (hashType & 0x1f) !== Transaction.SIGHASH_SINGLE &&
+            (hashType & 0x1f) !== Transaction.SIGHASH_NONE) {
+            tbuffer = Buffer.allocUnsafe(4 * this.ins.length);
+            bufferWriter = new BufferWriter(tbuffer, 0);
+            this.ins.forEach((txIn) => {
+                bufferWriter.writeUInt32(txIn.sequence);
+            });
+            hashSequence = bcrypto.hash256(tbuffer);
+        }
+        if ((hashType & 0x1f) !== Transaction.SIGHASH_SINGLE &&
+            (hashType & 0x1f) !== Transaction.SIGHASH_NONE) {
+            const txOutsSize = this.outs.reduce((sum, output) => {
+                return sum + 8 + varSliceSize(output.script);
+            }, 0);
+            tbuffer = Buffer.allocUnsafe(txOutsSize);
+            bufferWriter = new BufferWriter(tbuffer, 0);
+            this.outs.forEach((out) => {
+                bufferWriter.writeUInt64(out.value);
+                bufferWriter.writeVarSlice(out.script);
+            });
+            hashOutputs = bcrypto.hash256(tbuffer);
+        }
+        else if ((hashType & 0x1f) === Transaction.SIGHASH_SINGLE && inIndex < this.outs.length) {
+            const output = this.outs[inIndex];
+            tbuffer = Buffer.allocUnsafe(8 + varSliceSize(output.script));
+            bufferWriter = new BufferWriter(tbuffer, 0);
+            bufferWriter.writeUInt64(output.value);
+            bufferWriter.writeVarSlice(output.script);
+            hashOutputs = bcrypto.hash256(tbuffer);
+        }
+        tbuffer = Buffer.allocUnsafe(156 + varSliceSize(prevOutScript));
+        bufferWriter = new BufferWriter(tbuffer, 0);
+        const input = this.ins[inIndex];
+        bufferWriter.writeInt32(this.version);
+        bufferWriter.writeSlice(hashPrevouts);
+        bufferWriter.writeSlice(hashSequence);
+        bufferWriter.writeSlice(input.hash);
+        bufferWriter.writeUInt32(input.index);
+        bufferWriter.writeVarSlice(prevOutScript);
+        bufferWriter.writeUInt64(value);
+        bufferWriter.writeUInt32(input.sequence);
+        bufferWriter.writeSlice(hashOutputs);
+        bufferWriter.writeUInt32(this.locktime);
+        bufferWriter.writeUInt32(hashType);
+        return bcrypto.hash256(tbuffer);
+    }
+    getHash(forWitness) {
+        if (forWitness && this.isCoinbase())
+            return Buffer.alloc(32, 0);
+        return bcrypto.hash256(this.__toBuffer(undefined, undefined, forWitness));
+    }
+    getId() {
+        return reverseBuffer(this.getHash(false)).toString('hex');
+    }
+    toBuffer(buffer, initialOffset) {
+        return this.__toBuffer(buffer, initialOffset, true);
+    }
+    toHex() {
+        return this.toBuffer(undefined, undefined).toString('hex');
+    }
+    setInputScript(index, scriptSig) {
+        typeforce(types.tuple(types.Number, types.Buffer), arguments);
+        this.ins[index].script = scriptSig;
+    }
+    setWitness(index, witness) {
+        typeforce(types.tuple(types.Number, [types.Buffer]), arguments);
+        this.ins[index].witness = witness;
+    }
+    __toBuffer(buffer, initialOffset, _ALLOW_WITNESS = false) {
+        if (!buffer)
+            buffer = Buffer.allocUnsafe(this.byteLength(_ALLOW_WITNESS));
+        const bufferWriter = new BufferWriter(buffer, initialOffset || 0);
+        bufferWriter.writeInt32(this.version);
+        const hasWitnesses = _ALLOW_WITNESS && this.hasWitnesses();
+        if (hasWitnesses) {
+            bufferWriter.writeUInt8(Transaction.ADVANCED_TRANSACTION_MARKER);
+            bufferWriter.writeUInt8(Transaction.ADVANCED_TRANSACTION_FLAG);
+        }
+        bufferWriter.writeVarInt(this.ins.length);
+        this.ins.forEach((txIn) => {
+            bufferWriter.writeSlice(txIn.hash);
+            bufferWriter.writeUInt32(txIn.index);
+            bufferWriter.writeVarSlice(txIn.script);
+            bufferWriter.writeUInt32(txIn.sequence);
+        });
+        bufferWriter.writeVarInt(this.outs.length);
+        this.outs.forEach((txOut) => {
+            if (isOutput(txOut)) {
+                bufferWriter.writeUInt64(txOut.value);
+            }
+            else {
+                bufferWriter.writeSlice(txOut.valueBuffer);
+            }
+            bufferWriter.writeVarSlice(txOut.script);
+        });
+        if (hasWitnesses) {
+            this.ins.forEach((input) => {
+                bufferWriter.writeVector(input.witness);
+            });
+        }
+        bufferWriter.writeUInt32(this.locktime);
+        if (initialOffset !== undefined)
+            return buffer.slice(initialOffset, bufferWriter.offset);
+        return buffer;
+    }
+}
+Transaction.DEFAULT_SEQUENCE = 0xffffffff;
+Transaction.SIGHASH_DEFAULT = 0x00;
+Transaction.SIGHASH_ALL = 0x01;
+Transaction.SIGHASH_NONE = 0x02;
+Transaction.SIGHASH_SINGLE = 0x03;
+Transaction.SIGHASH_ANYONECANPAY = 0x80;
+Transaction.SIGHASH_OUTPUT_MASK = 0x03;
+Transaction.SIGHASH_INPUT_MASK = 0x80;
+Transaction.ADVANCED_TRANSACTION_MARKER = 0x00;
+Transaction.ADVANCED_TRANSACTION_FLAG = 0x01;

package/build/types.d.ts

@@ -0,0 +1,37 @@
+export declare const typeforce: any;
+export declare function stacksEqual(a: Buffer[], b: Buffer[]): boolean;
+export declare function isPoint(p: Buffer | number | undefined | null): boolean;
+export declare function Satoshi(value: number): boolean;
+export interface XOnlyPointAddTweakResult {
+    parity: 1 | 0;
+    xOnlyPubkey: Uint8Array;
+}
+export interface Tapleaf {
+    output: Buffer;
+    version?: number;
+}
+export declare const TAPLEAF_VERSION_MASK = 254;
+export declare function isTapleaf(o: any): o is Tapleaf;
+export type Taptree = [Taptree | Tapleaf, Taptree | Tapleaf] | Tapleaf;
+export declare function isTaptree(scriptTree: any): scriptTree is Taptree;
+export interface TinySecp256k1Interface {
+    isXOnlyPoint(p: Uint8Array): boolean;
+    xOnlyPointAddTweak(p: Uint8Array, tweak: Uint8Array): XOnlyPointAddTweakResult | null;
+}
+export declare const Buffer256bit: any;
+export declare const Hash160bit: any;
+export declare const Hash256bit: any;
+export declare const Number: any;
+export declare const Array: any;
+export declare const Boolean: any;
+export declare const String: any;
+export declare const Buffer: any;
+export declare const Hex: any;
+export declare const maybe: any;
+export declare const tuple: any;
+export declare const UInt8: any;
+export declare const UInt32: any;
+export declare const Function: any;
+export declare const BufferN: any;
+export declare const Null: any;
+export declare const oneOf: any;

package/build/types.js

@@ -0,0 +1,73 @@
+import { Buffer as NBuffer } from 'buffer';
+import * as _typeforce from 'typeforce';
+export const typeforce = _typeforce.default;
+const ZERO32 = NBuffer.alloc(32, 0);
+const EC_P = NBuffer.from('fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f', 'hex');
+export function stacksEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    return a.every((x, i) => {
+        return x.equals(b[i]);
+    });
+}
+export function isPoint(p) {
+    if (!NBuffer.isBuffer(p))
+        return false;
+    if (p.length < 33)
+        return false;
+    const t = p[0];
+    const x = p.slice(1, 33);
+    if (x.compare(ZERO32) === 0)
+        return false;
+    if (x.compare(EC_P) >= 0)
+        return false;
+    if ((t === 0x02 || t === 0x03) && p.length === 33) {
+        return true;
+    }
+    if (p.length !== 65)
+        return false;
+    const y = p.slice(33);
+    if (y.compare(ZERO32) === 0)
+        return false;
+    if (y.compare(EC_P) >= 0)
+        return false;
+    return t === 0x04 || t === 0x06 || t === 0x07;
+}
+const SATOSHI_MAX = 21 * 1e14;
+export function Satoshi(value) {
+    return typeforce.UInt53(value) && value <= SATOSHI_MAX;
+}
+export const TAPLEAF_VERSION_MASK = 0xfe;
+export function isTapleaf(o) {
+    if (!o || !('output' in o))
+        return false;
+    if (!NBuffer.isBuffer(o.output))
+        return false;
+    if (o.version !== undefined)
+        return (o.version & TAPLEAF_VERSION_MASK) === o.version;
+    return true;
+}
+export function isTaptree(scriptTree) {
+    if (!Array(scriptTree))
+        return isTapleaf(scriptTree);
+    if (scriptTree.length !== 2)
+        return false;
+    return scriptTree.every((t) => isTaptree(t));
+}
+export const Buffer256bit = typeforce.BufferN(32);
+export const Hash160bit = typeforce.BufferN(20);
+export const Hash256bit = typeforce.BufferN(32);
+export const Number = typeforce.Number;
+export const Array = typeforce.Array;
+export const Boolean = typeforce.Boolean;
+export const String = typeforce.String;
+export const Buffer = typeforce.Buffer;
+export const Hex = typeforce.Hex;
+export const maybe = typeforce.maybe;
+export const tuple = typeforce.tuple;
+export const UInt8 = typeforce.UInt8;
+export const UInt32 = typeforce.UInt32;
+export const Function = typeforce.Function;
+export const BufferN = typeforce.BufferN;
+export const Null = typeforce.Null;
+export const oneOf = typeforce.oneOf;

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "commonjs"
+}

package/eslint.config.js

@@ -0,0 +1,56 @@
+// @ts-check
+
+import eslint from '@eslint/js';
+import tseslint from 'typescript-eslint';
+
+export default tseslint.config(
+    eslint.configs.recommended,
+    ...tseslint.configs.strictTypeChecked,
+    {
+        languageOptions: {
+            parserOptions: {
+                projectService: true,
+                tsconfigDirName: import.meta.dirname,
+            },
+        },
+        rules: {
+            'no-undef': 'off',
+            '@typescript-eslint/no-unused-vars': 'off',
+            'no-empty': 'off',
+            '@typescript-eslint/restrict-template-expressions': 'off',
+            '@typescript-eslint/only-throw-error': 'off',
+            '@typescript-eslint/no-unnecessary-condition': 'off',
+            '@typescript-eslint/unbound-method': 'warn',
+            '@typescript-eslint/no-confusing-void-expression': 'off',
+            '@typescript-eslint/no-extraneous-class': 'off',
+            'no-async-promise-executor': 'off',
+            '@typescript-eslint/no-misused-promises': 'off',
+            '@typescript-eslint/no-unnecessary-type-parameters': 'off',
+            '@typescript-eslint/no-duplicate-enum-values': 'off',
+            'prefer-spread': 'off',
+            '@typescript-eslint/no-empty-object-type': 'off',
+            /** TO FIX */
+            '@typescript-eslint/no-unsafe-call': 'warn',
+            '@typescript-eslint/no-unsafe-assignment': 'warn',
+            'prefer-rest-params': 'warn',
+            '@typescript-eslint/restrict-plus-operands': 'warn',
+            '@typescript-eslint/no-unsafe-member-access': 'warn',
+            '@typescript-eslint/no-unsafe-return': 'warn',
+            '@typescript-eslint/no-require-imports': 'warn',
+            '@typescript-eslint/no-explicit-any': 'warn',
+            '@typescript-eslint/no-unsafe-argument': 'warn',
+            '@typescript-eslint/no-unnecessary-type-assertion': 'warn',
+            '@typescript-eslint/no-non-null-assertion': 'warn',
+            '@typescript-eslint/no-invalid-void-type': 'warn',
+            '@typescript-eslint/no-unnecessary-boolean-literal-compare': 'warn',
+            '@typescript-eslint/no-unnecessary-template-expression': 'warn',
+            'no-case-declarations': 'warn',
+            '@typescript-eslint/ban-ts-comment': 'warn',
+            '@typescript-eslint/no-deprecated': 'warn',
+        },
+    },
+    {
+        files: ['**/*.js'],
+        ...tseslint.configs.disableTypeChecked,
+    },
+);

package/gulpfile.js

@@ -0,0 +1,42 @@
+import gulp from 'gulp';
+import gulpcache from 'gulp-cached';
+import gulpESLintNew from 'gulp-eslint-new';
+
+import gulpClean from 'gulp-clean';
+import logger from 'gulp-logger-new';
+import ts from 'gulp-typescript';
+
+process.on('uncaughtException', function (err) {
+    console.log('Caught exception: ', err);
+});
+
+const tsProject = ts.createProject('tsconfig.json');
+
+function buildESM() {
+    return tsProject
+        .src()
+        .pipe(gulpcache('ts-esm'))
+        .pipe(
+            logger({
+                before: 'Starting...',
+                after: 'Project compiled!',
+                extname: '.js',
+                showChange: true,
+            }),
+        )
+        .pipe(gulpESLintNew())
+        .pipe(gulpESLintNew.format())
+        .pipe(tsProject())
+        .pipe(gulp.dest('build'));
+}
+
+export async function clean() {
+    return gulp.src('./build/src', { read: false }).pipe(gulpClean());
+}
+
+export const build = buildESM;
+export default build;
+
+export function watch() {
+    gulp.watch(['src/**/*.ts', 'src/**/*.js'], gulp.series(buildESM));
+}