@onetokenfe/coinselect 3.1.16

package/third-party/utxo-lib/transaction/dash.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromConstructor = fromConstructor;
+exports.fromBuffer = fromBuffer;
+const tslib_1 = require("tslib");
+const varuint = tslib_1.__importStar(require("varuint-bitcoin"));
+const bufferutils_1 = require("../bufferutils");
+const base_1 = require("./base");
+const DASH_NORMAL = 0;
+const DASH_QUORUM_COMMITMENT = 6;
+function byteLength(tx, _ALLOW_WITNESS = true) {
+    var _a;
+    const hasWitnesses = _ALLOW_WITNESS && tx.hasWitnesses();
+    return ((hasWitnesses ? 10 : 8) +
+        (tx.timestamp ? 4 : 0) +
+        varuint.encodingLength(tx.ins.length) +
+        varuint.encodingLength(tx.outs.length) +
+        tx.ins.reduce((sum, input) => sum + 40 + (0, base_1.varSliceSize)(input.script), 0) +
+        tx.outs.reduce((sum, output) => sum + 8 + (0, base_1.varSliceSize)(output.script), 0) +
+        (((_a = tx.specific) === null || _a === void 0 ? void 0 : _a.extraPayload) ? (0, base_1.varSliceSize)(tx.specific.extraPayload) : 0) +
+        (hasWitnesses ? tx.ins.reduce((sum, input) => sum + (0, base_1.vectorSize)(input.witness), 0) : 0));
+}
+function toBuffer(tx, buffer, initialOffset, _ALLOW_WITNESS = true) {
+    var _a;
+    if (!buffer)
+        buffer = Buffer.allocUnsafe(tx.byteLength(_ALLOW_WITNESS));
+    const bufferWriter = new bufferutils_1.BufferWriter(buffer, initialOffset || 0);
+    if (tx.version >= 3 && tx.type !== DASH_NORMAL) {
+        bufferWriter.writeUInt16(tx.version);
+        bufferWriter.writeUInt16(tx.type);
+    }
+    else {
+        bufferWriter.writeInt32(tx.version);
+    }
+    bufferWriter.writeVarInt(tx.ins.length);
+    tx.ins.forEach(txIn => {
+        bufferWriter.writeSlice(txIn.hash);
+        bufferWriter.writeUInt32(txIn.index);
+        bufferWriter.writeVarSlice(txIn.script);
+        bufferWriter.writeUInt32(txIn.sequence);
+    });
+    bufferWriter.writeVarInt(tx.outs.length);
+    tx.outs.forEach(txOut => {
+        bufferWriter.writeUInt64(txOut.value);
+        bufferWriter.writeVarSlice(txOut.script);
+    });
+    bufferWriter.writeUInt32(tx.locktime);
+    if ((_a = tx.specific) === null || _a === void 0 ? void 0 : _a.extraPayload)
+        bufferWriter.writeVarSlice(tx.specific.extraPayload);
+    if (initialOffset !== undefined)
+        return buffer.subarray(initialOffset, bufferWriter.offset);
+    return buffer;
+}
+function getExtraData(tx) {
+    var _a;
+    if (!((_a = tx.specific) === null || _a === void 0 ? void 0 : _a.extraPayload))
+        return;
+    const { buffer: extraDataLength } = varuint.encode(tx.specific.extraPayload.length);
+    return Buffer.concat([extraDataLength, tx.specific.extraPayload]);
+}
+function fromConstructor(options) {
+    const tx = new base_1.TransactionBase(options);
+    tx.specific = tx.specific || { type: 'dash' };
+    tx.byteLength = byteLength.bind(null, tx);
+    tx.toBuffer = toBuffer.bind(null, tx);
+    tx.getExtraData = getExtraData.bind(null, tx);
+    return tx;
+}
+function fromBuffer(buffer, options) {
+    const bufferReader = new bufferutils_1.BufferReader(buffer);
+    const tx = fromConstructor(options);
+    tx.version = bufferReader.readInt32();
+    tx.type = tx.version >> 16;
+    tx.version &= 0xffff;
+    if (tx.version === 3 && (tx.type < DASH_NORMAL || tx.type > DASH_QUORUM_COMMITMENT)) {
+        throw new Error('Unsupported Dash transaction type');
+    }
+    const vinLen = bufferReader.readVarInt();
+    for (let i = 0; i < vinLen; ++i) {
+        tx.ins.push({
+            hash: bufferReader.readSlice(32),
+            index: bufferReader.readUInt32(),
+            script: bufferReader.readVarSlice(),
+            sequence: bufferReader.readUInt32(),
+            witness: [],
+        });
+    }
+    const voutLen = bufferReader.readVarInt();
+    for (let i = 0; i < voutLen; ++i) {
+        tx.outs.push({
+            value: bufferReader.readUInt64String(),
+            script: bufferReader.readVarSlice(),
+        });
+    }
+    tx.locktime = bufferReader.readUInt32();
+    if (tx.version >= 3 && tx.type !== DASH_NORMAL) {
+        tx.specific.extraPayload = bufferReader.readVarSlice();
+    }
+    if (options.nostrict)
+        return tx;
+    if (bufferReader.offset !== buffer.length)
+        throw new Error('Transaction has unexpected data');
+    return tx;
+}
+//# sourceMappingURL=dash.js.map

package/third-party/utxo-lib/transaction/decred.d.ts

@@ -0,0 +1,4 @@
+import { TransactionBase, TransactionOptions } from './base';
+export declare function fromConstructor(options: TransactionOptions): TransactionBase<undefined>;
+export declare function fromBuffer(buffer: Buffer, options: TransactionOptions): TransactionBase<undefined>;
+//# sourceMappingURL=decred.d.ts.map

package/third-party/utxo-lib/transaction/decred.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromConstructor = fromConstructor;
+exports.fromBuffer = fromBuffer;
+const tslib_1 = require("tslib");
+const varuint = tslib_1.__importStar(require("varuint-bitcoin"));
+const bufferutils_1 = require("../bufferutils");
+const bcrypto = tslib_1.__importStar(require("../crypto"));
+const base_1 = require("./base");
+const DECRED_TX_VERSION = 1;
+const DECRED_TX_SERIALIZE_FULL = 0;
+const DECRED_TX_SERIALIZE_NO_WITNESS = 1;
+const DECRED_SCRIPT_VERSION = 0;
+function hasWitnesses(tx) {
+    return tx.type === DECRED_TX_SERIALIZE_FULL;
+}
+function byteLength(tx, _ALLOW_WITNESS = true) {
+    let byteLength = 4 + varuint.encodingLength(tx.ins.length);
+    let nWitness = 0;
+    const hasWitnesses = _ALLOW_WITNESS && tx.hasWitnesses();
+    byteLength += tx.ins.reduce((sum, input) => {
+        sum += 32 + 4 + 1 + 4;
+        if (hasWitnesses) {
+            nWitness += 1;
+            sum += 8 + 4 + 4;
+            sum += (0, base_1.varSliceSize)(input.decredWitness.script);
+        }
+        return sum;
+    }, 0);
+    if (hasWitnesses) {
+        byteLength += varuint.encodingLength(nWitness);
+    }
+    byteLength += varuint.encodingLength(tx.outs.length);
+    byteLength += tx.outs.reduce((sum, output) => {
+        sum += 8 + 2;
+        sum += (0, base_1.varSliceSize)(output.script);
+        return sum;
+    }, 0);
+    byteLength += 4 + 4;
+    return byteLength;
+}
+function toBuffer(tx, buffer, initialOffset, _ALLOW_WITNESS = true) {
+    if (!buffer)
+        buffer = Buffer.allocUnsafe(byteLength(tx, _ALLOW_WITNESS));
+    const bufferWriter = new bufferutils_1.BufferWriter(buffer, initialOffset || 0);
+    bufferWriter.writeUInt16(tx.version);
+    bufferWriter.writeUInt16(_ALLOW_WITNESS ? tx.type : DECRED_TX_SERIALIZE_NO_WITNESS);
+    bufferWriter.writeVarInt(tx.ins.length);
+    tx.ins.forEach(txIn => {
+        bufferWriter.writeSlice(txIn.hash);
+        bufferWriter.writeUInt32(txIn.index);
+        bufferWriter.writeUInt8(txIn.decredTree);
+        bufferWriter.writeUInt32(txIn.sequence);
+    });
+    bufferWriter.writeVarInt(tx.outs.length);
+    tx.outs.forEach(txOut => {
+        bufferWriter.writeUInt64(txOut.value);
+        bufferWriter.writeUInt16(txOut.decredVersion);
+        bufferWriter.writeVarSlice(txOut.script);
+    });
+    bufferWriter.writeUInt32(tx.locktime);
+    bufferWriter.writeUInt32(tx.expiry);
+    if (_ALLOW_WITNESS && tx.hasWitnesses()) {
+        bufferWriter.writeVarInt(tx.ins.length);
+        tx.ins.forEach(input => {
+            bufferWriter.writeUInt64(input.decredWitness.value);
+            bufferWriter.writeUInt32(input.decredWitness.height);
+            bufferWriter.writeUInt32(input.decredWitness.blockIndex);
+            bufferWriter.writeVarSlice(input.decredWitness.script);
+        });
+    }
+    if (initialOffset !== undefined)
+        return buffer.subarray(initialOffset, bufferWriter.offset);
+    return buffer;
+}
+function getHash(tx, forWitness = false) {
+    if (forWitness && tx.isCoinbase())
+        return Buffer.alloc(32, 0);
+    return bcrypto.blake256(toBuffer(tx, undefined, undefined, forWitness));
+}
+function weight(tx) {
+    return tx.byteLength(true);
+}
+function fromConstructor(options) {
+    const tx = new base_1.TransactionBase(options);
+    tx.byteLength = byteLength.bind(null, tx);
+    tx.toBuffer = toBuffer.bind(null, tx);
+    tx.hasWitnesses = hasWitnesses.bind(null, tx);
+    tx.getHash = getHash.bind(null, tx);
+    tx.weight = weight.bind(null, tx);
+    return tx;
+}
+function fromBuffer(buffer, options) {
+    const bufferReader = new bufferutils_1.BufferReader(buffer);
+    const tx = fromConstructor(options);
+    tx.version = bufferReader.readInt32();
+    tx.type = tx.version >> 16;
+    tx.version &= 0xffff;
+    if (tx.version !== DECRED_TX_VERSION) {
+        throw new Error('Unsupported Decred transaction version');
+    }
+    if (tx.type !== DECRED_TX_SERIALIZE_FULL && tx.type !== DECRED_TX_SERIALIZE_NO_WITNESS) {
+        throw new Error('Unsupported Decred transaction type');
+    }
+    const vinLen = bufferReader.readVarInt();
+    for (let i = 0; i < vinLen; ++i) {
+        tx.ins.push({
+            hash: bufferReader.readSlice(32),
+            index: bufferReader.readUInt32(),
+            decredTree: bufferReader.readUInt8(),
+            sequence: bufferReader.readUInt32(),
+            script: base_1.EMPTY_SCRIPT,
+            witness: [],
+        });
+    }
+    const voutLen = bufferReader.readVarInt();
+    for (let i = 0; i < voutLen; i++) {
+        const value = bufferReader.readUInt64String();
+        const version = bufferReader.readUInt16();
+        if (version !== DECRED_SCRIPT_VERSION)
+            throw new Error('Unsupported Decred script version');
+        tx.outs.push({
+            value,
+            decredVersion: version,
+            script: bufferReader.readVarSlice(),
+        });
+    }
+    tx.locktime = bufferReader.readUInt32();
+    tx.expiry = bufferReader.readUInt32();
+    if (tx.type === DECRED_TX_SERIALIZE_FULL) {
+        const count = bufferReader.readVarInt();
+        if (count !== vinLen)
+            throw new Error('Non equal number of ins and witnesses');
+        tx.ins.forEach(vin => {
+            vin.decredWitness = {
+                value: bufferReader.readUInt64String(),
+                height: bufferReader.readUInt32(),
+                blockIndex: bufferReader.readUInt32(),
+                script: bufferReader.readVarSlice(),
+            };
+        });
+    }
+    if (options.nostrict)
+        return tx;
+    if (bufferReader.offset !== buffer.length)
+        throw new Error('Transaction has unexpected data');
+    return tx;
+}
+//# sourceMappingURL=decred.js.map

package/third-party/utxo-lib/transaction/index.d.ts

@@ -0,0 +1,15 @@
+import { TransactionBase, TransactionOptions } from './base';
+import * as dash from './dash';
+import * as zcash from './zcash';
+export type TxOptions = TransactionOptions & {
+    txSpecific?: dash.DashSpecific | zcash.ZcashSpecific;
+};
+declare class Transaction extends TransactionBase<dash.DashSpecific | zcash.ZcashSpecific> {
+    constructor(options?: TxOptions);
+    static isCoinbaseHash(buffer: Buffer): boolean;
+    static fromBuffer(buffer: Buffer, options?: TransactionOptions): TransactionBase<undefined> | TransactionBase<dash.DashSpecific> | TransactionBase<zcash.ZcashSpecific>;
+    static fromHex(hex: string, options?: TransactionOptions): TransactionBase<undefined> | TransactionBase<dash.DashSpecific> | TransactionBase<zcash.ZcashSpecific>;
+}
+export type { TransactionOptions } from './base';
+export { Transaction };
+//# sourceMappingURL=index.d.ts.map

package/third-party/utxo-lib/transaction/index.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transaction = void 0;
+const tslib_1 = require("tslib");
+const networks_1 = require("../networks");
+const base_1 = require("./base");
+const bitcoin = tslib_1.__importStar(require("./bitcoin"));
+const dash = tslib_1.__importStar(require("./dash"));
+const decred = tslib_1.__importStar(require("./decred"));
+const peercoin = tslib_1.__importStar(require("./peercoin"));
+const zcash = tslib_1.__importStar(require("./zcash"));
+class Transaction extends base_1.TransactionBase {
+    constructor(options = {}) {
+        super(options);
+        if ((0, networks_1.isNetworkType)('dash', this.network))
+            return dash.fromConstructor(options);
+        if ((0, networks_1.isNetworkType)('decred', this.network))
+            return decred.fromConstructor(options);
+        if ((0, networks_1.isNetworkType)('peercoin', this.network))
+            return peercoin.fromConstructor(options);
+        if ((0, networks_1.isNetworkType)('zcash', this.network))
+            return zcash.fromConstructor(options);
+        return bitcoin.fromConstructor(options);
+    }
+    static isCoinbaseHash(buffer) {
+        return (0, base_1.isCoinbaseHash)(buffer);
+    }
+    static fromBuffer(buffer, options = {}) {
+        if ((0, networks_1.isNetworkType)('dash', options.network))
+            return dash.fromBuffer(buffer, options);
+        if ((0, networks_1.isNetworkType)('decred', options.network))
+            return decred.fromBuffer(buffer, options);
+        if ((0, networks_1.isNetworkType)('peercoin', options.network))
+            return peercoin.fromBuffer(buffer, options);
+        if ((0, networks_1.isNetworkType)('zcash', options.network))
+            return zcash.fromBuffer(buffer, options);
+        return bitcoin.fromBuffer(buffer, options);
+    }
+    static fromHex(hex, options = {}) {
+        return this.fromBuffer(Buffer.from(hex, 'hex'), Object.assign(Object.assign({}, options), { nostrict: false }));
+    }
+}
+exports.Transaction = Transaction;
+//# sourceMappingURL=index.js.map

package/third-party/utxo-lib/transaction/peercoin.d.ts

@@ -0,0 +1,4 @@
+import { TransactionBase, TransactionOptions } from './base';
+export declare function fromConstructor(options: TransactionOptions): TransactionBase<undefined>;
+export declare function fromBuffer(buffer: Buffer, options: TransactionOptions): TransactionBase<undefined>;
+//# sourceMappingURL=peercoin.d.ts.map

package/third-party/utxo-lib/transaction/peercoin.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromConstructor = fromConstructor;
+exports.fromBuffer = fromBuffer;
+const bufferutils_1 = require("../bufferutils");
+const base_1 = require("./base");
+function toBuffer(tx, buffer, initialOffset) {
+    if (!buffer)
+        buffer = Buffer.allocUnsafe(tx.byteLength(false));
+    const bufferWriter = new bufferutils_1.BufferWriter(buffer, initialOffset || 0);
+    bufferWriter.writeInt32(tx.version);
+    bufferWriter.writeUInt32(tx.timestamp);
+    bufferWriter.writeVarInt(tx.ins.length);
+    tx.ins.forEach(txIn => {
+        bufferWriter.writeSlice(txIn.hash);
+        bufferWriter.writeUInt32(txIn.index);
+        bufferWriter.writeVarSlice(txIn.script);
+        bufferWriter.writeUInt32(txIn.sequence);
+    });
+    bufferWriter.writeVarInt(tx.outs.length);
+    tx.outs.forEach(txOut => {
+        bufferWriter.writeUInt64(txOut.value);
+        bufferWriter.writeVarSlice(txOut.script);
+    });
+    bufferWriter.writeUInt32(tx.locktime);
+    if (initialOffset !== undefined)
+        return buffer.subarray(initialOffset, bufferWriter.offset);
+    return buffer;
+}
+function fromConstructor(options) {
+    const tx = new base_1.TransactionBase(options);
+    tx.toBuffer = toBuffer.bind(null, tx);
+    return tx;
+}
+function fromBuffer(buffer, options) {
+    const bufferReader = new bufferutils_1.BufferReader(buffer);
+    const tx = fromConstructor(options);
+    tx.version = bufferReader.readInt32();
+    tx.timestamp = bufferReader.readUInt32();
+    const vinLen = bufferReader.readVarInt();
+    for (let i = 0; i < vinLen; ++i) {
+        tx.ins.push({
+            hash: bufferReader.readSlice(32),
+            index: bufferReader.readUInt32(),
+            script: bufferReader.readVarSlice(),
+            sequence: bufferReader.readUInt32(),
+            witness: [],
+        });
+    }
+    const voutLen = bufferReader.readVarInt();
+    for (let i = 0; i < voutLen; ++i) {
+        tx.outs.push({
+            value: bufferReader.readUInt64String(),
+            script: bufferReader.readVarSlice(),
+        });
+    }
+    tx.locktime = bufferReader.readUInt32();
+    if (options.nostrict)
+        return tx;
+    if (bufferReader.offset !== buffer.length)
+        throw new Error('Transaction has unexpected data');
+    return tx;
+}
+//# sourceMappingURL=peercoin.js.map

package/third-party/utxo-lib/transaction/zcash.d.ts

@@ -0,0 +1,66 @@
+import { TransactionBase, TransactionOptions } from './base';
+export interface ZcashCompressedG {
+    x: Buffer;
+    yLsb: number;
+}
+export interface ZcashSaplingZKProof {
+    type: 'sapling';
+    sA: Buffer;
+    sB: Buffer;
+    sC: Buffer;
+}
+export interface ZcashJoinSplitZKProof {
+    type: 'joinsplit';
+    gA: ZcashCompressedG;
+    gAPrime: ZcashCompressedG;
+    gB: ZcashCompressedG;
+    gBPrime: ZcashCompressedG;
+    gC: ZcashCompressedG;
+    gCPrime: ZcashCompressedG;
+    gK: ZcashCompressedG;
+    gH: ZcashCompressedG;
+}
+export interface ZcashJoinSplits {
+    vpubOld: number;
+    vpubNew: number;
+    anchor: Buffer;
+    nullifiers: Buffer[];
+    commitments: Buffer[];
+    ephemeralKey: Buffer;
+    randomSeed: Buffer;
+    macs: Buffer[];
+    zkproof: ZcashSaplingZKProof | ZcashJoinSplitZKProof;
+    ciphertexts: Buffer[];
+}
+export interface ZcashVShieldedSpend {
+    cv: Buffer;
+    anchor: Buffer;
+    nullifier: Buffer;
+    rk: Buffer;
+    zkproof: ZcashSaplingZKProof;
+    spendAuthSig: Buffer;
+}
+export interface ZcashVShieldedOutput {
+    cv: Buffer;
+    cmu: Buffer;
+    ephemeralKey: Buffer;
+    encCiphertext: Buffer;
+    outCiphertext: Buffer;
+    zkproof: ZcashSaplingZKProof;
+}
+export interface ZcashSpecific {
+    type: 'zcash';
+    joinsplits: ZcashJoinSplits[];
+    joinsplitPubkey: Buffer;
+    joinsplitSig: Buffer;
+    overwintered: number;
+    versionGroupId: number;
+    valueBalance: number;
+    vShieldedSpend: ZcashVShieldedSpend[];
+    vShieldedOutput: ZcashVShieldedOutput[];
+    bindingSig: Buffer;
+    consensusBranchId: number;
+}
+export declare function fromConstructor(options: TransactionOptions): TransactionBase<ZcashSpecific>;
+export declare function fromBuffer(buffer: Buffer, options: TransactionOptions): TransactionBase<ZcashSpecific>;
+//# sourceMappingURL=zcash.d.ts.map