cashscript 0.6.4 → 0.7.0

package/dist/main/network/ElectrumNetworkProvider.js

@@ -12,10 +12,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const libauth_1 = require("@bitauth/libauth");
 const utils_1 = require("@cashscript/utils");
 const electrum_cash_1 = require("electrum-cash");
-const interfaces_1 = require("../interfaces");
-const utils_2 = require("../utils");
+const interfaces_js_1 = require("../interfaces.js");
+const utils_js_1 = require("../utils.js");
 class ElectrumNetworkProvider {
-    constructor(network = interfaces_1.Network.MAINNET, electrum, manualConnectionManagement) {
+    constructor(network = interfaces_js_1.Network.MAINNET, electrum, manualConnectionManagement) {
         this.network = network;
         this.manualConnectionManagement = manualConnectionManagement;
         this.concurrentRequests = 0;
@@ -24,7 +24,7 @@ class ElectrumNetworkProvider {
             this.electrum = electrum;
             return;
         }
-        if (network === interfaces_1.Network.MAINNET) {
+        if (network === interfaces_js_1.Network.MAINNET) {
             // Initialise a 2-of-3 Electrum Cluster with 6 reliable hardcoded servers
             // using the first three servers as "priority" servers
             this.electrum = new electrum_cash_1.ElectrumCluster('CashScript Application', '1.4.1', 2, 3, electrum_cash_1.ClusterOrder.PRIORITY);
@@ -35,14 +35,18 @@ class ElectrumNetworkProvider {
             this.electrum.addServer('bch.loping.net', 50004, electrum_cash_1.ElectrumTransport.WSS.Scheme, false);
             this.electrum.addServer('electrum.imaginary.cash', 50004, electrum_cash_1.ElectrumTransport.WSS.Scheme, false);
         }
-        else if (network === interfaces_1.Network.TESTNET) {
+        else if (network === interfaces_js_1.Network.TESTNET) {
             // Initialise a 1-of-2 Electrum Cluster with 2 hardcoded servers
-            this.electrum = new electrum_cash_1.ElectrumCluster('CashScript Application', '1.4.1', 1, 2);
+            this.electrum = new electrum_cash_1.ElectrumCluster('CashScript Application', '1.4.1', 1, 2, electrum_cash_1.ClusterOrder.PRIORITY);
             this.electrum.addServer('blackie.c3-soft.com', 60004, electrum_cash_1.ElectrumTransport.WSS.Scheme, false);
             this.electrum.addServer('electroncash.de', 60004, electrum_cash_1.ElectrumTransport.WSS.Scheme, false);
             // this.electrum.addServer('bch.loping.net', 60004, ElectrumTransport.WSS.Scheme, false);
             // this.electrum.addServer('testnet.imaginary.cash', 50004, ElectrumTransport.WSS.Scheme);
         }
+        else if (network === interfaces_js_1.Network.STAGING) {
+            this.electrum = new electrum_cash_1.ElectrumCluster('CashScript Application', '1.4.1', 1, 1, electrum_cash_1.ClusterOrder.PRIORITY);
+            this.electrum.addServer('testnet4.imaginary.cash', 50004, electrum_cash_1.ElectrumTransport.WSS.Scheme, false);
+        }
         else {
             throw new Error(`Tried to instantiate an ElectrumNetworkProvider for unsupported network ${network}`);
         }
@@ -143,12 +147,12 @@ exports.default = ElectrumNetworkProvider;
  */
 function addressToElectrumScriptHash(address) {
     // Retrieve locking script
-    const lockScript = utils_2.addressToLockScript(address);
+    const lockScript = (0, utils_js_1.addressToLockScript)(address);
     // Hash locking script
-    const scriptHash = utils_1.sha256(lockScript);
+    const scriptHash = (0, utils_1.sha256)(lockScript);
     // Reverse scripthash
     scriptHash.reverse();
     // Return scripthash as a hex string
-    return libauth_1.binToHex(scriptHash);
+    return (0, libauth_1.binToHex)(scriptHash);
 }
 //# sourceMappingURL=ElectrumNetworkProvider.js.map

package/dist/main/network/FullStackNetworkProvider.d.ts

@@ -1,5 +1,5 @@
-import { Utxo, Network } from '../interfaces';
-import NetworkProvider from './NetworkProvider';
+import { Utxo, Network } from '../interfaces.js';
+import NetworkProvider from './NetworkProvider.js';
 export default class FullStackNetworkProvider implements NetworkProvider {
     network: Network;
     private bchjs;

package/dist/main/network/NetworkProvider.d.ts

@@ -1,4 +1,4 @@
-import { Utxo, Network } from '../interfaces';
+import { Utxo, Network } from '../interfaces.js';
 export default interface NetworkProvider {
     /**
      * Variable indicating the network that this provider connects to.

package/dist/main/network/index.d.ts

@@ -1,5 +1,5 @@
-export { default as NetworkProvider } from './NetworkProvider';
-export { default as BitboxNetworkProvider } from './BitboxNetworkProvider';
-export { default as BitcoinRpcNetworkProvider } from './BitcoinRpcNetworkProvider';
-export { default as ElectrumNetworkProvider } from './ElectrumNetworkProvider';
-export { default as FullStackNetworkProvider } from './FullStackNetworkProvider';
+export { default as NetworkProvider } from './NetworkProvider.js';
+export { default as BitboxNetworkProvider } from './BitboxNetworkProvider.js';
+export { default as BitcoinRpcNetworkProvider } from './BitcoinRpcNetworkProvider.js';
+export { default as ElectrumNetworkProvider } from './ElectrumNetworkProvider.js';
+export { default as FullStackNetworkProvider } from './FullStackNetworkProvider.js';

package/dist/main/network/index.js

@@ -4,12 +4,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FullStackNetworkProvider = exports.ElectrumNetworkProvider = exports.BitcoinRpcNetworkProvider = exports.BitboxNetworkProvider = void 0;
-var BitboxNetworkProvider_1 = require("./BitboxNetworkProvider");
-Object.defineProperty(exports, "BitboxNetworkProvider", { enumerable: true, get: function () { return __importDefault(BitboxNetworkProvider_1).default; } });
-var BitcoinRpcNetworkProvider_1 = require("./BitcoinRpcNetworkProvider");
-Object.defineProperty(exports, "BitcoinRpcNetworkProvider", { enumerable: true, get: function () { return __importDefault(BitcoinRpcNetworkProvider_1).default; } });
-var ElectrumNetworkProvider_1 = require("./ElectrumNetworkProvider");
-Object.defineProperty(exports, "ElectrumNetworkProvider", { enumerable: true, get: function () { return __importDefault(ElectrumNetworkProvider_1).default; } });
-var FullStackNetworkProvider_1 = require("./FullStackNetworkProvider");
-Object.defineProperty(exports, "FullStackNetworkProvider", { enumerable: true, get: function () { return __importDefault(FullStackNetworkProvider_1).default; } });
+var BitboxNetworkProvider_js_1 = require("./BitboxNetworkProvider.js");
+Object.defineProperty(exports, "BitboxNetworkProvider", { enumerable: true, get: function () { return __importDefault(BitboxNetworkProvider_js_1).default; } });
+var BitcoinRpcNetworkProvider_js_1 = require("./BitcoinRpcNetworkProvider.js");
+Object.defineProperty(exports, "BitcoinRpcNetworkProvider", { enumerable: true, get: function () { return __importDefault(BitcoinRpcNetworkProvider_js_1).default; } });
+var ElectrumNetworkProvider_js_1 = require("./ElectrumNetworkProvider.js");
+Object.defineProperty(exports, "ElectrumNetworkProvider", { enumerable: true, get: function () { return __importDefault(ElectrumNetworkProvider_js_1).default; } });
+var FullStackNetworkProvider_js_1 = require("./FullStackNetworkProvider.js");
+Object.defineProperty(exports, "FullStackNetworkProvider", { enumerable: true, get: function () { return __importDefault(FullStackNetworkProvider_js_1).default; } });
 //# sourceMappingURL=index.js.map

package/dist/main/utils.d.ts

@@ -1,7 +1,8 @@
 import { Transaction } from '@bitauth/libauth';
 import { Script } from '@cashscript/utils';
-import { Utxo, Output } from './interfaces';
-import { FailedTransactionError } from './Errors';
+import { Utxo, Output, Recipient } from './interfaces.js';
+import { FailedTransactionError } from './Errors.js';
+export declare function validateRecipient(recipient: Recipient): void;
 export declare function getInputSize(inputScript: Uint8Array): number;
 export declare function getPreimageSize(script: Uint8Array): number;
 export declare function getTxSizeWithoutInputs(outputs: Output[]): number;

package/dist/main/utils.js

@@ -1,11 +1,18 @@
 "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 = void 0;
+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_1 = require("./interfaces");
-const constants_1 = require("./constants");
-const Errors_1 = require("./Errors");
+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;
@@ -34,16 +41,16 @@ function getTxSizeWithoutInputs(outputs) {
     //   Script Length(1 ~ 9B)*
     //   Script (?)*
     // LockTime (4B)
-    let size = constants_1.VERSION_SIZE + constants_1.LOCKTIME_SIZE;
+    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_1.P2PKH_OUTPUT_SIZE;
+            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 += utils_1.encodeInt(outputs.length + 1).byteLength;
+    size += (0, utils_1.encodeInt)(outputs.length + 1).byteLength;
     return size;
 }
 exports.getTxSizeWithoutInputs = getTxSizeWithoutInputs;
@@ -54,10 +61,10 @@ function createInputScript(redeemScript, encodedArgs, selector, preimage) {
     if (preimage !== undefined)
         unlockScript.push(preimage);
     if (selector !== undefined)
-        unlockScript.push(utils_1.encodeInt(selector));
+        unlockScript.push((0, utils_1.encodeInt)(selector));
     // Create input script and compile it to bytecode
-    const inputScript = [...unlockScript, utils_1.scriptToBytecode(redeemScript)];
-    return utils_1.scriptToBytecode(inputScript);
+    const inputScript = [...unlockScript, (0, utils_1.scriptToBytecode)(redeemScript)];
+    return (0, utils_1.scriptToBytecode)(inputScript);
 }
 exports.createInputScript = createInputScript;
 function createOpReturnOutput(opReturnData) {
@@ -74,12 +81,12 @@ function toBin(output) {
     return encode(data);
 }
 function createSighashPreimage(transaction, input, inputIndex, coveredBytecode, hashtype) {
-    const state = libauth_1.createTransactionContextCommon({
+    const state = (0, libauth_1.createTransactionContextCommon)({
         inputIndex,
-        sourceOutput: { satoshis: libauth_1.bigIntToBinUint64LE(BigInt(input.satoshis)) },
+        sourceOutput: { satoshis: (0, libauth_1.bigIntToBinUint64LE)(BigInt(input.satoshis)) },
         spendingTransaction: transaction,
     });
-    const sighashPreimage = libauth_1.generateSigningSerializationBCH({
+    const sighashPreimage = (0, libauth_1.generateSigningSerializationBCH)({
         correspondingOutput: state.correspondingOutput,
         coveredBytecode,
         forkId: new Uint8Array([0, 0, 0]),
@@ -100,24 +107,24 @@ function createSighashPreimage(transaction, input, inputIndex, coveredBytecode,
 exports.createSighashPreimage = createSighashPreimage;
 function buildError(reason, meepStr) {
     const require = [
-        Errors_1.Reason.EVAL_FALSE, Errors_1.Reason.VERIFY, Errors_1.Reason.EQUALVERIFY, Errors_1.Reason.CHECKMULTISIGVERIFY,
-        Errors_1.Reason.CHECKSIGVERIFY, Errors_1.Reason.CHECKDATASIGVERIFY, Errors_1.Reason.NUMEQUALVERIFY,
+        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_1.Reason.NEGATIVE_LOCKTIME, Errors_1.Reason.UNSATISFIED_LOCKTIME];
+    const timeCheck = [Errors_js_1.Reason.NEGATIVE_LOCKTIME, Errors_js_1.Reason.UNSATISFIED_LOCKTIME];
     const sigCheck = [
-        Errors_1.Reason.SIG_COUNT, Errors_1.Reason.PUBKEY_COUNT, Errors_1.Reason.SIG_HASHTYPE, Errors_1.Reason.SIG_DER,
-        Errors_1.Reason.SIG_HIGH_S, Errors_1.Reason.SIG_NULLFAIL, Errors_1.Reason.SIG_BADLENGTH, Errors_1.Reason.SIG_NONSCHNORR,
+        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_1.FailedRequireError(reason, meepStr);
+        return new Errors_js_1.FailedRequireError(reason, meepStr);
     }
     if (toRegExp(timeCheck).test(reason)) {
-        return new Errors_1.FailedTimeCheckError(reason, meepStr);
+        return new Errors_js_1.FailedTimeCheckError(reason, meepStr);
     }
     if (toRegExp(sigCheck).test(reason)) {
-        return new Errors_1.FailedSigCheckError(reason, meepStr);
+        return new Errors_js_1.FailedSigCheckError(reason, meepStr);
     }
-    return new Errors_1.FailedTransactionError(reason, meepStr);
+    return new Errors_js_1.FailedTransactionError(reason, meepStr);
 }
 exports.buildError = buildError;
 function toRegExp(reasons) {
@@ -125,21 +132,21 @@ function toRegExp(reasons) {
 }
 // ////////// MISC ////////////////////////////////////////////////////////////
 function meep(tx, utxos, script) {
-    const scriptPubkey = libauth_1.binToHex(scriptToLockingBytecode(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 = libauth_1.lockingBytecodeToCashAddress(lockingBytecode, prefix);
+    const address = (0, libauth_1.lockingBytecodeToCashAddress)(lockingBytecode, prefix);
     return address;
 }
 exports.scriptToAddress = scriptToAddress;
 function scriptToLockingBytecode(script) {
-    const scriptHash = utils_1.hash160(utils_1.scriptToBytecode(script));
+    const scriptHash = (0, utils_1.hash160)((0, utils_1.scriptToBytecode)(script));
     const addressContents = { payload: scriptHash, type: libauth_1.AddressType.p2sh };
-    const lockingBytecode = libauth_1.addressContentsToLockingBytecode(addressContents);
+    const lockingBytecode = (0, libauth_1.addressContentsToLockingBytecode)(addressContents);
     return lockingBytecode;
 }
 exports.scriptToLockingBytecode = scriptToLockingBytecode;
@@ -151,7 +158,7 @@ exports.scriptToLockingBytecode = scriptToLockingBytecode;
 * @returns a locking script corresponding to the passed address
 */
 function addressToLockScript(address) {
-    const result = libauth_1.cashAddressToLockingBytecode(address);
+    const result = (0, libauth_1.cashAddressToLockingBytecode)(address);
     if (typeof result === 'string')
         throw new Error(result);
     return result.bytecode;
@@ -159,11 +166,13 @@ function addressToLockScript(address) {
 exports.addressToLockScript = addressToLockScript;
 function getNetworkPrefix(network) {
     switch (network) {
-        case interfaces_1.Network.MAINNET:
+        case interfaces_js_1.Network.MAINNET:
             return 'bitcoincash';
-        case interfaces_1.Network.TESTNET:
+        case interfaces_js_1.Network.STAGING:
+            return 'bchtest';
+        case interfaces_js_1.Network.TESTNET:
             return 'bchtest';
-        case interfaces_1.Network.REGTEST:
+        case interfaces_js_1.Network.REGTEST:
             return 'bchreg';
         default:
             return 'bitcoincash';
@@ -173,7 +182,7 @@ exports.getNetworkPrefix = getNetworkPrefix;
 // ////////////////////////////////////////////////////////////////////////////
 // For encoding OP_RETURN data (doesn't require BIP62.3 / MINIMALDATA)
 function encodeNullDataScript(chunks) {
-    return libauth_1.flattenBinArray(chunks.map((chunk) => {
+    return (0, libauth_1.flattenBinArray)(chunks.map((chunk) => {
         if (typeof chunk === 'number') {
             return new Uint8Array([chunk]);
         }

package/dist/module/Argument.d.ts

@@ -1,3 +1,3 @@
-import SignatureTemplate from './SignatureTemplate';
-export declare type Argument = number | boolean | string | Uint8Array | SignatureTemplate;
+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/Argument.js

@@ -1,7 +1,7 @@
 import { hexToBin } from '@bitauth/libauth';
 import { BytesType, encodeBool, encodeInt, encodeString, parseType, PrimitiveType, } from '@cashscript/utils';
-import { TypeError } from './Errors';
-import SignatureTemplate from './SignatureTemplate';
+import { TypeError } from './Errors.js';
+import SignatureTemplate from './SignatureTemplate.js';
 export function encodeArgument(argument, typeStr) {
     let type = parseType(typeStr);
     if (type === PrimitiveType.BOOL) {
@@ -11,7 +11,7 @@ export function encodeArgument(argument, typeStr) {
         return encodeBool(argument);
     }
     if (type === PrimitiveType.INT) {
-        if (typeof argument !== 'number') {
+        if (typeof argument !== 'number' && typeof argument !== 'bigint') {
             throw new TypeError(typeof argument, type);
         }
         return encodeInt(argument);
@@ -36,14 +36,14 @@ export function encodeArgument(argument, typeStr) {
     }
     // Redefine SIG as a bytes65 so it is included in the size checks below
     // Note that ONLY Schnorr signatures are accepted
-    if (type === PrimitiveType.SIG) {
+    if (type === PrimitiveType.SIG && argument.byteLength !== 0) {
         type = new BytesType(65);
     }
-    // TODO: Set DATASIG to 64 bytes (enforcing Schnorr) in a new MINOR version upgrade
-    // (backwards incompatible)
-    // if (type === PrimitiveType.DATASIG) {
-    //   type = new BytesType(64);
-    // }
+    // Redefine SIG as a bytes64 so it is included in the size checks below
+    // Note that ONLY Schnorr signatures are accepted
+    if (type === PrimitiveType.DATASIG && argument.byteLength !== 0) {
+        type = new BytesType(64);
+    }
     // Bounded bytes types require a correctly sized argument
     if (type instanceof BytesType && type.bound && argument.byteLength !== type.bound) {
         throw new TypeError(`bytes${argument.byteLength}`, type);

package/dist/module/Contract.d.ts

@@ -1,8 +1,8 @@
 import { Artifact } from '@cashscript/utils';
-import { Transaction } from './Transaction';
-import { Argument } from './Argument';
-import { Utxo } from './interfaces';
-import NetworkProvider from './network/NetworkProvider';
+import { Transaction } from './Transaction.js';
+import { Argument } from './Argument.js';
+import { Utxo } from './interfaces.js';
+import NetworkProvider from './network/NetworkProvider.js';
 export declare class Contract {
     private artifact;
     private provider;

package/dist/module/Contract.js

@@ -9,11 +9,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { binToHex } from '@bitauth/libauth';
 import { asmToScript, calculateBytesize, countOpcodes, generateRedeemScript, scriptToBytecode, } from '@cashscript/utils';
-import { Transaction } from './Transaction';
-import { encodeArgument } from './Argument';
-import { scriptToAddress, } from './utils';
-import SignatureTemplate from './SignatureTemplate';
-import { ElectrumNetworkProvider } from './network';
+import { Transaction } from './Transaction.js';
+import { encodeArgument } from './Argument.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()) {
         this.artifact = artifact;

package/dist/module/Errors.d.ts

@@ -2,6 +2,9 @@ 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;
@@ -28,7 +31,7 @@ export declare enum Reason {
     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 [-2^31...2^31]",
+    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",
@@ -58,5 +61,6 @@ export declare enum Reason {
     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"
+    MUST_USE_FORKID = "Signature must use SIGHASH_FORKID",
+    UNKNOWN = "unknown error"
 }

package/dist/module/Errors.js

@@ -1,8 +1,14 @@
+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})`);
+    }
+}
 export class FailedTransactionError extends Error {
     constructor(reason, meep) {
         super(`Transaction failed with reason: ${reason}\n${meep}`);
@@ -33,7 +39,7 @@ export var Reason;
     Reason["SIG_COUNT"] = "Signature count negative or greater than pubkey count";
     Reason["PUBKEY_COUNT"] = "Pubkey count negative or limit exceeded";
     Reason["INVALID_OPERAND_SIZE"] = "Invalid operand size";
-    Reason["INVALID_NUMBER_RANGE"] = "Given operand is not a number within the valid range [-2^31...2^31]";
+    Reason["INVALID_NUMBER_RANGE"] = "Given operand is not a number within the valid range";
     Reason["IMPOSSIBLE_ENCODING"] = "The requested encoding is impossible to satisfy";
     Reason["INVALID_SPLIT_RANGE"] = "Invalid OP_SPLIT range";
     Reason["INVALID_BIT_COUNT"] = "Invalid number of bit set in OP_CHECKMULTISIG";
@@ -64,5 +70,6 @@ export var Reason;
     Reason["NONCOMPRESSED_PUBKEY"] = "Using non-compressed public key";
     Reason["ILLEGAL_FORKID"] = "Illegal use of SIGHASH_FORKID";
     Reason["MUST_USE_FORKID"] = "Signature must use SIGHASH_FORKID";
+    Reason["UNKNOWN"] = "unknown error";
 })(Reason || (Reason = {}));
 //# sourceMappingURL=Errors.js.map

package/dist/module/SignatureTemplate.d.ts

@@ -1,5 +1,5 @@
 import { Secp256k1 } from '@bitauth/libauth';
-import { HashType } from './interfaces';
+import { HashType } from './interfaces.js';
 export default class SignatureTemplate {
     private hashtype;
     private privateKey;

package/dist/module/SignatureTemplate.js

@@ -1,6 +1,6 @@
 import { decodePrivateKeyWif, SigningSerializationFlag } from '@bitauth/libauth';
 import { sha256 } from '@cashscript/utils';
-import { HashType } from './interfaces';
+import { HashType } from './interfaces.js';
 export default class SignatureTemplate {
     constructor(signer, hashtype = HashType.SIGHASH_ALL) {
         this.hashtype = hashtype;

package/dist/module/Transaction.d.ts

@@ -1,7 +1,7 @@
 import { AbiFunction, Script } from '@cashscript/utils';
-import { Utxo, Recipient, TransactionDetails } from './interfaces';
-import NetworkProvider from './network/NetworkProvider';
-import SignatureTemplate from './SignatureTemplate';
+import { Utxo, Recipient, TransactionDetails } from './interfaces.js';
+import NetworkProvider from './network/NetworkProvider.js';
+import SignatureTemplate from './SignatureTemplate.js';
 export declare class Transaction {
     private address;
     private provider;

package/dist/module/Transaction.js

@@ -10,10 +10,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 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';
-import { meep, createInputScript, getInputSize, createOpReturnOutput, getTxSizeWithoutInputs, getPreimageSize, buildError, addressToLockScript, createSighashPreimage, } from './utils';
-import { P2SH_OUTPUT_SIZE, DUST_LIMIT } from './constants';
-import SignatureTemplate from './SignatureTemplate';
+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) {
@@ -46,15 +46,14 @@ export class Transaction {
     }
     to(toOrOutputs, amount) {
         if (typeof toOrOutputs === 'string' && typeof amount === 'number') {
-            this.outputs.push({ to: toOrOutputs, amount });
+            return this.to([{ to: toOrOutputs, amount }]);
         }
-        else if (Array.isArray(toOrOutputs) && amount === undefined) {
+        if (Array.isArray(toOrOutputs) && amount === undefined) {
+            toOrOutputs.forEach(validateRecipient);
             this.outputs = this.outputs.concat(toOrOutputs);
+            return this;
         }
-        else {
-            throw new Error('Incorrect arguments passed to function \'to\'');
-        }
-        return this;
+        throw new Error('Incorrect arguments passed to function \'to\'');
     }
     withOpReturn(chunks) {
         this.outputs.push(createOpReturnOutput(chunks));
@@ -188,6 +187,7 @@ export class Transaction {
         });
     }
     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');
@@ -205,9 +205,7 @@ export class Transaction {
             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 = this.hardcodedFee
-                ? this.hardcodedFee
-                : getTxSizeWithoutInputs(this.outputs) * this.feePerByte;
+            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) {

package/dist/module/index.d.ts

@@ -1,9 +1,9 @@
-export { Contract } from './Contract';
-export { Transaction } from './Transaction';
-export { Argument } from './Argument';
-export { default as SignatureTemplate } from './SignatureTemplate';
+export { Contract } from './Contract.js';
+export { Transaction } from './Transaction.js';
+export { Argument } from './Argument.js';
+export { default as SignatureTemplate } from './SignatureTemplate.js';
 export { Artifact, AbiFunction, AbiInput } from '@cashscript/utils';
 export * as utils from '@cashscript/utils';
-export { Utxo, Recipient, SignatureAlgorithm, HashType, Network, } from './interfaces';
-export * from './Errors';
-export * from './network';
+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/index.js

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

package/dist/module/interfaces.d.ts

@@ -1,5 +1,5 @@
 import { Transaction } from '@bitauth/libauth';
-import SignatureTemplate from './SignatureTemplate';
+import type SignatureTemplate from './SignatureTemplate.js';
 export interface Utxo {
     txid: string;
     vout: number;
@@ -30,6 +30,7 @@ export declare enum HashType {
 export declare const Network: {
     MAINNET: "mainnet";
     TESTNET: "testnet";
+    STAGING: "staging";
     REGTEST: "regtest";
 };
 export declare type Network = (typeof Network)[keyof typeof Network];

package/dist/module/interfaces.js

@@ -19,6 +19,7 @@ const literal = (l) => l;
 export const Network = {
     MAINNET: literal('mainnet'),
     TESTNET: literal('testnet'),
+    STAGING: literal('staging'),
     REGTEST: literal('regtest'),
 };
 //# sourceMappingURL=interfaces.js.map

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

@@ -1,5 +1,5 @@
-import { Utxo, Network } from '../interfaces';
-import NetworkProvider from './NetworkProvider';
+import { Utxo, Network } from '../interfaces.js';
+import NetworkProvider from './NetworkProvider.js';
 export default class BitboxNetworkProvider implements NetworkProvider {
     network: Network;
     private bitbox;

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

@@ -1,5 +1,5 @@
-import { Utxo, Network } from '../interfaces';
-import NetworkProvider from './NetworkProvider';
+import { Utxo, Network } from '../interfaces.js';
+import NetworkProvider from './NetworkProvider.js';
 declare const RpcClientRetry: any;
 export default class BitcoinRpcNetworkProvider implements NetworkProvider {
     network: Network;

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

@@ -1,6 +1,6 @@
 import { ElectrumCluster } from 'electrum-cash';
-import { Utxo, Network } from '../interfaces';
-import NetworkProvider from './NetworkProvider';
+import { Utxo, Network } from '../interfaces.js';
+import NetworkProvider from './NetworkProvider.js';
 export default class ElectrumNetworkProvider implements NetworkProvider {
     network: Network;
     private manualConnectionManagement?;