cashscript 0.7.0-next.0 → 0.7.0

package/dist/main/Argument.d.ts

@@ -1,3 +1,3 @@
-import SignatureTemplate from './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/main/Argument.js

@@ -6,36 +6,36 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.encodeArgument = void 0;
 const libauth_1 = require("@bitauth/libauth");
 const utils_1 = require("@cashscript/utils");
-const Errors_1 = require("./Errors");
-const SignatureTemplate_1 = __importDefault(require("./SignatureTemplate"));
+const Errors_js_1 = require("./Errors.js");
+const SignatureTemplate_js_1 = __importDefault(require("./SignatureTemplate.js"));
 function encodeArgument(argument, typeStr) {
-    let type = utils_1.parseType(typeStr);
+    let type = (0, utils_1.parseType)(typeStr);
     if (type === utils_1.PrimitiveType.BOOL) {
         if (typeof argument !== 'boolean') {
-            throw new Errors_1.TypeError(typeof argument, type);
+            throw new Errors_js_1.TypeError(typeof argument, type);
         }
-        return utils_1.encodeBool(argument);
+        return (0, utils_1.encodeBool)(argument);
     }
     if (type === utils_1.PrimitiveType.INT) {
         if (typeof argument !== 'number' && typeof argument !== 'bigint') {
-            throw new Errors_1.TypeError(typeof argument, type);
+            throw new Errors_js_1.TypeError(typeof argument, type);
         }
-        return utils_1.encodeInt(argument);
+        return (0, utils_1.encodeInt)(argument);
     }
     if (type === utils_1.PrimitiveType.STRING) {
         if (typeof argument !== 'string') {
-            throw new Errors_1.TypeError(typeof argument, type);
+            throw new Errors_js_1.TypeError(typeof argument, type);
         }
-        return utils_1.encodeString(argument);
+        return (0, utils_1.encodeString)(argument);
     }
-    if (type === utils_1.PrimitiveType.SIG && argument instanceof SignatureTemplate_1.default)
+    if (type === utils_1.PrimitiveType.SIG && argument instanceof SignatureTemplate_js_1.default)
         return argument;
     // Convert hex string to Uint8Array
     if (typeof argument === 'string') {
         if (argument.startsWith('0x')) {
             argument = argument.slice(2);
         }
-        argument = libauth_1.hexToBin(argument);
+        argument = (0, libauth_1.hexToBin)(argument);
     }
     if (!(argument instanceof Uint8Array)) {
         throw Error(`Value for type ${type} should be a Uint8Array or hex string`);
@@ -52,7 +52,7 @@ function encodeArgument(argument, typeStr) {
     }
     // Bounded bytes types require a correctly sized argument
     if (type instanceof utils_1.BytesType && type.bound && argument.byteLength !== type.bound) {
-        throw new Errors_1.TypeError(`bytes${argument.byteLength}`, type);
+        throw new Errors_js_1.TypeError(`bytes${argument.byteLength}`, type);
     }
     return argument;
 }

package/dist/main/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/main/Contract.js

@@ -15,13 +15,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Contract = void 0;
 const libauth_1 = require("@bitauth/libauth");
 const utils_1 = require("@cashscript/utils");
-const Transaction_1 = require("./Transaction");
-const Argument_1 = require("./Argument");
-const utils_2 = require("./utils");
-const SignatureTemplate_1 = __importDefault(require("./SignatureTemplate"));
-const network_1 = require("./network");
+const Transaction_js_1 = require("./Transaction.js");
+const Argument_js_1 = require("./Argument.js");
+const utils_js_1 = require("./utils.js");
+const SignatureTemplate_js_1 = __importDefault(require("./SignatureTemplate.js"));
+const index_js_1 = require("./network/index.js");
 class Contract {
-    constructor(artifact, constructorArgs, provider = new network_1.ElectrumNetworkProvider()) {
+    constructor(artifact, constructorArgs, provider = new index_js_1.ElectrumNetworkProvider()) {
         this.artifact = artifact;
         this.provider = provider;
         const expectedProperties = ['abi', 'bytecode', 'constructorInputs', 'contractName'];
@@ -33,13 +33,13 @@ class Contract {
         }
         // Encode arguments (this also performs type checking)
         const encodedArgs = constructorArgs
-            .map((arg, i) => Argument_1.encodeArgument(arg, artifact.constructorInputs[i].type))
+            .map((arg, i) => (0, Argument_js_1.encodeArgument)(arg, artifact.constructorInputs[i].type))
             .reverse();
         // Check there's no signature templates in the constructor
-        if (encodedArgs.some((arg) => arg instanceof SignatureTemplate_1.default)) {
+        if (encodedArgs.some((arg) => arg instanceof SignatureTemplate_js_1.default)) {
             throw new Error('Cannot use signatures in constructor');
         }
-        this.redeemScript = utils_1.generateRedeemScript(utils_1.asmToScript(this.artifact.bytecode), encodedArgs);
+        this.redeemScript = (0, utils_1.generateRedeemScript)((0, utils_1.asmToScript)(this.artifact.bytecode), encodedArgs);
         // Populate the functions object with the contract's functions
         // (with a special case for single function, which has no "function selector")
         this.functions = {};
@@ -53,9 +53,9 @@ class Contract {
             });
         }
         this.name = artifact.contractName;
-        this.address = utils_2.scriptToAddress(this.redeemScript, this.provider.network);
-        this.bytesize = utils_1.calculateBytesize(this.redeemScript);
-        this.opcount = utils_1.countOpcodes(this.redeemScript);
+        this.address = (0, utils_js_1.scriptToAddress)(this.redeemScript, this.provider.network);
+        this.bytesize = (0, utils_1.calculateBytesize)(this.redeemScript);
+        this.opcount = (0, utils_1.countOpcodes)(this.redeemScript);
     }
     getBalance() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -69,7 +69,7 @@ class Contract {
         });
     }
     getRedeemScriptHex() {
-        return libauth_1.binToHex(utils_1.scriptToBytecode(this.redeemScript));
+        return (0, libauth_1.binToHex)((0, utils_1.scriptToBytecode)(this.redeemScript));
     }
     createFunction(abiFunction, selector) {
         return (...args) => {
@@ -78,8 +78,8 @@ class Contract {
             }
             // Encode passed args (this also performs type checking)
             const encodedArgs = args
-                .map((arg, i) => Argument_1.encodeArgument(arg, abiFunction.inputs[i].type));
-            return new Transaction_1.Transaction(this.address, this.provider, this.redeemScript, abiFunction, encodedArgs, selector);
+                .map((arg, i) => (0, Argument_js_1.encodeArgument)(arg, abiFunction.inputs[i].type));
+            return new Transaction_js_1.Transaction(this.address, this.provider, this.redeemScript, abiFunction, encodedArgs, selector);
         };
     }
 }

package/dist/main/Errors.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Reason = exports.FailedSigCheckError = exports.FailedTimeCheckError = exports.FailedRequireError = exports.FailedTransactionError = exports.OutputSatoshisTooSmallError = exports.TypeError = void 0;
-const constants_1 = require("./constants");
+const constants_js_1 = require("./constants.js");
 class TypeError extends Error {
     constructor(actual, expected) {
         super(`Found type '${actual}' where type '${expected.toString()}' was expected`);
@@ -10,7 +10,7 @@ class TypeError extends Error {
 exports.TypeError = TypeError;
 class OutputSatoshisTooSmallError extends Error {
     constructor(satoshis) {
-        super(`Tried to add an output with ${satoshis} satoshis, which is less than the DUST limit (${constants_1.DUST_LIMIT})`);
+        super(`Tried to add an output with ${satoshis} satoshis, which is less than the DUST limit (${constants_js_1.DUST_LIMIT})`);
     }
 }
 exports.OutputSatoshisTooSmallError = OutputSatoshisTooSmallError;

package/dist/main/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/main/SignatureTemplate.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const libauth_1 = require("@bitauth/libauth");
 const utils_1 = require("@cashscript/utils");
-const interfaces_1 = require("./interfaces");
+const interfaces_js_1 = require("./interfaces.js");
 class SignatureTemplate {
-    constructor(signer, hashtype = interfaces_1.HashType.SIGHASH_ALL) {
+    constructor(signer, hashtype = interfaces_js_1.HashType.SIGHASH_ALL) {
         this.hashtype = hashtype;
         if (isKeypair(signer)) {
             const wif = signer.toWIF();
@@ -33,7 +33,7 @@ function isKeypair(obj) {
     return typeof obj.toWIF === 'function';
 }
 function decodeWif(wif) {
-    const result = libauth_1.decodePrivateKeyWif({ hash: utils_1.sha256 }, wif);
+    const result = (0, libauth_1.decodePrivateKeyWif)({ hash: utils_1.sha256 }, wif);
     if (typeof result === 'string') {
         throw new Error(result);
     }

package/dist/main/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/main/Transaction.js

@@ -16,10 +16,10 @@ exports.Transaction = void 0;
 const libauth_1 = require("@bitauth/libauth");
 const delay_1 = __importDefault(require("delay"));
 const utils_1 = require("@cashscript/utils");
-const interfaces_1 = require("./interfaces");
-const utils_2 = require("./utils");
-const constants_1 = require("./constants");
-const SignatureTemplate_1 = __importDefault(require("./SignatureTemplate"));
+const interfaces_js_1 = require("./interfaces.js");
+const utils_js_1 = require("./utils.js");
+const constants_js_1 = require("./constants.js");
+const SignatureTemplate_js_1 = __importDefault(require("./SignatureTemplate.js"));
 const bip68 = require('bip68');
 class Transaction {
     constructor(address, provider, redeemScript, abiFunction, args, selector) {
@@ -33,7 +33,7 @@ class Transaction {
         this.outputs = [];
         this.sequence = 0xfffffffe;
         this.feePerByte = 1.0;
-        this.minChange = constants_1.DUST_LIMIT;
+        this.minChange = constants_js_1.DUST_LIMIT;
     }
     from(inputOrInputs) {
         if (!Array.isArray(inputOrInputs)) {
@@ -55,14 +55,14 @@ class Transaction {
             return this.to([{ to: toOrOutputs, amount }]);
         }
         if (Array.isArray(toOrOutputs) && amount === undefined) {
-            toOrOutputs.forEach(utils_2.validateRecipient);
+            toOrOutputs.forEach(utils_js_1.validateRecipient);
             this.outputs = this.outputs.concat(toOrOutputs);
             return this;
         }
         throw new Error('Incorrect arguments passed to function \'to\'');
     }
     withOpReturn(chunks) {
-        this.outputs.push(utils_2.createOpReturnOutput(chunks));
+        this.outputs.push((0, utils_js_1.createOpReturnOutput)(chunks));
         return this;
     }
     withAge(age) {
@@ -93,19 +93,19 @@ class Transaction {
         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 libauth_1.instantiateSecp256k1();
-            const bytecode = utils_1.scriptToBytecode(this.redeemScript);
+            const secp256k1 = yield (0, libauth_1.instantiateSecp256k1)();
+            const bytecode = (0, utils_1.scriptToBytecode)(this.redeemScript);
             const inputs = this.inputs.map((utxo) => ({
                 outpointIndex: utxo.vout,
-                outpointTransactionHash: libauth_1.hexToBin(utxo.txid),
+                outpointTransactionHash: (0, libauth_1.hexToBin)(utxo.txid),
                 sequenceNumber: this.sequence,
                 unlockingBytecode: new Uint8Array(),
             }));
             const outputs = this.outputs.map((output) => {
                 const lockingBytecode = typeof output.to === 'string'
-                    ? utils_2.addressToLockScript(output.to)
+                    ? (0, utils_js_1.addressToLockScript)(output.to)
                     : output.to;
-                const satoshis = libauth_1.bigIntToBinUint64LE(BigInt(output.amount));
+                const satoshis = (0, libauth_1.bigIntToBinUint64LE)(BigInt(output.amount));
                 return { lockingBytecode, satoshis };
             });
             const transaction = {
@@ -117,40 +117,40 @@ class Transaction {
             const inputScripts = [];
             this.inputs.forEach((utxo, i) => {
                 // UTXO's with signature templates are signed using P2PKH
-                if (interfaces_1.isSignableUtxo(utxo)) {
+                if ((0, interfaces_js_1.isSignableUtxo)(utxo)) {
                     const pubkey = utxo.template.getPublicKey(secp256k1);
-                    const pubkeyHash = utils_1.hash160(pubkey);
+                    const pubkeyHash = (0, utils_1.hash160)(pubkey);
                     const addressContents = { payload: pubkeyHash, type: libauth_1.AddressType.p2pkh };
-                    const prevOutScript = libauth_1.addressContentsToLockingBytecode(addressContents);
+                    const prevOutScript = (0, libauth_1.addressContentsToLockingBytecode)(addressContents);
                     const hashtype = utxo.template.getHashType();
-                    const preimage = utils_2.createSighashPreimage(transaction, utxo, i, prevOutScript, hashtype);
-                    const sighash = utils_1.hash256(preimage);
+                    const preimage = (0, utils_js_1.createSighashPreimage)(transaction, utxo, i, prevOutScript, hashtype);
+                    const sighash = (0, utils_1.hash256)(preimage);
                     const signature = utxo.template.generateSignature(sighash, secp256k1);
-                    const inputScript = utils_1.scriptToBytecode([signature, pubkey]);
+                    const inputScript = (0, utils_1.scriptToBytecode)([signature, pubkey]);
                     inputScripts.push(inputScript);
                     return;
                 }
                 let covenantHashType = -1;
                 const completeArgs = this.args.map((arg) => {
-                    if (!(arg instanceof SignatureTemplate_1.default))
+                    if (!(arg instanceof SignatureTemplate_js_1.default))
                         return arg;
                     // First signature is used for sighash preimage (maybe not the best way)
                     if (covenantHashType < 0)
                         covenantHashType = arg.getHashType();
-                    const preimage = utils_2.createSighashPreimage(transaction, utxo, i, bytecode, arg.getHashType());
-                    const sighash = utils_1.hash256(preimage);
+                    const preimage = (0, utils_js_1.createSighashPreimage)(transaction, utxo, i, bytecode, arg.getHashType());
+                    const sighash = (0, utils_1.hash256)(preimage);
                     return arg.generateSignature(sighash, secp256k1);
                 });
                 const preimage = this.abiFunction.covenant
-                    ? utils_2.createSighashPreimage(transaction, utxo, i, bytecode, covenantHashType)
+                    ? (0, utils_js_1.createSighashPreimage)(transaction, utxo, i, bytecode, covenantHashType)
                     : undefined;
-                const inputScript = utils_2.createInputScript(this.redeemScript, completeArgs, this.selector, preimage);
+                const inputScript = (0, utils_js_1.createInputScript)(this.redeemScript, completeArgs, this.selector, preimage);
                 inputScripts.push(inputScript);
             });
             inputScripts.forEach((script, i) => {
                 transaction.inputs[i].unlockingBytecode = script;
             });
-            return libauth_1.binToHex(libauth_1.encodeTransaction(transaction));
+            return (0, libauth_1.binToHex)((0, libauth_1.encodeTransaction)(transaction));
         });
     }
     send(raw) {
@@ -163,19 +163,19 @@ class Transaction {
             }
             catch (e) {
                 const reason = (_a = e.error) !== null && _a !== void 0 ? _a : e.message;
-                throw utils_2.buildError(reason, utils_2.meep(tx, this.inputs, this.redeemScript));
+                throw (0, utils_js_1.buildError)(reason, (0, utils_js_1.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_1.default(500);
+                yield (0, delay_1.default)(500);
                 try {
                     const hex = yield this.provider.getRawTransaction(txid);
                     if (raw)
                         return hex;
-                    const libauthTransaction = libauth_1.decodeTransaction(libauth_1.hexToBin(hex));
+                    const libauthTransaction = (0, libauth_1.decodeTransaction)((0, libauth_1.hexToBin)(hex));
                     return Object.assign(Object.assign({}, libauthTransaction), { txid, hex });
                 }
                 catch (ignored) {
@@ -189,30 +189,29 @@ class Transaction {
     meep() {
         return __awaiter(this, void 0, void 0, function* () {
             const tx = yield this.build();
-            return utils_2.meep(tx, this.inputs, this.redeemScript);
+            return (0, utils_js_1.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_1.default ? utils_1.placeholder(65) : arg));
+            const placeholderArgs = this.args.map((arg) => (arg instanceof SignatureTemplate_js_1.default ? (0, utils_1.placeholder)(65) : arg));
             // Create a placeholder preimage of the correct size
             const placeholderPreimage = this.abiFunction.covenant
-                ? utils_1.placeholder(utils_2.getPreimageSize(utils_1.scriptToBytecode(this.redeemScript)))
+                ? (0, utils_1.placeholder)((0, utils_js_1.getPreimageSize)((0, utils_1.scriptToBytecode)(this.redeemScript)))
                 : undefined;
             // Create a placeholder input script for size calculation using the placeholder
             // arguments and correctly sized placeholder preimage
-            const placeholderScript = utils_2.createInputScript(this.redeemScript, placeholderArgs, this.selector, placeholderPreimage);
+            const placeholderScript = (0, utils_js_1.createInputScript)(this.redeemScript, placeholderArgs, this.selector, placeholderPreimage);
             // Add one extra byte per input to over-estimate tx-in count
-            const inputSize = utils_2.getInputSize(placeholderScript) + 1;
+            const inputSize = (0, utils_js_1.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
-                : utils_2.getTxSizeWithoutInputs(this.outputs) * this.feePerByte;
+            let fee = (_a = this.hardcodedFee) !== null && _a !== void 0 ? _a : (0, utils_js_1.getTxSizeWithoutInputs)(this.outputs) * this.feePerByte;
             // Select and gather UTXOs and calculate fees and available funds
             let satsAvailable = 0;
             if (this.inputs.length > 0) {
@@ -246,10 +245,10 @@ class Transaction {
             }
             // Account for the fee of a change output
             if (!this.hardcodedFee) {
-                change -= constants_1.P2SH_OUTPUT_SIZE;
+                change -= constants_js_1.P2SH_OUTPUT_SIZE;
             }
             // Add a change output if applicable
-            if (change >= constants_1.DUST_LIMIT && change >= this.minChange) {
+            if (change >= constants_js_1.DUST_LIMIT && change >= this.minChange) {
                 this.outputs.push({ to: this.address, amount: change });
             }
         });

package/dist/main/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/main/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -25,18 +29,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Network = exports.HashType = exports.SignatureAlgorithm = exports.utils = exports.SignatureTemplate = exports.Transaction = exports.Contract = void 0;
-var Contract_1 = require("./Contract");
-Object.defineProperty(exports, "Contract", { enumerable: true, get: function () { return Contract_1.Contract; } });
-var Transaction_1 = require("./Transaction");
-Object.defineProperty(exports, "Transaction", { enumerable: true, get: function () { return Transaction_1.Transaction; } });
-var SignatureTemplate_1 = require("./SignatureTemplate");
-Object.defineProperty(exports, "SignatureTemplate", { enumerable: true, get: function () { return __importDefault(SignatureTemplate_1).default; } });
+exports.FullStackNetworkProvider = exports.ElectrumNetworkProvider = exports.BitcoinRpcNetworkProvider = exports.BitboxNetworkProvider = exports.Network = exports.HashType = exports.SignatureAlgorithm = exports.utils = exports.SignatureTemplate = exports.Transaction = exports.Contract = void 0;
+var Contract_js_1 = require("./Contract.js");
+Object.defineProperty(exports, "Contract", { enumerable: true, get: function () { return Contract_js_1.Contract; } });
+var Transaction_js_1 = require("./Transaction.js");
+Object.defineProperty(exports, "Transaction", { enumerable: true, get: function () { return Transaction_js_1.Transaction; } });
+var SignatureTemplate_js_1 = require("./SignatureTemplate.js");
+Object.defineProperty(exports, "SignatureTemplate", { enumerable: true, get: function () { return __importDefault(SignatureTemplate_js_1).default; } });
 exports.utils = __importStar(require("@cashscript/utils"));
-var interfaces_1 = require("./interfaces");
-Object.defineProperty(exports, "SignatureAlgorithm", { enumerable: true, get: function () { return interfaces_1.SignatureAlgorithm; } });
-Object.defineProperty(exports, "HashType", { enumerable: true, get: function () { return interfaces_1.HashType; } });
-Object.defineProperty(exports, "Network", { enumerable: true, get: function () { return interfaces_1.Network; } });
-__exportStar(require("./Errors"), exports);
-__exportStar(require("./network"), exports);
+var interfaces_js_1 = require("./interfaces.js");
+Object.defineProperty(exports, "SignatureAlgorithm", { enumerable: true, get: function () { return interfaces_js_1.SignatureAlgorithm; } });
+Object.defineProperty(exports, "HashType", { enumerable: true, get: function () { return interfaces_js_1.HashType; } });
+Object.defineProperty(exports, "Network", { enumerable: true, get: function () { return interfaces_js_1.Network; } });
+__exportStar(require("./Errors.js"), exports);
+var index_js_1 = require("./network/index.js");
+Object.defineProperty(exports, "BitboxNetworkProvider", { enumerable: true, get: function () { return index_js_1.BitboxNetworkProvider; } });
+Object.defineProperty(exports, "BitcoinRpcNetworkProvider", { enumerable: true, get: function () { return index_js_1.BitcoinRpcNetworkProvider; } });
+Object.defineProperty(exports, "ElectrumNetworkProvider", { enumerable: true, get: function () { return index_js_1.ElectrumNetworkProvider; } });
+Object.defineProperty(exports, "FullStackNetworkProvider", { enumerable: true, get: function () { return index_js_1.FullStackNetworkProvider; } });
 //# sourceMappingURL=index.js.map

package/dist/main/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;

package/dist/main/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/main/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/main/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?;

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,7 +35,7 @@ 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, electrum_cash_1.ClusterOrder.PRIORITY);
             this.electrum.addServer('blackie.c3-soft.com', 60004, electrum_cash_1.ElectrumTransport.WSS.Scheme, false);
@@ -43,7 +43,7 @@ class ElectrumNetworkProvider {
             // 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_1.Network.STAGING) {
+        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);
         }
@@ -147,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,7 @@
 import { Transaction } from '@bitauth/libauth';
 import { Script } from '@cashscript/utils';
-import { Utxo, Output, Recipient } 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;

package/dist/main/utils.js

@@ -3,13 +3,13 @@ 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_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_1.DUST_LIMIT) {
-        throw new Errors_1.OutputSatoshisTooSmallError(recipient.amount);
+    if (recipient.amount < constants_js_1.DUST_LIMIT) {
+        throw new Errors_js_1.OutputSatoshisTooSmallError(recipient.amount);
     }
 }
 exports.validateRecipient = validateRecipient;
@@ -41,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;
@@ -61,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) {
@@ -81,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]),
@@ -107,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) {
@@ -132,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;
@@ -158,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;
@@ -166,13 +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.STAGING:
+        case interfaces_js_1.Network.STAGING:
             return 'bchtest';
-        case interfaces_1.Network.TESTNET:
+        case interfaces_js_1.Network.TESTNET:
             return 'bchtest';
-        case interfaces_1.Network.REGTEST:
+        case interfaces_js_1.Network.REGTEST:
             return 'bchreg';
         default:
             return 'bitcoincash';
@@ -182,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';
+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) {

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.js

@@ -1,4 +1,4 @@
-import { DUST_LIMIT } from './constants';
+import { DUST_LIMIT } from './constants.js';
 export class TypeError extends Error {
     constructor(actual, expected) {
         super(`Found type '${actual}' where type '${expected.toString()}' was expected`);

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, validateRecipient, } 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) {
@@ -187,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');
@@ -204,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;

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?;

package/dist/module/network/ElectrumNetworkProvider.js

@@ -10,8 +10,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { binToHex } from '@bitauth/libauth';
 import { sha256 } from '@cashscript/utils';
 import { ElectrumCluster, ElectrumTransport, ClusterOrder, } from 'electrum-cash';
-import { Network } from '../interfaces';
-import { addressToLockScript } from '../utils';
+import { Network } from '../interfaces.js';
+import { addressToLockScript } from '../utils.js';
 export default class ElectrumNetworkProvider {
     constructor(network = Network.MAINNET, electrum, manualConnectionManagement) {
         this.network = network;

package/dist/module/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/module/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/module/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/module/network/index.js

@@ -1,5 +1,5 @@
-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 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';
 //# sourceMappingURL=index.js.map

package/dist/module/utils.d.ts

@@ -1,7 +1,7 @@
 import { Transaction } from '@bitauth/libauth';
 import { Script } from '@cashscript/utils';
-import { Utxo, Output, Recipient } 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;

package/dist/module/utils.js

@@ -1,8 +1,8 @@
 import { cashAddressToLockingBytecode, AddressType, addressContentsToLockingBytecode, lockingBytecodeToCashAddress, binToHex, createTransactionContextCommon, bigIntToBinUint64LE, generateSigningSerializationBCH, utf8ToBin, hexToBin, flattenBinArray, } from '@bitauth/libauth';
 import { encodeInt, hash160, Op, scriptToBytecode, sha256, } from '@cashscript/utils';
-import { Network, } from './interfaces';
-import { P2PKH_OUTPUT_SIZE, VERSION_SIZE, LOCKTIME_SIZE, DUST_LIMIT, } from './constants';
-import { OutputSatoshisTooSmallError, Reason, FailedTransactionError, FailedRequireError, FailedTimeCheckError, FailedSigCheckError, } from './Errors';
+import { Network, } from './interfaces.js';
+import { P2PKH_OUTPUT_SIZE, VERSION_SIZE, LOCKTIME_SIZE, DUST_LIMIT, } from './constants.js';
+import { OutputSatoshisTooSmallError, Reason, FailedTransactionError, FailedRequireError, FailedTimeCheckError, FailedSigCheckError, } from './Errors.js';
 // ////////// PARAMETER VALIDATION ////////////////////////////////////////////
 export function validateRecipient(recipient) {
     if (recipient.amount < DUST_LIMIT) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cashscript",
-  "version": "0.7.0-next.0",
+  "version": "0.7.0",
   "description": "Easily write and interact with Bitcoin Cash contracts",
   "keywords": [
     "bitcoin cash",
@@ -42,11 +42,11 @@
   },
   "dependencies": {
     "@bitauth/libauth": "^1.18.1",
-    "@cashscript/utils": "^0.7.0-next.0",
+    "@cashscript/utils": "^0.7.0",
     "bip68": "^1.0.4",
     "bitcoin-rpc-promise-retry": "^1.3.0",
     "delay": "^5.0.0",
-    "electrum-cash": "^2.0.6"
+    "electrum-cash": "^2.0.10"
   },
   "devDependencies": {
     "@psf/bch-js": "^4.15.0",