cashscript 0.7.6 → 0.8.0-next.1

package/README.md

@@ -1,6 +1,6 @@
 # CashScript
 
-[![Build Status](https://travis-ci.org/Bitcoin-com/cashscript.svg)](https://travis-ci.org/Bitcoin-com/cashscript)
+![Build Status](https://github.com/CashScript/cashscript/actions/workflows/github-actions.yml/badge.svg)
 [![Coverage Status](https://img.shields.io/codecov/c/github/Bitcoin-com/cashscript.svg)](https://codecov.io/gh/Bitcoin-com/cashscript/)
 [![NPM Version](https://img.shields.io/npm/v/cashscript.svg)](https://www.npmjs.com/package/cashscript)
 [![NPM Monthly Downloads](https://img.shields.io/npm/dm/cashscript.svg)](https://www.npmjs.com/package/cashscript)
@@ -26,16 +26,12 @@ npm install cashscript
 import { Contract, ... } from 'cashscript';
 ```
 
-```js
-const { Contract, ... } = require('cashscript');
-```
-
 Using the CashScript SDK, you can import contract artifact files, create new instances of these contracts, and interact with these instances:
 
 ```ts
 ...
   // Import the P2PKH artifact
-  const P2PKH = require('./p2pkh-artifact.json');
+  import P2PKH from './p2pkh-artifact.json' assert { type: 'json' };
 
   // Instantiate a network provider for CashScript's network operations
   const provider = new ElectrumNetworkProvider('mainnet');

package/dist/{main/Argument.d.ts → Argument.d.ts}

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

package/dist/{module/Argument.js → Argument.js}

@@ -11,7 +11,7 @@ export function encodeArgument(argument, typeStr) {
         return encodeBool(argument);
     }
     if (type === PrimitiveType.INT) {
-        if (typeof argument !== 'number' && typeof argument !== 'bigint') {
+        if (typeof argument !== 'bigint') {
             throw new TypeError(typeof argument, type);
         }
         return encodeInt(argument);

package/dist/{module/Contract.d.ts → Contract.d.ts}

@@ -1,23 +1,25 @@
 import { Artifact } from '@cashscript/utils';
 import { Transaction } from './Transaction.js';
 import { Argument } from './Argument.js';
-import { Utxo } from './interfaces.js';
-import NetworkProvider from './network/NetworkProvider.js';
+import { ContractOptions, Utxo } from './interfaces.js';
 export declare class Contract {
     private artifact;
-    private provider;
+    private options?;
     name: string;
     address: string;
+    tokenAddress: string;
+    bytecode: string;
     bytesize: number;
     opcount: number;
     functions: {
         [name: string]: ContractFunction;
     };
     private redeemScript;
-    constructor(artifact: Artifact, constructorArgs: Argument[], provider?: NetworkProvider);
-    getBalance(): Promise<number>;
+    private provider;
+    private addressType;
+    constructor(artifact: Artifact, constructorArgs: Argument[], options?: ContractOptions | undefined);
+    getBalance(): Promise<bigint>;
     getUtxos(): Promise<Utxo[]>;
-    getRedeemScriptHex(): string;
     private createFunction;
 }
 export declare type ContractFunction = (...args: Argument[]) => Transaction;

package/dist/{module/Contract.js → Contract.js}

@@ -1,23 +1,18 @@
-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 { binToHex } from '@bitauth/libauth';
 import { asmToScript, calculateBytesize, countOpcodes, generateRedeemScript, scriptToBytecode, } from '@cashscript/utils';
 import { Transaction } from './Transaction.js';
 import { encodeArgument } from './Argument.js';
-import { scriptToAddress, } from './utils.js';
+import { scriptToAddress } from './utils.js';
 import SignatureTemplate from './SignatureTemplate.js';
 import { ElectrumNetworkProvider } from './network/index.js';
 export class Contract {
-    constructor(artifact, constructorArgs, provider = new ElectrumNetworkProvider()) {
+    constructor(artifact, constructorArgs, options) {
         this.artifact = artifact;
-        this.provider = provider;
+        this.options = options;
+        const defaultProvider = new ElectrumNetworkProvider();
+        const defaultAddressType = 'p2sh32';
+        this.provider = this.options?.provider ?? defaultProvider;
+        this.addressType = this.options?.addressType ?? defaultAddressType;
         const expectedProperties = ['abi', 'bytecode', 'constructorInputs', 'contractName'];
         if (!expectedProperties.every((property) => property in artifact)) {
             throw new Error('Invalid or incomplete artifact provided');
@@ -47,23 +42,18 @@ export class Contract {
             });
         }
         this.name = artifact.contractName;
-        this.address = scriptToAddress(this.redeemScript, this.provider.network);
+        this.address = scriptToAddress(this.redeemScript, this.provider.network, this.addressType, false);
+        this.tokenAddress = scriptToAddress(this.redeemScript, this.provider.network, this.addressType, true);
+        this.bytecode = binToHex(scriptToBytecode(this.redeemScript));
         this.bytesize = calculateBytesize(this.redeemScript);
         this.opcount = countOpcodes(this.redeemScript);
     }
-    getBalance() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const utxos = yield this.getUtxos();
-            return utxos.reduce((acc, utxo) => acc + utxo.satoshis, 0);
-        });
+    async getBalance() {
+        const utxos = await this.getUtxos();
+        return utxos.reduce((acc, utxo) => acc + utxo.satoshis, 0n);
     }
-    getUtxos() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.provider.getUtxos(this.address);
-        });
-    }
-    getRedeemScriptHex() {
-        return binToHex(scriptToBytecode(this.redeemScript));
+    async getUtxos() {
+        return this.provider.getUtxos(this.address);
     }
     createFunction(abiFunction, selector) {
         return (...args) => {

package/dist/{main/Errors.d.ts → Errors.d.ts}

@@ -3,7 +3,10 @@ export declare class TypeError extends Error {
     constructor(actual: string, expected: Type);
 }
 export declare class OutputSatoshisTooSmallError extends Error {
-    constructor(satoshis: number);
+    constructor(satoshis: bigint, minimumAmount: bigint);
+}
+export declare class TokensToNonTokenAddressError extends Error {
+    constructor(address: string);
 }
 export declare class FailedTransactionError extends Error {
     reason: string;

package/dist/{module/Errors.js → Errors.js}

@@ -1,12 +1,16 @@
-import { DUST_LIMIT } from './constants.js';
 export class TypeError extends Error {
     constructor(actual, expected) {
         super(`Found type '${actual}' where type '${expected.toString()}' was expected`);
     }
 }
 export class OutputSatoshisTooSmallError extends Error {
-    constructor(satoshis) {
-        super(`Tried to add an output with ${satoshis} satoshis, which is less than the DUST limit (${DUST_LIMIT})`);
+    constructor(satoshis, minimumAmount) {
+        super(`Tried to add an output with ${satoshis} satoshis, which is less than the required minimum for this output-type (${minimumAmount})`);
+    }
+}
+export class TokensToNonTokenAddressError extends Error {
+    constructor(address) {
+        super(`Tried to send tokens to an address without token support, ${address}.`);
     }
 }
 export class FailedTransactionError extends Error {

package/dist/{main/SignatureTemplate.d.ts → SignatureTemplate.d.ts}

@@ -1,13 +1,12 @@
-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;
+    generateSignature(payload: Uint8Array, bchForkId?: boolean): Uint8Array;
     getHashType(bchForkId?: boolean): number;
-    getPublicKey(secp256k1: Secp256k1): Uint8Array;
+    getPublicKey(): Uint8Array;
 }
 interface Keypair {
     toWIF(): string;

package/dist/{module/SignatureTemplate.js → SignatureTemplate.js}

@@ -1,5 +1,4 @@
-import { decodePrivateKeyWif, SigningSerializationFlag } from '@bitauth/libauth';
-import { sha256 } from '@cashscript/utils';
+import { decodePrivateKeyWif, secp256k1, SigningSerializationFlag } from '@bitauth/libauth';
 import { HashType, SignatureAlgorithm } from './interfaces.js';
 export default class SignatureTemplate {
     constructor(signer, hashtype = HashType.SIGHASH_ALL, signatureAlgorithm = SignatureAlgorithm.SCHNORR) {
@@ -16,7 +15,7 @@ export default class SignatureTemplate {
             this.privateKey = signer;
         }
     }
-    generateSignature(payload, secp256k1, bchForkId) {
+    generateSignature(payload, bchForkId) {
         const signature = this.signatureAlgorithm === SignatureAlgorithm.SCHNORR
             ? secp256k1.signMessageHashSchnorr(this.privateKey, payload)
             : secp256k1.signMessageHashDER(this.privateKey, payload);
@@ -25,7 +24,7 @@ export default class SignatureTemplate {
     getHashType(bchForkId = true) {
         return bchForkId ? (this.hashtype | SigningSerializationFlag.forkId) : this.hashtype;
     }
-    getPublicKey(secp256k1) {
+    getPublicKey() {
         return secp256k1.derivePublicKeyCompressed(this.privateKey);
     }
 }
@@ -33,7 +32,7 @@ function isKeypair(obj) {
     return typeof obj.toWIF === 'function';
 }
 function decodeWif(wif) {
-    const result = decodePrivateKeyWif({ hash: sha256 }, wif);
+    const result = decodePrivateKeyWif(wif);
     if (typeof result === 'string') {
         throw new Error(result);
     }

package/dist/{module/Transaction.d.ts → Transaction.d.ts}

@@ -1,5 +1,5 @@
 import { AbiFunction, Script } from '@cashscript/utils';
-import { Utxo, Recipient, TransactionDetails } from './interfaces.js';
+import { Utxo, Recipient, TokenDetails, TransactionDetails } from './interfaces.js';
 import NetworkProvider from './network/NetworkProvider.js';
 import SignatureTemplate from './SignatureTemplate.js';
 export declare class Transaction {
@@ -13,23 +13,25 @@ export declare class Transaction {
     private outputs;
     private sequence;
     private locktime;
-    private hardcodedFee;
     private feePerByte;
+    private hardcodedFee;
     private minChange;
+    private tokenChange;
     constructor(address: string, provider: NetworkProvider, redeemScript: Script, abiFunction: AbiFunction, args: (Uint8Array | SignatureTemplate)[], selector?: number | undefined);
     from(input: Utxo): this;
     from(inputs: Utxo[]): this;
     experimentalFromP2PKH(input: Utxo, template: SignatureTemplate): this;
     experimentalFromP2PKH(inputs: Utxo[], template: SignatureTemplate): this;
-    to(to: string, amount: number): this;
+    to(to: string, amount: bigint, token?: TokenDetails): this;
     to(outputs: Recipient[]): this;
     withOpReturn(chunks: string[]): this;
     withAge(age: number): this;
     withTime(time: number): this;
-    withHardcodedFee(hardcodedFee: number): this;
+    withHardcodedFee(hardcodedFee: bigint): this;
     withFeePerByte(feePerByte: number): this;
-    withMinChange(minChange: number): this;
+    withMinChange(minChange: bigint): this;
     withoutChange(): this;
+    withoutTokenChange(): this;
     build(): Promise<string>;
     send(): Promise<TransactionDetails>;
     send(raw: true): Promise<string>;

package/dist/Transaction.js

@@ -0,0 +1,352 @@
+import { hexToBin, binToHex, encodeTransaction, addressContentsToLockingBytecode, decodeTransaction, LockingBytecodeType, } 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, createSighashPreimage, validateRecipient, utxoComparator, cashScriptOutputToLibauthOutput, calculateDust, getOutputSize, } from './utils.js';
+import SignatureTemplate from './SignatureTemplate.js';
+const bip68 = await import('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 = 0n;
+        this.tokenChange = true;
+    }
+    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) => ({ ...input, template }));
+        this.inputs = this.inputs.concat(inputOrInputs);
+        return this;
+    }
+    to(toOrOutputs, amount, token) {
+        if (typeof toOrOutputs === 'string' && typeof amount === 'bigint') {
+            const recipient = { to: toOrOutputs, amount, token };
+            return this.to([recipient]);
+        }
+        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(BigInt(Number.MAX_VALUE));
+    }
+    withoutTokenChange() {
+        this.tokenChange = false;
+        return this;
+    }
+    async build() {
+        this.locktime = this.locktime ?? await this.provider.getBlockHeight();
+        await this.setInputsAndOutputs();
+        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(cashScriptOutputToLibauthOutput);
+        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();
+                const pubkeyHash = hash160(pubkey);
+                const addressContents = { payload: pubkeyHash, type: LockingBytecodeType.p2pkh };
+                const prevOutScript = addressContentsToLockingBytecode(addressContents);
+                const hashtype = utxo.template.getHashType();
+                const preimage = createSighashPreimage(transaction, this.inputs, i, prevOutScript, hashtype);
+                const sighash = hash256(preimage);
+                const signature = utxo.template.generateSignature(sighash);
+                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, this.inputs, i, bytecode, arg.getHashType());
+                const sighash = hash256(preimage);
+                return arg.generateSignature(sighash);
+            });
+            const preimage = this.abiFunction.covenant
+                ? createSighashPreimage(transaction, this.inputs, 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));
+    }
+    async send(raw) {
+        const tx = await this.build();
+        try {
+            const txid = await this.provider.sendRawTransaction(tx);
+            return raw ? await this.getTxDetails(txid, raw) : await this.getTxDetails(txid);
+        }
+        catch (e) {
+            const reason = e.error ?? e.message;
+            throw buildError(reason, meep(tx, this.inputs, this.redeemScript));
+        }
+    }
+    async getTxDetails(txid, raw) {
+        for (let retries = 0; retries < 1200; retries += 1) {
+            await delay(500);
+            try {
+                const hex = await this.provider.getRawTransaction(txid);
+                if (raw)
+                    return hex;
+                const libauthTransaction = decodeTransaction(hexToBin(hex));
+                return { ...libauthTransaction, txid, hex };
+            }
+            catch (ignored) {
+                // ignored
+            }
+        }
+        // Should not happen
+        throw new Error('Could not retrieve transaction details for over 10 minutes');
+    }
+    async meep() {
+        const tx = await this.build();
+        return meep(tx, this.inputs, this.redeemScript);
+    }
+    async setInputsAndOutputs() {
+        if (this.outputs.length === 0) {
+            throw Error('Attempted to build a transaction without outputs');
+        }
+        // Construct object with total output of fungible tokens by tokenId
+        const netBalanceTokens = {};
+        // Construct list with all nfts in inputs
+        const listNftsInputs = [];
+        // If inputs are manually selected, add their tokens to balance
+        for (const input of this.inputs) {
+            if (!input.token)
+                continue;
+            const tokenCategory = input.token.category;
+            if (!netBalanceTokens[tokenCategory]) {
+                netBalanceTokens[tokenCategory] = input.token.amount;
+            }
+            else {
+                netBalanceTokens[tokenCategory] += input.token.amount;
+            }
+            if (input.token.nft) {
+                listNftsInputs.push({ ...input.token.nft, category: input.token.category });
+            }
+        }
+        // Construct list with all nfts in outputs
+        let listNftsOutputs = [];
+        // Subtract all token outputs from the token balances
+        for (const output of this.outputs) {
+            if (!output.token)
+                continue;
+            const tokenCategory = output.token.category;
+            if (!netBalanceTokens[tokenCategory]) {
+                netBalanceTokens[tokenCategory] = -output.token.amount;
+            }
+            else {
+                netBalanceTokens[tokenCategory] -= output.token.amount;
+            }
+            if (output.token.nft) {
+                listNftsOutputs.push({ ...output.token.nft, category: output.token.category });
+            }
+        }
+        // If inputs are manually provided, check token balances
+        if (this.inputs.length > 0) {
+            for (const [category, balance] of Object.entries(netBalanceTokens)) {
+                // Add token change outputs if applicable
+                if (this.tokenChange && balance > 0) {
+                    const tokenDetails = {
+                        category,
+                        amount: balance,
+                    };
+                    const tokenChangeOutput = { to: this.address, amount: BigInt(1000), token: tokenDetails };
+                    this.outputs.push(tokenChangeOutput);
+                }
+                // Throw error when token balance is insufficient
+                if (balance < 0) {
+                    throw new Error(`Insufficient token balance for token with category ${category}.`);
+                }
+            }
+            // Compare nfts in- and outputs, check if inputs have nfts corresponding to outputs
+            // Keep list of nfts in inputs without matching output
+            // First check immutable nfts, then mutable & minting nfts together
+            // this is so the mutable nft in input does not get match to an output nft corresponding to an immutable nft in the inputs
+            let unusedNfts = listNftsInputs;
+            for (const nftInput of listNftsInputs) {
+                if (nftInput.capability === 'none') {
+                    for (let i = 0; i < listNftsOutputs.length; i++) {
+                        // Deep equality check token objects
+                        if (JSON.stringify(listNftsOutputs[i]) === JSON.stringify(nftInput)) {
+                            listNftsOutputs.splice(i, 1);
+                            unusedNfts = unusedNfts.filter((nft) => nft !== nftInput);
+                            break;
+                        }
+                    }
+                }
+            }
+            for (const nftInput of listNftsInputs) {
+                if (nftInput.capability === 'minting') {
+                    const newListNftsOutputs = listNftsOutputs.filter((nftOutput) => nftOutput.category !== nftInput.category);
+                    if (newListNftsOutputs !== listNftsOutputs) {
+                        unusedNfts = unusedNfts.filter((nft) => nft !== nftInput);
+                        listNftsOutputs = newListNftsOutputs;
+                    }
+                }
+                if (nftInput.capability === 'mutable') {
+                    for (let i = 0; i < listNftsOutputs.length; i++) {
+                        if (listNftsOutputs[i].category === nftInput.category) {
+                            listNftsOutputs.splice(i, 1);
+                            unusedNfts = unusedNfts.filter((nft) => nft !== nftInput);
+                            break;
+                        }
+                    }
+                }
+            }
+            if (listNftsOutputs.length !== 0) {
+                throw new Error('Nfts in outputs don\'t have corresponding nfts in inputs!');
+            }
+            if (this.tokenChange) {
+                for (const unusedNft of unusedNfts) {
+                    const tokenDetails = {
+                        category: unusedNft.category,
+                        amount: BigInt(0),
+                        nft: {
+                            capability: unusedNft.capability,
+                            commitment: unusedNft.commitment,
+                        },
+                    };
+                    const nftChangeOutput = { to: this.address, amount: BigInt(1000), token: tokenDetails };
+                    this.outputs.push(nftChangeOutput);
+                }
+            }
+        }
+        // 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;
+        // Note that we use the addPrecision function to add "decimal points" to BigInt numbers
+        // Calculate amount to send and base fee (excluding additional fees per UTXO)
+        let amount = addPrecision(this.outputs.reduce((acc, output) => acc + output.amount, 0n));
+        let fee = addPrecision(this.hardcodedFee ?? getTxSizeWithoutInputs(this.outputs) * this.feePerByte);
+        // Select and gather UTXOs and calculate fees and available funds
+        let satsAvailable = 0n;
+        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 += addPrecision(this.inputs.length * inputSize * this.feePerByte);
+            satsAvailable = addPrecision(this.inputs.reduce((acc, input) => acc + input.satoshis, 0n));
+        }
+        else {
+            // If inputs are not defined yet, we retrieve the contract's UTXOs and perform selection
+            const utxos = await 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(utxoComparator).reverse();
+            for (const utxo of utxos) {
+                this.inputs.push(utxo);
+                satsAvailable += addPrecision(utxo.satoshis);
+                if (!this.hardcodedFee)
+                    fee += addPrecision(inputSize * this.feePerByte);
+                if (satsAvailable > amount + fee)
+                    break;
+            }
+        }
+        // Remove "decimal points" from BigInt numbers (rounding up for fee, down for others)
+        satsAvailable = removePrecisionFloor(satsAvailable);
+        amount = removePrecisionFloor(amount);
+        fee = removePrecisionCeil(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 adding a change output
+        if (!this.hardcodedFee) {
+            const changeOutputSize = getOutputSize({ to: this.address, amount: 0n });
+            change -= BigInt(changeOutputSize * this.feePerByte);
+        }
+        // Add a change output if applicable
+        const changeOutput = { to: this.address, amount: change };
+        if (change >= this.minChange && change >= calculateDust(changeOutput)) {
+            this.outputs.push(changeOutput);
+        }
+    }
+}
+// Note: the below is a very simple implementation of a "decimal point" system for BigInt numbers
+// It is safe to use for UTXO fee calculations due to its low numbers, but should not be used for other purposes
+// Also note that multiplication and division between two "decimal" bigints is not supported
+// High precision may not work with some 'number' inputs, so we set the default to 6 "decimal places"
+const addPrecision = (amount, precision = 6) => {
+    if (typeof amount === 'number') {
+        return BigInt(Math.ceil(amount * 10 ** precision));
+    }
+    return amount * BigInt(10 ** precision);
+};
+const removePrecisionFloor = (amount, precision = 6) => (amount / (10n ** BigInt(precision)));
+const removePrecisionCeil = (amount, precision = 6) => {
+    const multiplier = 10n ** BigInt(precision);
+    return (amount + multiplier - 1n) / multiplier;
+};
+//# sourceMappingURL=Transaction.js.map

package/dist/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const VERSION_SIZE = 4;
+export declare const LOCKTIME_SIZE = 4;

package/dist/constants.js

@@ -0,0 +1,3 @@
+export const VERSION_SIZE = 4;
+export const LOCKTIME_SIZE = 4;
+//# sourceMappingURL=constants.js.map

package/dist/{main/index.d.ts → index.d.ts}

@@ -7,4 +7,4 @@ 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';
+export { NetworkProvider, BitcoinRpcNetworkProvider, ElectrumNetworkProvider, FullStackNetworkProvider, } from './network/index.js';

package/dist/{module/index.js → index.js}

@@ -2,9 +2,8 @@ import SignatureTemplate from './SignatureTemplate.js';
 export { SignatureTemplate };
 export { Contract } from './Contract.js';
 export { Transaction } from './Transaction.js';
-import * as utils_1 from '@cashscript/utils';
-export { utils_1 as utils };
+export * as utils from '@cashscript/utils';
 export { SignatureAlgorithm, HashType, Network, } from './interfaces.js';
 export * from './Errors.js';
-export { BitboxNetworkProvider, BitcoinRpcNetworkProvider, ElectrumNetworkProvider, FullStackNetworkProvider, } from './network/index.js';
+export { BitcoinRpcNetworkProvider, ElectrumNetworkProvider, FullStackNetworkProvider, } from './network/index.js';
 //# sourceMappingURL=index.js.map