cashscript 0.7.6 → 0.8.0-next.1

package/dist/main/utils.js

@@ -1,205 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getNetworkPrefix = exports.addressToLockScript = exports.scriptToLockingBytecode = exports.scriptToAddress = exports.meep = exports.buildError = exports.createSighashPreimage = exports.createOpReturnOutput = exports.createInputScript = exports.getTxSizeWithoutInputs = exports.getPreimageSize = exports.getInputSize = exports.validateRecipient = void 0;
-const libauth_1 = require("@bitauth/libauth");
-const utils_1 = require("@cashscript/utils");
-const interfaces_js_1 = require("./interfaces.js");
-const constants_js_1 = require("./constants.js");
-const Errors_js_1 = require("./Errors.js");
-// ////////// PARAMETER VALIDATION ////////////////////////////////////////////
-function validateRecipient(recipient) {
-    if (recipient.amount < constants_js_1.DUST_LIMIT) {
-        throw new Errors_js_1.OutputSatoshisTooSmallError(recipient.amount);
-    }
-}
-exports.validateRecipient = validateRecipient;
-// ////////// SIZE CALCULATIONS ///////////////////////////////////////////////
-function getInputSize(inputScript) {
-    const scriptSize = inputScript.byteLength;
-    const varIntSize = scriptSize > 252 ? 3 : 1;
-    return 32 + 4 + varIntSize + scriptSize + 4;
-}
-exports.getInputSize = getInputSize;
-function getPreimageSize(script) {
-    const scriptSize = script.byteLength;
-    const varIntSize = scriptSize > 252 ? 3 : 1;
-    return 4 + 32 + 32 + 36 + varIntSize + scriptSize + 8 + 4 + 32 + 4 + 4;
-}
-exports.getPreimageSize = getPreimageSize;
-function getTxSizeWithoutInputs(outputs) {
-    // Transaction format:
-    // Version (4 Bytes)
-    // TxIn Count (1 ~ 9B)
-    // For each TxIn:
-    //   Outpoint (36B)
-    //   Script Length (1 ~ 9B)
-    //   ScriptSig(?)
-    //   Sequence (4B)
-    // TxOut Count (1 ~ 9B)
-    // For each TxOut:
-    //   Value (8B)
-    //   Script Length(1 ~ 9B)*
-    //   Script (?)*
-    // LockTime (4B)
-    let size = constants_js_1.VERSION_SIZE + constants_js_1.LOCKTIME_SIZE;
-    size += outputs.reduce((acc, output) => {
-        if (typeof output.to === 'string') {
-            return acc + constants_js_1.P2PKH_OUTPUT_SIZE;
-        }
-        // Size of an OP_RETURN output = byteLength + 8 (amount) + 2 (scriptSize)
-        return acc + output.to.byteLength + 8 + 2;
-    }, 0);
-    // Add tx-out count (accounting for a potential change output)
-    size += (0, utils_1.encodeInt)(outputs.length + 1).byteLength;
-    return size;
-}
-exports.getTxSizeWithoutInputs = getTxSizeWithoutInputs;
-// ////////// BUILD OBJECTS ///////////////////////////////////////////////////
-function createInputScript(redeemScript, encodedArgs, selector, preimage) {
-    // Create unlock script / redeemScriptSig (add potential preimage and selector)
-    const unlockScript = encodedArgs.reverse();
-    if (preimage !== undefined)
-        unlockScript.push(preimage);
-    if (selector !== undefined)
-        unlockScript.push((0, utils_1.encodeInt)(selector));
-    // Create input script and compile it to bytecode
-    const inputScript = [...unlockScript, (0, utils_1.scriptToBytecode)(redeemScript)];
-    return (0, utils_1.scriptToBytecode)(inputScript);
-}
-exports.createInputScript = createInputScript;
-function createOpReturnOutput(opReturnData) {
-    const script = [
-        utils_1.Op.OP_RETURN,
-        ...opReturnData.map((output) => toBin(output)),
-    ];
-    return { to: encodeNullDataScript(script), amount: 0 };
-}
-exports.createOpReturnOutput = createOpReturnOutput;
-function toBin(output) {
-    const data = output.replace(/^0x/, '');
-    const encode = data === output ? libauth_1.utf8ToBin : libauth_1.hexToBin;
-    return encode(data);
-}
-function createSighashPreimage(transaction, input, inputIndex, coveredBytecode, hashtype) {
-    const state = (0, libauth_1.createTransactionContextCommon)({
-        inputIndex,
-        sourceOutput: { satoshis: (0, libauth_1.bigIntToBinUint64LE)(BigInt(input.satoshis)) },
-        spendingTransaction: transaction,
-    });
-    const sighashPreimage = (0, libauth_1.generateSigningSerializationBCH)({
-        correspondingOutput: state.correspondingOutput,
-        coveredBytecode,
-        forkId: new Uint8Array([0, 0, 0]),
-        locktime: state.locktime,
-        outpointIndex: state.outpointIndex,
-        outpointTransactionHash: state.outpointTransactionHash,
-        outputValue: state.outputValue,
-        sequenceNumber: state.sequenceNumber,
-        sha256: { hash: utils_1.sha256 },
-        signingSerializationType: new Uint8Array([hashtype]),
-        transactionOutpoints: state.transactionOutpoints,
-        transactionOutputs: state.transactionOutputs,
-        transactionSequenceNumbers: state.transactionSequenceNumbers,
-        version: 2,
-    });
-    return sighashPreimage;
-}
-exports.createSighashPreimage = createSighashPreimage;
-function buildError(reason, meepStr) {
-    const require = [
-        Errors_js_1.Reason.EVAL_FALSE, Errors_js_1.Reason.VERIFY, Errors_js_1.Reason.EQUALVERIFY, Errors_js_1.Reason.CHECKMULTISIGVERIFY,
-        Errors_js_1.Reason.CHECKSIGVERIFY, Errors_js_1.Reason.CHECKDATASIGVERIFY, Errors_js_1.Reason.NUMEQUALVERIFY,
-    ];
-    const timeCheck = [Errors_js_1.Reason.NEGATIVE_LOCKTIME, Errors_js_1.Reason.UNSATISFIED_LOCKTIME];
-    const sigCheck = [
-        Errors_js_1.Reason.SIG_COUNT, Errors_js_1.Reason.PUBKEY_COUNT, Errors_js_1.Reason.SIG_HASHTYPE, Errors_js_1.Reason.SIG_DER,
-        Errors_js_1.Reason.SIG_HIGH_S, Errors_js_1.Reason.SIG_NULLFAIL, Errors_js_1.Reason.SIG_BADLENGTH, Errors_js_1.Reason.SIG_NONSCHNORR,
-    ];
-    if (toRegExp(require).test(reason)) {
-        return new Errors_js_1.FailedRequireError(reason, meepStr);
-    }
-    if (toRegExp(timeCheck).test(reason)) {
-        return new Errors_js_1.FailedTimeCheckError(reason, meepStr);
-    }
-    if (toRegExp(sigCheck).test(reason)) {
-        return new Errors_js_1.FailedSigCheckError(reason, meepStr);
-    }
-    return new Errors_js_1.FailedTransactionError(reason, meepStr);
-}
-exports.buildError = buildError;
-function toRegExp(reasons) {
-    return new RegExp(reasons.join('|').replace(/\(/g, '\\(').replace(/\)/g, '\\)'));
-}
-// ////////// MISC ////////////////////////////////////////////////////////////
-function meep(tx, utxos, script) {
-    const scriptPubkey = (0, libauth_1.binToHex)(scriptToLockingBytecode(script));
-    return `meep debug --tx=${tx} --idx=0 --amt=${utxos[0].satoshis} --pkscript=${scriptPubkey}`;
-}
-exports.meep = meep;
-function scriptToAddress(script, network) {
-    const lockingBytecode = scriptToLockingBytecode(script);
-    const prefix = getNetworkPrefix(network);
-    const address = (0, libauth_1.lockingBytecodeToCashAddress)(lockingBytecode, prefix);
-    return address;
-}
-exports.scriptToAddress = scriptToAddress;
-function scriptToLockingBytecode(script) {
-    const scriptHash = (0, utils_1.hash160)((0, utils_1.scriptToBytecode)(script));
-    const addressContents = { payload: scriptHash, type: libauth_1.AddressType.p2sh };
-    const lockingBytecode = (0, libauth_1.addressContentsToLockingBytecode)(addressContents);
-    return lockingBytecode;
-}
-exports.scriptToLockingBytecode = scriptToLockingBytecode;
-/**
-* Helper function to convert an address to a locking script
-*
-* @param address   Address to convert to locking script
-*
-* @returns a locking script corresponding to the passed address
-*/
-function addressToLockScript(address) {
-    const result = (0, libauth_1.cashAddressToLockingBytecode)(address);
-    if (typeof result === 'string')
-        throw new Error(result);
-    return result.bytecode;
-}
-exports.addressToLockScript = addressToLockScript;
-function getNetworkPrefix(network) {
-    switch (network) {
-        case interfaces_js_1.Network.MAINNET:
-            return 'bitcoincash';
-        case interfaces_js_1.Network.STAGING:
-        case interfaces_js_1.Network.TESTNET4:
-        case interfaces_js_1.Network.TESTNET:
-        case interfaces_js_1.Network.TESTNET3:
-        case interfaces_js_1.Network.CHIPNET:
-            return 'bchtest';
-        case interfaces_js_1.Network.REGTEST:
-            return 'bchreg';
-        default:
-            return 'bitcoincash';
-    }
-}
-exports.getNetworkPrefix = getNetworkPrefix;
-// ////////////////////////////////////////////////////////////////////////////
-// For encoding OP_RETURN data (doesn't require BIP62.3 / MINIMALDATA)
-function encodeNullDataScript(chunks) {
-    return (0, libauth_1.flattenBinArray)(chunks.map((chunk) => {
-        if (typeof chunk === 'number') {
-            return new Uint8Array([chunk]);
-        }
-        const pushdataOpcode = getPushDataOpcode(chunk);
-        return new Uint8Array([...pushdataOpcode, ...chunk]);
-    }));
-}
-function getPushDataOpcode(data) {
-    const { byteLength } = data;
-    if (byteLength === 0)
-        return Uint8Array.from([0x4c, 0x00]);
-    if (byteLength < 76)
-        return Uint8Array.from([byteLength]);
-    if (byteLength < 256)
-        return Uint8Array.from([0x4c, byteLength]);
-    throw Error('Pushdata too large');
-}
-//# sourceMappingURL=utils.js.map

package/dist/module/Argument.d.ts

@@ -1,3 +0,0 @@
-import SignatureTemplate from './SignatureTemplate.js';
-export declare type Argument = number | bigint | boolean | string | Uint8Array | SignatureTemplate;
-export declare function encodeArgument(argument: Argument, typeStr: string): Uint8Array | SignatureTemplate;

package/dist/module/Errors.d.ts

@@ -1,66 +0,0 @@
-import { Type } from '@cashscript/utils';
-export declare class TypeError extends Error {
-    constructor(actual: string, expected: Type);
-}
-export declare class OutputSatoshisTooSmallError extends Error {
-    constructor(satoshis: number);
-}
-export declare class FailedTransactionError extends Error {
-    reason: string;
-    meep: string;
-    constructor(reason: string, meep: string);
-}
-export declare class FailedRequireError extends FailedTransactionError {
-}
-export declare class FailedTimeCheckError extends FailedTransactionError {
-}
-export declare class FailedSigCheckError extends FailedTransactionError {
-}
-export declare enum Reason {
-    EVAL_FALSE = "Script evaluated without error but finished with a false/empty top stack element",
-    VERIFY = "Script failed an OP_VERIFY operation",
-    EQUALVERIFY = "Script failed an OP_EQUALVERIFY operation",
-    CHECKMULTISIGVERIFY = "Script failed an OP_CHECKMULTISIGVERIFY operation",
-    CHECKSIGVERIFY = "Script failed an OP_CHECKSIGVERIFY operation",
-    CHECKDATASIGVERIFY = "Script failed an OP_CHECKDATASIGVERIFY operation",
-    NUMEQUALVERIFY = "Script failed an OP_NUMEQUALVERIFY operation",
-    SCRIPT_SIZE = "Script is too big",
-    PUSH_SIZE = "Push value size limit exceeded",
-    OP_COUNT = "Operation limit exceeded",
-    STACK_SIZE = "Stack size limit exceeded",
-    SIG_COUNT = "Signature count negative or greater than pubkey count",
-    PUBKEY_COUNT = "Pubkey count negative or limit exceeded",
-    INVALID_OPERAND_SIZE = "Invalid operand size",
-    INVALID_NUMBER_RANGE = "Given operand is not a number within the valid range",
-    IMPOSSIBLE_ENCODING = "The requested encoding is impossible to satisfy",
-    INVALID_SPLIT_RANGE = "Invalid OP_SPLIT range",
-    INVALID_BIT_COUNT = "Invalid number of bit set in OP_CHECKMULTISIG",
-    BAD_OPCODE = "Opcode missing or not understood",
-    DISABLED_OPCODE = "Attempted to use a disabled opcode",
-    INVALID_STACK_OPERATION = "Operation not valid with the current stack size",
-    INVALID_ALTSTACK_OPERATION = "Operation not valid with the current altstack size",
-    OP_RETURN = "OP_RETURN was encountered",
-    UNBALANCED_CONDITIONAL = "Invalid OP_IF construction",
-    DIV_BY_ZERO = "Division by zero error",
-    MOD_BY_ZERO = "Modulo by zero error",
-    INVALID_BITFIELD_SIZE = "Bitfield of unexpected size error",
-    INVALID_BIT_RANGE = "Bitfield's bit out of the expected range",
-    NEGATIVE_LOCKTIME = "Negative locktime",
-    UNSATISFIED_LOCKTIME = "Locktime requirement not satisfied",
-    SIG_HASHTYPE = "Signature hash type missing or not understood",
-    SIG_DER = "Non-canonical DER signature",
-    MINIMALDATA = "Data push larger than necessary",
-    SIG_PUSHONLY = "Only push operators allowed in signature scripts",
-    SIG_HIGH_S = "Non-canonical signature: S value is unnecessarily high",
-    MINIMALIF = "OP_IF/NOTIF argument must be minimal",
-    SIG_NULLFAIL = "Signature must be zero for failed CHECK(MULTI)SIG operation",
-    SIG_BADLENGTH = "Signature cannot be 65 bytes in CHECKMULTISIG",
-    SIG_NONSCHNORR = "Only Schnorr signatures allowed in this operation",
-    DISCOURAGE_UPGRADABLE_NOPS = "NOPx reserved for soft-fork upgrades",
-    PUBKEYTYPE = "Public key is neither compressed or uncompressed",
-    CLEANSTACK = "Script did not clean its stack",
-    NONCOMPRESSED_PUBKEY = "Using non-compressed public key",
-    ILLEGAL_FORKID = "Illegal use of SIGHASH_FORKID",
-    MUST_USE_FORKID = "Signature must use SIGHASH_FORKID",
-    UNKNOWN = "unknown error"
-}

package/dist/module/SignatureTemplate.d.ts

@@ -1,15 +0,0 @@
-import { Secp256k1 } from '@bitauth/libauth';
-import { HashType, SignatureAlgorithm } from './interfaces.js';
-export default class SignatureTemplate {
-    private hashtype;
-    private signatureAlgorithm;
-    private privateKey;
-    constructor(signer: Keypair | Uint8Array | string, hashtype?: HashType, signatureAlgorithm?: SignatureAlgorithm);
-    generateSignature(payload: Uint8Array, secp256k1: Secp256k1, bchForkId?: boolean): Uint8Array;
-    getHashType(bchForkId?: boolean): number;
-    getPublicKey(secp256k1: Secp256k1): Uint8Array;
-}
-interface Keypair {
-    toWIF(): string;
-}
-export {};

package/dist/module/Transaction.js

@@ -1,251 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { bigIntToBinUint64LE, hexToBin, binToHex, encodeTransaction, addressContentsToLockingBytecode, AddressType, decodeTransaction, instantiateSecp256k1, } from '@bitauth/libauth';
-import delay from 'delay';
-import { hash160, hash256, placeholder, scriptToBytecode, } from '@cashscript/utils';
-import { isSignableUtxo, } from './interfaces.js';
-import { meep, createInputScript, getInputSize, createOpReturnOutput, getTxSizeWithoutInputs, getPreimageSize, buildError, addressToLockScript, createSighashPreimage, validateRecipient, } from './utils.js';
-import { P2SH_OUTPUT_SIZE, DUST_LIMIT } from './constants.js';
-import SignatureTemplate from './SignatureTemplate.js';
-const bip68 = require('bip68');
-export class Transaction {
-    constructor(address, provider, redeemScript, abiFunction, args, selector) {
-        this.address = address;
-        this.provider = provider;
-        this.redeemScript = redeemScript;
-        this.abiFunction = abiFunction;
-        this.args = args;
-        this.selector = selector;
-        this.inputs = [];
-        this.outputs = [];
-        this.sequence = 0xfffffffe;
-        this.feePerByte = 1.0;
-        this.minChange = DUST_LIMIT;
-    }
-    from(inputOrInputs) {
-        if (!Array.isArray(inputOrInputs)) {
-            inputOrInputs = [inputOrInputs];
-        }
-        this.inputs = this.inputs.concat(inputOrInputs);
-        return this;
-    }
-    experimentalFromP2PKH(inputOrInputs, template) {
-        if (!Array.isArray(inputOrInputs)) {
-            inputOrInputs = [inputOrInputs];
-        }
-        inputOrInputs = inputOrInputs.map((input) => (Object.assign(Object.assign({}, input), { template })));
-        this.inputs = this.inputs.concat(inputOrInputs);
-        return this;
-    }
-    to(toOrOutputs, amount) {
-        if (typeof toOrOutputs === 'string' && typeof amount === 'number') {
-            return this.to([{ to: toOrOutputs, amount }]);
-        }
-        if (Array.isArray(toOrOutputs) && amount === undefined) {
-            toOrOutputs.forEach(validateRecipient);
-            this.outputs = this.outputs.concat(toOrOutputs);
-            return this;
-        }
-        throw new Error('Incorrect arguments passed to function \'to\'');
-    }
-    withOpReturn(chunks) {
-        this.outputs.push(createOpReturnOutput(chunks));
-        return this;
-    }
-    withAge(age) {
-        this.sequence = bip68.encode({ blocks: age });
-        return this;
-    }
-    withTime(time) {
-        this.locktime = time;
-        return this;
-    }
-    withHardcodedFee(hardcodedFee) {
-        this.hardcodedFee = hardcodedFee;
-        return this;
-    }
-    withFeePerByte(feePerByte) {
-        this.feePerByte = feePerByte;
-        return this;
-    }
-    withMinChange(minChange) {
-        this.minChange = minChange;
-        return this;
-    }
-    withoutChange() {
-        return this.withMinChange(Number.MAX_VALUE);
-    }
-    build() {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            this.locktime = (_a = this.locktime) !== null && _a !== void 0 ? _a : yield this.provider.getBlockHeight();
-            yield this.setInputsAndOutputs();
-            const secp256k1 = yield instantiateSecp256k1();
-            const bytecode = scriptToBytecode(this.redeemScript);
-            const inputs = this.inputs.map((utxo) => ({
-                outpointIndex: utxo.vout,
-                outpointTransactionHash: hexToBin(utxo.txid),
-                sequenceNumber: this.sequence,
-                unlockingBytecode: new Uint8Array(),
-            }));
-            const outputs = this.outputs.map((output) => {
-                const lockingBytecode = typeof output.to === 'string'
-                    ? addressToLockScript(output.to)
-                    : output.to;
-                const satoshis = bigIntToBinUint64LE(BigInt(output.amount));
-                return { lockingBytecode, satoshis };
-            });
-            const transaction = {
-                inputs,
-                locktime: this.locktime,
-                outputs,
-                version: 2,
-            };
-            const inputScripts = [];
-            this.inputs.forEach((utxo, i) => {
-                // UTXO's with signature templates are signed using P2PKH
-                if (isSignableUtxo(utxo)) {
-                    const pubkey = utxo.template.getPublicKey(secp256k1);
-                    const pubkeyHash = hash160(pubkey);
-                    const addressContents = { payload: pubkeyHash, type: AddressType.p2pkh };
-                    const prevOutScript = addressContentsToLockingBytecode(addressContents);
-                    const hashtype = utxo.template.getHashType();
-                    const preimage = createSighashPreimage(transaction, utxo, i, prevOutScript, hashtype);
-                    const sighash = hash256(preimage);
-                    const signature = utxo.template.generateSignature(sighash, secp256k1);
-                    const inputScript = scriptToBytecode([signature, pubkey]);
-                    inputScripts.push(inputScript);
-                    return;
-                }
-                let covenantHashType = -1;
-                const completeArgs = this.args.map((arg) => {
-                    if (!(arg instanceof SignatureTemplate))
-                        return arg;
-                    // First signature is used for sighash preimage (maybe not the best way)
-                    if (covenantHashType < 0)
-                        covenantHashType = arg.getHashType();
-                    const preimage = createSighashPreimage(transaction, utxo, i, bytecode, arg.getHashType());
-                    const sighash = hash256(preimage);
-                    return arg.generateSignature(sighash, secp256k1);
-                });
-                const preimage = this.abiFunction.covenant
-                    ? createSighashPreimage(transaction, utxo, i, bytecode, covenantHashType)
-                    : undefined;
-                const inputScript = createInputScript(this.redeemScript, completeArgs, this.selector, preimage);
-                inputScripts.push(inputScript);
-            });
-            inputScripts.forEach((script, i) => {
-                transaction.inputs[i].unlockingBytecode = script;
-            });
-            return binToHex(encodeTransaction(transaction));
-        });
-    }
-    send(raw) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const tx = yield this.build();
-            try {
-                const txid = yield this.provider.sendRawTransaction(tx);
-                return raw ? yield this.getTxDetails(txid, raw) : yield this.getTxDetails(txid);
-            }
-            catch (e) {
-                const reason = (_a = e.error) !== null && _a !== void 0 ? _a : e.message;
-                throw buildError(reason, meep(tx, this.inputs, this.redeemScript));
-            }
-        });
-    }
-    getTxDetails(txid, raw) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (let retries = 0; retries < 1200; retries += 1) {
-                yield delay(500);
-                try {
-                    const hex = yield this.provider.getRawTransaction(txid);
-                    if (raw)
-                        return hex;
-                    const libauthTransaction = decodeTransaction(hexToBin(hex));
-                    return Object.assign(Object.assign({}, libauthTransaction), { txid, hex });
-                }
-                catch (ignored) {
-                    // ignored
-                }
-            }
-            // Should not happen
-            throw new Error('Could not retrieve transaction details for over 10 minutes');
-        });
-    }
-    meep() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const tx = yield this.build();
-            return meep(tx, this.inputs, this.redeemScript);
-        });
-    }
-    setInputsAndOutputs() {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.outputs.length === 0) {
-                throw Error('Attempted to build a transaction without outputs');
-            }
-            // Replace all SignatureTemplate with 65-length placeholder Uint8Arrays
-            const placeholderArgs = this.args.map((arg) => (arg instanceof SignatureTemplate ? placeholder(65) : arg));
-            // Create a placeholder preimage of the correct size
-            const placeholderPreimage = this.abiFunction.covenant
-                ? placeholder(getPreimageSize(scriptToBytecode(this.redeemScript)))
-                : undefined;
-            // Create a placeholder input script for size calculation using the placeholder
-            // arguments and correctly sized placeholder preimage
-            const placeholderScript = createInputScript(this.redeemScript, placeholderArgs, this.selector, placeholderPreimage);
-            // Add one extra byte per input to over-estimate tx-in count
-            const inputSize = getInputSize(placeholderScript) + 1;
-            // Calculate amount to send and base fee (excluding additional fees per UTXO)
-            const amount = this.outputs.reduce((acc, output) => acc + output.amount, 0);
-            let fee = (_a = this.hardcodedFee) !== null && _a !== void 0 ? _a : getTxSizeWithoutInputs(this.outputs) * this.feePerByte;
-            // Select and gather UTXOs and calculate fees and available funds
-            let satsAvailable = 0;
-            if (this.inputs.length > 0) {
-                // If inputs are already defined, the user provided the UTXOs
-                // and we perform no further UTXO selection
-                if (!this.hardcodedFee)
-                    fee += this.inputs.length * inputSize * this.feePerByte;
-                satsAvailable = this.inputs.reduce((acc, input) => acc + input.satoshis, 0);
-            }
-            else {
-                // If inputs are not defined yet, we retrieve the contract's UTXOs and perform selection
-                const utxos = yield this.provider.getUtxos(this.address);
-                // We sort the UTXOs mainly so there is consistent behaviour between network providers
-                // even if they report UTXOs in a different order
-                utxos.sort((a, b) => b.satoshis - a.satoshis);
-                for (const utxo of utxos) {
-                    this.inputs.push(utxo);
-                    satsAvailable += utxo.satoshis;
-                    if (!this.hardcodedFee)
-                        fee += inputSize * this.feePerByte;
-                    if (satsAvailable > amount + fee)
-                        break;
-                }
-            }
-            // Fee per byte can be a decimal number, but we need the total fee to be an integer
-            fee = Math.ceil(fee);
-            // Calculate change and check available funds
-            let change = satsAvailable - amount - fee;
-            if (change < 0) {
-                throw new Error(`Insufficient funds: available (${satsAvailable}) < needed (${amount + fee}).`);
-            }
-            // Account for the fee of a change output
-            if (!this.hardcodedFee) {
-                change -= P2SH_OUTPUT_SIZE;
-            }
-            // Add a change output if applicable
-            if (change >= DUST_LIMIT && change >= this.minChange) {
-                this.outputs.push({ to: this.address, amount: change });
-            }
-        });
-    }
-}
-//# sourceMappingURL=Transaction.js.map

package/dist/module/constants.d.ts

@@ -1,5 +0,0 @@
-export declare const DUST_LIMIT = 546;
-export declare const P2PKH_OUTPUT_SIZE = 34;
-export declare const P2SH_OUTPUT_SIZE = 32;
-export declare const VERSION_SIZE = 4;
-export declare const LOCKTIME_SIZE = 4;

package/dist/module/constants.js

@@ -1,6 +0,0 @@
-export const DUST_LIMIT = 546;
-export const P2PKH_OUTPUT_SIZE = 34;
-export const P2SH_OUTPUT_SIZE = 32;
-export const VERSION_SIZE = 4;
-export const LOCKTIME_SIZE = 4;
-//# sourceMappingURL=constants.js.map

package/dist/module/index.d.ts

@@ -1,10 +0,0 @@
-import SignatureTemplate from './SignatureTemplate.js';
-export { SignatureTemplate };
-export { Contract, ContractFunction } from './Contract.js';
-export { Transaction } from './Transaction.js';
-export { Argument } from './Argument.js';
-export { Artifact, AbiFunction, AbiInput } from '@cashscript/utils';
-export * as utils from '@cashscript/utils';
-export { Utxo, Recipient, SignatureAlgorithm, HashType, Network, } from './interfaces.js';
-export * from './Errors.js';
-export { NetworkProvider, BitboxNetworkProvider, BitcoinRpcNetworkProvider, ElectrumNetworkProvider, FullStackNetworkProvider, } from './network/index.js';

package/dist/module/network/BitboxNetworkProvider.d.ts

@@ -1,26 +0,0 @@
-import { Utxo, Network } from '../interfaces.js';
-import NetworkProvider from './NetworkProvider.js';
-export default class BitboxNetworkProvider implements NetworkProvider {
-    network: Network;
-    private bitbox;
-    constructor(network: Network, bitbox: BITBOX);
-    getUtxos(address: string): Promise<Utxo[]>;
-    getBlockHeight(): Promise<number>;
-    getRawTransaction(txid: string): Promise<string>;
-    sendRawTransaction(txHex: string): Promise<string>;
-}
-interface BITBOX {
-    Address: {
-        utxo(address: string): Promise<{
-            utxos: Utxo[];
-        }>;
-    };
-    Blockchain: {
-        getBlockCount(): Promise<number>;
-    };
-    RawTransactions: {
-        getRawTransaction(txid: string): Promise<string>;
-        sendRawTransaction(txHex: string): Promise<string>;
-    };
-}
-export {};

package/dist/module/network/BitboxNetworkProvider.js

@@ -1,37 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-export default class BitboxNetworkProvider {
-    constructor(network, bitbox) {
-        this.network = network;
-        this.bitbox = bitbox;
-    }
-    getUtxos(address) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { utxos } = yield this.bitbox.Address.utxo(address);
-            return utxos;
-        });
-    }
-    getBlockHeight() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.bitbox.Blockchain.getBlockCount();
-        });
-    }
-    getRawTransaction(txid) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.bitbox.RawTransactions.getRawTransaction(txid);
-        });
-    }
-    sendRawTransaction(txHex) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.bitbox.RawTransactions.sendRawTransaction(txHex);
-        });
-    }
-}
-//# sourceMappingURL=BitboxNetworkProvider.js.map