@onetokenfe/coinselect 3.1.16

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

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPS = exports.signature = exports.number = void 0;
+exports.isPushOnly = isPushOnly;
+exports.compile = compile;
+exports.decompile = decompile;
+exports.toASM = toASM;
+exports.fromASM = fromASM;
+exports.toStack = toStack;
+exports.isCanonicalPubKey = isCanonicalPubKey;
+exports.isDefinedHashType = isDefinedHashType;
+exports.isCanonicalScriptSignature = isCanonicalScriptSignature;
+const tslib_1 = require("tslib");
+const bip66 = tslib_1.__importStar(require("bip66"));
+const pushdata_bitcoin_1 = tslib_1.__importDefault(require("pushdata-bitcoin"));
+const tiny_secp256k1_1 = tslib_1.__importDefault(require("tiny-secp256k1"));
+const scriptNumber = tslib_1.__importStar(require("./scriptNumber"));
+const scriptSignature = tslib_1.__importStar(require("./scriptSignature"));
+const ops_1 = require("./ops");
+const types = tslib_1.__importStar(require("../types"));
+const types_1 = require("../types");
+const OP_INT_BASE = ops_1.OPS.OP_RESERVED;
+function isOPInt(value) {
+    return (types.Number(value) &&
+        (value === ops_1.OPS.OP_0 ||
+            (value >= ops_1.OPS.OP_1 && value <= ops_1.OPS.OP_16) ||
+            value === ops_1.OPS.OP_1NEGATE));
+}
+function isPushOnlyChunk(value) {
+    return types.Buffer(value) || isOPInt(value);
+}
+function isPushOnly(value) {
+    return types.Array(value) && value.every(isPushOnlyChunk);
+}
+function asMinimalOP(buffer) {
+    if (buffer.length === 0)
+        return ops_1.OPS.OP_0;
+    if (buffer.length !== 1)
+        return;
+    if (buffer[0] >= 1 && buffer[0] <= 16)
+        return OP_INT_BASE + buffer[0];
+    if (buffer[0] === 0x81)
+        return ops_1.OPS.OP_1NEGATE;
+}
+function compile(chunks) {
+    if (types.Buffer(chunks))
+        return chunks;
+    (0, types_1.typeforce)(types.Array, chunks);
+    const bufferSize = chunks.reduce((accum, chunk) => {
+        if (types.Buffer(chunk)) {
+            if (chunk.length === 1 && asMinimalOP(chunk) !== undefined) {
+                return accum + 1;
+            }
+            return accum + pushdata_bitcoin_1.default.encodingLength(chunk.length) + chunk.length;
+        }
+        return accum + 1;
+    }, 0.0);
+    const buffer = Buffer.allocUnsafe(bufferSize);
+    let offset = 0;
+    chunks.forEach(chunk => {
+        if (types.Buffer(chunk)) {
+            const opcode = asMinimalOP(chunk);
+            if (opcode !== undefined) {
+                buffer.writeUInt8(opcode, offset);
+                offset += 1;
+                return;
+            }
+            offset += pushdata_bitcoin_1.default.encode(buffer, chunk.length, offset);
+            chunk.copy(buffer, offset);
+            offset += chunk.length;
+        }
+        else {
+            buffer.writeUInt8(chunk, offset);
+            offset += 1;
+        }
+    });
+    if (offset !== buffer.length)
+        throw new Error('Could not decode chunks');
+    return buffer;
+}
+function decompile(buffer) {
+    if (types.Array(buffer))
+        return buffer;
+    (0, types_1.typeforce)(types.Buffer, buffer);
+    const chunks = [];
+    let i = 0;
+    while (i < buffer.length) {
+        const opcode = buffer[i];
+        if (opcode > ops_1.OPS.OP_0 && opcode <= ops_1.OPS.OP_PUSHDATA4) {
+            const d = pushdata_bitcoin_1.default.decode(buffer, i);
+            if (d === null)
+                return [];
+            i += d.size;
+            if (i + d.number > buffer.length)
+                return [];
+            const data = buffer.subarray(i, i + d.number);
+            i += d.number;
+            const op = asMinimalOP(data);
+            if (op !== undefined) {
+                chunks.push(op);
+            }
+            else {
+                chunks.push(data);
+            }
+        }
+        else {
+            chunks.push(opcode);
+            i += 1;
+        }
+    }
+    return chunks;
+}
+function toASM(chunks) {
+    if (types.Buffer(chunks)) {
+        chunks = decompile(chunks);
+    }
+    return chunks
+        .map(chunk => {
+        if (types.Buffer(chunk)) {
+            const op = asMinimalOP(chunk);
+            if (op === undefined)
+                return chunk.toString('hex');
+            chunk = op;
+        }
+        return ops_1.REVERSE_OPS[chunk];
+    })
+        .join(' ');
+}
+function fromASM(asm) {
+    (0, types_1.typeforce)(types.String, asm);
+    return compile(asm.split(' ').map(chunkStr => {
+        if (ops_1.OPS[chunkStr] !== undefined)
+            return ops_1.OPS[chunkStr];
+        (0, types_1.typeforce)(types.Hex, chunkStr);
+        return Buffer.from(chunkStr, 'hex');
+    }));
+}
+function toStack(chunks0) {
+    const chunks = decompile(chunks0);
+    (0, types_1.typeforce)(isPushOnly, chunks);
+    return chunks === null || chunks === void 0 ? void 0 : chunks.map(op => {
+        if (types.Buffer(op))
+            return op;
+        if (op === ops_1.OPS.OP_0)
+            return Buffer.allocUnsafe(0);
+        return scriptNumber.encode(op - OP_INT_BASE);
+    });
+}
+function isCanonicalPubKey(buffer) {
+    return tiny_secp256k1_1.default.isPoint(buffer);
+}
+function isDefinedHashType(hashType) {
+    const hashTypeMod = hashType & ~0x80;
+    return hashTypeMod > 0x00 && hashTypeMod < 0x04;
+}
+function isCanonicalScriptSignature(buffer) {
+    if (!types.Buffer(buffer))
+        return false;
+    if (!isDefinedHashType(buffer[buffer.length - 1]))
+        return false;
+    return bip66.check(buffer.subarray(0, -1));
+}
+exports.number = scriptNumber;
+exports.signature = scriptSignature;
+var ops_2 = require("./ops");
+Object.defineProperty(exports, "OPS", { enumerable: true, get: function () { return ops_2.OPS; } });
+//# sourceMappingURL=index.js.map

package/third-party/utxo-lib/script/ops.d.ts

@@ -0,0 +1,4 @@
+declare const OPS: Record<string, number>;
+declare const REVERSE_OPS: string[];
+export { OPS, REVERSE_OPS };
+//# sourceMappingURL=ops.d.ts.map

package/third-party/utxo-lib/script/ops.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REVERSE_OPS = exports.OPS = void 0;
+const tslib_1 = require("tslib");
+const ops = tslib_1.__importStar(require("bitcoin-ops"));
+const OPS = Object.assign(Object.assign({}, ops), { OP_SSTX: 0xba, OP_SSTXCHANGE: 0xbd, OP_SSGEN: 0xbb, OP_SSRTX: 0xbc });
+exports.OPS = OPS;
+const REVERSE_OPS = [];
+exports.REVERSE_OPS = REVERSE_OPS;
+Object.keys(OPS).forEach(code => {
+    REVERSE_OPS[OPS[code]] = code;
+});
+//# sourceMappingURL=ops.js.map

package/third-party/utxo-lib/script/scriptNumber.d.ts

@@ -0,0 +1,3 @@
+export declare function decode(buffer: Buffer, maxLength?: number, minimal?: boolean): number;
+export declare function encode(number: number): Buffer;
+//# sourceMappingURL=scriptNumber.d.ts.map

package/third-party/utxo-lib/script/scriptNumber.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decode = decode;
+exports.encode = encode;
+function decode(buffer, maxLength = 4, minimal = true) {
+    const { length } = buffer;
+    if (length === 0)
+        return 0;
+    if (length > maxLength)
+        throw new TypeError('Script number overflow');
+    if (minimal) {
+        if ((buffer[length - 1] & 0x7f) === 0) {
+            if (length <= 1 || (buffer[length - 2] & 0x80) === 0)
+                throw new Error('Non-minimally encoded script number');
+        }
+    }
+    if (length === 5) {
+        const a = buffer.readUInt32LE(0);
+        const b = buffer.readUInt8(4);
+        if (b & 0x80)
+            return -((b & ~0x80) * 0x100000000 + a);
+        return b * 0x100000000 + a;
+    }
+    let result = 0;
+    for (let i = 0; i < length; ++i) {
+        result |= buffer[i] << (8 * i);
+    }
+    if (buffer[length - 1] & 0x80)
+        return -(result & ~(0x80 << (8 * (length - 1))));
+    return result;
+}
+function scriptNumSize(i) {
+    if (i > 0x7fffffff)
+        return 5;
+    if (i > 0x7fffff)
+        return 4;
+    if (i > 0x7fff)
+        return 3;
+    if (i > 0x7f)
+        return 2;
+    if (i > 0x00)
+        return 1;
+    return 0;
+}
+function encode(number) {
+    let value = Math.abs(number);
+    const size = scriptNumSize(value);
+    const buffer = Buffer.allocUnsafe(size);
+    const negative = number < 0;
+    for (let i = 0; i < size; ++i) {
+        buffer.writeUInt8(value & 0xff, i);
+        value >>= 8;
+    }
+    if (buffer[size - 1] & 0x80) {
+        buffer.writeUInt8(negative ? 0x80 : 0x00, size - 1);
+    }
+    else if (negative) {
+        buffer[size - 1] |= 0x80;
+    }
+    return buffer;
+}
+//# sourceMappingURL=scriptNumber.js.map

package/third-party/utxo-lib/script/scriptSignature.d.ts

@@ -0,0 +1,8 @@
+export declare function toDER(x: Buffer): Buffer;
+export declare function fromDER(x: Buffer): Buffer;
+export declare function decode(buffer: Buffer): {
+    signature: Buffer;
+    hashType: number;
+};
+export declare function encode(signature: Buffer, hashType: number): Buffer;
+//# sourceMappingURL=scriptSignature.d.ts.map

package/third-party/utxo-lib/script/scriptSignature.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toDER = toDER;
+exports.fromDER = fromDER;
+exports.decode = decode;
+exports.encode = encode;
+const tslib_1 = require("tslib");
+const bip66 = tslib_1.__importStar(require("bip66"));
+const types = tslib_1.__importStar(require("../types"));
+const ZERO = Buffer.alloc(1, 0);
+function toDER(x) {
+    let i = 0;
+    while (x[i] === 0)
+        ++i;
+    if (i === x.length)
+        return ZERO;
+    x = x.subarray(i);
+    if (x[0] & 0x80)
+        return Buffer.concat([ZERO, x], 1 + x.length);
+    return x;
+}
+function fromDER(x) {
+    if (x[0] === 0x00)
+        x = x.subarray(1);
+    const buffer = Buffer.alloc(32, 0);
+    const bstart = Math.max(0, 32 - x.length);
+    x.copy(buffer, bstart);
+    return buffer;
+}
+function decode(buffer) {
+    const hashType = buffer.readUInt8(buffer.length - 1);
+    const hashTypeMod = hashType & ~0x80;
+    if (hashTypeMod <= 0 || hashTypeMod >= 4)
+        throw new Error(`Invalid hashType ${hashType}`);
+    const decoded = bip66.decode(buffer.subarray(0, -1));
+    const r = fromDER(decoded.r);
+    const s = fromDER(decoded.s);
+    const signature = Buffer.concat([r, s], 64);
+    return { signature, hashType };
+}
+function encode(signature, hashType) {
+    types.typeforce({
+        signature: types.BufferN(64),
+        hashType: types.UInt8,
+    }, { signature, hashType });
+    const hashTypeMod = hashType & ~0x80;
+    if (hashTypeMod <= 0 || hashTypeMod >= 4)
+        throw new Error(`Invalid hashType ${hashType}`);
+    const hashTypeBuffer = Buffer.allocUnsafe(1);
+    hashTypeBuffer.writeUInt8(hashType, 0);
+    const r = toDER(signature.subarray(0, 32));
+    const s = toDER(signature.subarray(32, 64));
+    return Buffer.concat([bip66.encode(r, s), hashTypeBuffer]);
+}
+//# sourceMappingURL=scriptSignature.js.map

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

@@ -0,0 +1,56 @@
+import { Network } from '../networks';
+export declare function varSliceSize(someScript: Buffer): number;
+export declare function vectorSize(someVector: Buffer[]): number;
+export declare function isCoinbaseHash(buffer: Buffer): boolean;
+export declare const EMPTY_SCRIPT: Buffer;
+export interface TxOutput {
+    script: Buffer;
+    value: string;
+    decredVersion?: number;
+}
+export interface TxInput {
+    hash: Buffer;
+    index: number;
+    script: Buffer;
+    sequence: number;
+    witness: Buffer[];
+    decredTree?: number;
+    decredWitness?: {
+        value: string;
+        height: number;
+        blockIndex: number;
+        script: Buffer;
+    };
+}
+export type TransactionOptions = {
+    nostrict?: boolean;
+    network?: Network;
+};
+export declare class TransactionBase<S = undefined> {
+    version: number;
+    locktime: number;
+    ins: TxInput[];
+    outs: TxOutput[];
+    specific: S | undefined;
+    network: Network;
+    type: number | undefined;
+    timestamp: number | undefined;
+    expiry: number | undefined;
+    constructor(options: TransactionOptions & {
+        txSpecific?: S;
+    });
+    isCoinbase(): boolean;
+    hasWitnesses(): boolean;
+    isMwebPegOutTx(): boolean;
+    weight(): number;
+    virtualSize(): number;
+    byteLength(_ALLOW_WITNESS?: boolean, _ALLOW_MWEB?: boolean): number;
+    getHash(forWitness?: boolean, forMweb?: boolean): Buffer;
+    getId(): string;
+    getWitness(index: number): Buffer | undefined;
+    getExtraData(): Buffer | void;
+    getSpecificData(): S | void;
+    toBuffer(_buffer?: Buffer, _initialOffset?: number, _ALLOW_WITNESS?: boolean, _ALLOW_MWEB?: boolean): Buffer;
+    toHex(): string;
+}
+//# sourceMappingURL=base.d.ts.map

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

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionBase = exports.EMPTY_SCRIPT = void 0;
+exports.varSliceSize = varSliceSize;
+exports.vectorSize = vectorSize;
+exports.isCoinbaseHash = isCoinbaseHash;
+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 types = tslib_1.__importStar(require("../types"));
+const bscript = tslib_1.__importStar(require("../script"));
+const networks_1 = require("../networks");
+function varSliceSize(someScript) {
+    const { length } = someScript;
+    return varuint.encodingLength(length) + length;
+}
+function vectorSize(someVector) {
+    return (varuint.encodingLength(someVector.length) +
+        someVector.reduce((sum, witness) => sum + varSliceSize(witness), 0));
+}
+function isCoinbaseHash(buffer) {
+    types.typeforce(types.Hash256bit, buffer);
+    for (let i = 0; i < 32; ++i) {
+        if (buffer[i] !== 0)
+            return false;
+    }
+    return true;
+}
+exports.EMPTY_SCRIPT = Buffer.allocUnsafe(0);
+class TransactionBase {
+    constructor(options) {
+        this.version = 1;
+        this.locktime = 0;
+        this.ins = [];
+        this.outs = [];
+        this.network = options.network || networks_1.bitcoin;
+        this.specific = options.txSpecific;
+    }
+    isCoinbase() {
+        return this.ins.length === 1 && isCoinbaseHash(this.ins[0].hash);
+    }
+    hasWitnesses() {
+        return this.ins.some(x => x.witness.length !== 0);
+    }
+    isMwebPegOutTx() {
+        if (!(0, networks_1.isNetworkType)('litecoin', this.network)) {
+            return false;
+        }
+        return (this.outs.some(output => {
+            const asm = bscript.toASM(output.script);
+            return asm.startsWith('OP_8');
+        }) &&
+            this.ins.some(input => !input.script.length));
+    }
+    weight() {
+        const base = this.byteLength(false, false);
+        const total = this.byteLength(true, false);
+        return base * 3 + total;
+    }
+    virtualSize() {
+        return Math.ceil(this.weight() / 4);
+    }
+    byteLength(_ALLOW_WITNESS = true, _ALLOW_MWEB = true) {
+        const hasWitnesses = _ALLOW_WITNESS && this.hasWitnesses();
+        return ((hasWitnesses ? 10 : 8) +
+            (this.timestamp ? 4 : 0) +
+            varuint.encodingLength(this.ins.length) +
+            varuint.encodingLength(this.outs.length) +
+            this.ins.reduce((sum, input) => sum + 40 + varSliceSize(input.script), 0) +
+            this.outs.reduce((sum, output) => sum + 8 + varSliceSize(output.script), 0) +
+            (hasWitnesses
+                ? this.ins.reduce((sum, input) => sum + vectorSize(input.witness), 0)
+                : 0) +
+            (_ALLOW_MWEB && this.isMwebPegOutTx() ? 3 : 0));
+    }
+    getHash(forWitness = false, forMweb = false) {
+        if (forWitness && this.isCoinbase())
+            return Buffer.alloc(32, 0);
+        return bcrypto.hash256(this.toBuffer(undefined, undefined, forWitness, forMweb));
+    }
+    getId() {
+        return (0, bufferutils_1.reverseBuffer)(this.getHash(false)).toString('hex');
+    }
+    getWitness(index) {
+        if (!this.hasWitnesses() ||
+            !this.ins[index] ||
+            !Array.isArray(this.ins[index].witness) ||
+            this.ins[index].witness.length < 1)
+            return;
+        const { witness } = this.ins[index];
+        const chunks = witness.reduce((arr, chunk) => arr.concat([(0, bufferutils_1.getChunkSize)(chunk.length), chunk]), [(0, bufferutils_1.getChunkSize)(witness.length)]);
+        return Buffer.concat(chunks);
+    }
+    getExtraData() {
+    }
+    getSpecificData() {
+        return this.specific;
+    }
+    toBuffer(_buffer, _initialOffset, _ALLOW_WITNESS = true, _ALLOW_MWEB = true) {
+        return exports.EMPTY_SCRIPT;
+    }
+    toHex() {
+        return this.toBuffer().toString('hex');
+    }
+}
+exports.TransactionBase = TransactionBase;
+//# sourceMappingURL=base.js.map

package/third-party/utxo-lib/transaction/bitcoin.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=bitcoin.d.ts.map

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

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromConstructor = fromConstructor;
+exports.fromBuffer = fromBuffer;
+const bufferutils_1 = require("../bufferutils");
+const networks_1 = require("../networks");
+const base_1 = require("./base");
+const ADVANCED_TRANSACTION_MARKER = 0x00;
+const ADVANCED_TRANSACTION_FLAG = 0x01;
+const MWEB_PEGOUT_TX_FLAG = 0x08;
+function toBuffer(tx, buffer, initialOffset, _ALLOW_WITNESS = true, _ALLOW_MWEB = true) {
+    if (!buffer)
+        buffer = Buffer.allocUnsafe(tx.byteLength(_ALLOW_WITNESS, _ALLOW_MWEB));
+    const bufferWriter = new bufferutils_1.BufferWriter(buffer, initialOffset || 0);
+    bufferWriter.writeInt32(tx.version);
+    const hasWitnesses = _ALLOW_WITNESS && tx.hasWitnesses();
+    const hasMweb = _ALLOW_MWEB && tx.isMwebPegOutTx();
+    if (hasWitnesses) {
+        bufferWriter.writeUInt8(ADVANCED_TRANSACTION_MARKER);
+        bufferWriter.writeUInt8(ADVANCED_TRANSACTION_FLAG);
+    }
+    else if (hasMweb) {
+        bufferWriter.writeUInt8(ADVANCED_TRANSACTION_MARKER);
+        bufferWriter.writeUInt8(MWEB_PEGOUT_TX_FLAG);
+    }
+    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);
+    });
+    if (hasWitnesses) {
+        tx.ins.forEach(input => {
+            bufferWriter.writeVector(input.witness);
+        });
+    }
+    if (hasMweb) {
+        bufferWriter.writeUInt8(0);
+    }
+    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();
+    const marker = bufferReader.readUInt8();
+    const flag = bufferReader.readUInt8();
+    let hasWitnesses = false;
+    let hasMweb = false;
+    if ((0, networks_1.isNetworkType)('litecoin', tx.network)) {
+        if (marker === ADVANCED_TRANSACTION_MARKER && flag === MWEB_PEGOUT_TX_FLAG) {
+            hasMweb = true;
+        }
+    }
+    if (marker === ADVANCED_TRANSACTION_MARKER && flag === ADVANCED_TRANSACTION_FLAG) {
+        hasWitnesses = true;
+    }
+    else if (!hasMweb) {
+        bufferReader.offset -= 2;
+    }
+    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(),
+        });
+    }
+    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');
+    }
+    if (hasMweb) {
+        bufferReader.readUInt8();
+    }
+    tx.locktime = bufferReader.readUInt32();
+    if (options.nostrict)
+        return tx;
+    if (bufferReader.offset !== buffer.length)
+        throw new Error('Transaction has unexpected data');
+    return tx;
+}
+//# sourceMappingURL=bitcoin.js.map

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

@@ -0,0 +1,8 @@
+import { TransactionBase, TransactionOptions } from './base';
+export interface DashSpecific {
+    type: 'dash';
+    extraPayload?: Buffer;
+}
+export declare function fromConstructor(options: TransactionOptions): TransactionBase<DashSpecific>;
+export declare function fromBuffer(buffer: Buffer, options: TransactionOptions): TransactionBase<DashSpecific>;
+//# sourceMappingURL=dash.d.ts.map