cashscript 0.7.6 → 0.8.0-next.1

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

@@ -1,9 +1,11 @@
-import { Transaction } from '@bitauth/libauth';
+import type { Transaction } from '@bitauth/libauth';
+import type { NetworkProvider } from './network/index.js';
 import type SignatureTemplate from './SignatureTemplate.js';
 export interface Utxo {
     txid: string;
     vout: number;
-    satoshis: number;
+    satoshis: bigint;
+    token?: TokenDetails;
 }
 export interface SignableUtxo extends Utxo {
     template: SignatureTemplate;
@@ -11,11 +13,34 @@ export interface SignableUtxo extends Utxo {
 export declare function isSignableUtxo(utxo: Utxo): utxo is SignableUtxo;
 export interface Recipient {
     to: string;
-    amount: number;
+    amount: bigint;
+    token?: TokenDetails;
 }
 export interface Output {
     to: string | Uint8Array;
-    amount: number;
+    amount: bigint;
+    token?: TokenDetails;
+}
+export interface TokenDetails {
+    amount: bigint;
+    category: string;
+    nft?: {
+        capability: 'none' | 'mutable' | 'minting';
+        commitment: string;
+    };
+}
+export interface LibauthOutput {
+    lockingBytecode: Uint8Array;
+    valueSatoshis: bigint;
+    token?: LibauthTokenDetails;
+}
+export interface LibauthTokenDetails {
+    amount: bigint;
+    category: Uint8Array;
+    nft?: {
+        capability: 'none' | 'mutable' | 'minting';
+        commitment: Uint8Array;
+    };
 }
 export declare enum SignatureAlgorithm {
     ECDSA = 0,
@@ -32,8 +57,6 @@ export declare const Network: {
     TESTNET3: "testnet3";
     TESTNET4: "testnet4";
     CHIPNET: "chipnet";
-    TESTNET: "testnet";
-    STAGING: "staging";
     REGTEST: "regtest";
 };
 export declare type Network = (typeof Network)[keyof typeof Network];
@@ -41,3 +64,7 @@ export interface TransactionDetails extends Transaction {
     txid: string;
     hex: string;
 }
+export interface ContractOptions {
+    provider?: NetworkProvider;
+    addressType?: 'p2sh20' | 'p2sh32';
+}

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

@@ -21,8 +21,6 @@ export const Network = {
     TESTNET3: literal('testnet3'),
     TESTNET4: literal('testnet4'),
     CHIPNET: literal('chipnet'),
-    TESTNET: literal('testnet'),
-    STAGING: literal('staging'),
     REGTEST: literal('regtest'),
 };
 //# sourceMappingURL=interfaces.js.map

package/dist/{module/network → network}/BitcoinRpcNetworkProvider.d.ts

@@ -1,6 +1,5 @@
 import { Utxo, Network } from '../interfaces.js';
 import NetworkProvider from './NetworkProvider.js';
-declare const RpcClientRetry: any;
 export default class BitcoinRpcNetworkProvider implements NetworkProvider {
     network: Network;
     private rpcClient;
@@ -9,7 +8,7 @@ export default class BitcoinRpcNetworkProvider implements NetworkProvider {
     getBlockHeight(): Promise<number>;
     getRawTransaction(txid: string): Promise<string>;
     sendRawTransaction(txHex: string): Promise<string>;
-    getClient(): RpcClientRetry;
+    getClient(): IRpcClientRetry;
 }
 interface ListUnspentItem {
     txid: string;
@@ -24,7 +23,7 @@ interface ListUnspentItem {
     solvable: boolean;
     safe: boolean;
 }
-interface RpcClientRetry {
+interface IRpcClientRetry {
     constructor(url: string, opts?: object): void;
     listUnspent(minConf?: number, maxConf?: number, addresses?: string[], includeUnsafe?: boolean, queryOptions?: object): Promise<ListUnspentItem[]>;
     getBlockCount(): Promise<number>;

package/dist/network/BitcoinRpcNetworkProvider.js

@@ -0,0 +1,29 @@
+const { default: RpcClientRetry } = await import('bitcoin-rpc-promise-retry');
+export default class BitcoinRpcNetworkProvider {
+    constructor(network, url, opts) {
+        this.network = network;
+        this.rpcClient = new RpcClientRetry(url, opts);
+    }
+    async getUtxos(address) {
+        const result = await this.rpcClient.listUnspent(0, 9999999, [address]);
+        const utxos = result.map((utxo) => ({
+            txid: utxo.txid,
+            vout: utxo.vout,
+            satoshis: BigInt(utxo.amount * 1e8),
+        }));
+        return utxos;
+    }
+    async getBlockHeight() {
+        return this.rpcClient.getBlockCount();
+    }
+    async getRawTransaction(txid) {
+        return this.rpcClient.getRawTransaction(txid);
+    }
+    async sendRawTransaction(txHex) {
+        return this.rpcClient.sendRawTransaction(txHex);
+    }
+    getClient() {
+        return this.rpcClient;
+    }
+}
+//# sourceMappingURL=BitcoinRpcNetworkProvider.js.map

package/dist/{module/network → network}/ElectrumNetworkProvider.js

@@ -1,12 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { binToHex } from '@bitauth/libauth';
 import { sha256 } from '@cashscript/utils';
 import { ElectrumCluster, ElectrumTransport, ClusterOrder, } from 'electrum-cash';
@@ -33,7 +24,7 @@ export default class ElectrumNetworkProvider {
             this.electrum.addServer('bch.loping.net', 50004, ElectrumTransport.WSS.Scheme, false);
             this.electrum.addServer('electrum.imaginary.cash', 50004, ElectrumTransport.WSS.Scheme, false);
         }
-        else if (network === Network.TESTNET || network === Network.TESTNET3) {
+        else if (network === Network.TESTNET3) {
             // Initialise a 1-of-2 Electrum Cluster with 2 hardcoded servers
             this.electrum = new ElectrumCluster('CashScript Application', '1.4.1', 1, 2, ClusterOrder.PRIORITY);
             this.electrum.addServer('blackie.c3-soft.com', 60004, ElectrumTransport.WSS.Scheme, false);
@@ -41,7 +32,7 @@ export default 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 === Network.STAGING || network === Network.TESTNET4) {
+        else if (network === Network.TESTNET4) {
             this.electrum = new ElectrumCluster('CashScript Application', '1.4.1', 1, 1, ClusterOrder.PRIORITY);
             this.electrum.addServer('testnet4.imaginary.cash', 50004, ElectrumTransport.WSS.Scheme, false);
         }
@@ -53,74 +44,64 @@ export default class ElectrumNetworkProvider {
             throw new Error(`Tried to instantiate an ElectrumNetworkProvider for unsupported network ${network}`);
         }
     }
-    getUtxos(address) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const scripthash = addressToElectrumScriptHash(address);
-            const result = yield this.performRequest('blockchain.scripthash.listunspent', scripthash);
-            const utxos = result.map((utxo) => ({
-                txid: utxo.tx_hash,
-                vout: utxo.tx_pos,
-                satoshis: utxo.value,
-                height: utxo.height,
-            }));
-            return utxos;
-        });
+    async getUtxos(address) {
+        const scripthash = addressToElectrumScriptHash(address);
+        const filteringOption = 'include_tokens';
+        const result = await this.performRequest('blockchain.scripthash.listunspent', scripthash, filteringOption);
+        const utxos = result.map((utxo) => ({
+            txid: utxo.tx_hash,
+            vout: utxo.tx_pos,
+            satoshis: BigInt(utxo.value),
+            token: utxo.token_data ? {
+                ...utxo.token_data,
+                amount: BigInt(utxo.token_data.amount),
+            } : undefined,
+        }));
+        return utxos;
     }
-    getBlockHeight() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { height } = yield this.performRequest('blockchain.headers.subscribe');
-            return height;
-        });
+    async getBlockHeight() {
+        const { height } = await this.performRequest('blockchain.headers.subscribe');
+        return height;
     }
-    getRawTransaction(txid) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.performRequest('blockchain.transaction.get', txid);
-        });
+    async getRawTransaction(txid) {
+        return await this.performRequest('blockchain.transaction.get', txid);
     }
-    sendRawTransaction(txHex) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.performRequest('blockchain.transaction.broadcast', txHex);
-        });
+    async sendRawTransaction(txHex) {
+        return await this.performRequest('blockchain.transaction.broadcast', txHex);
     }
-    connectCluster() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                return yield this.electrum.startup();
-            }
-            catch (e) {
-                return [];
-            }
-        });
+    async connectCluster() {
+        try {
+            return await this.electrum.startup();
+        }
+        catch (e) {
+            return [];
+        }
     }
-    disconnectCluster() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.electrum.shutdown();
-        });
+    async disconnectCluster() {
+        return this.electrum.shutdown();
     }
-    performRequest(name, ...parameters) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Only connect the cluster when no concurrent requests are running
-            if (this.shouldConnect()) {
-                this.connectCluster();
-            }
-            this.concurrentRequests += 1;
-            yield this.electrum.ready();
-            let result;
-            try {
-                result = yield this.electrum.request(name, ...parameters);
-            }
-            finally {
-                // Always disconnect the cluster, also if the request fails
-                // as long as no other concurrent requests are running
-                if (this.shouldDisconnect()) {
-                    yield this.disconnectCluster();
-                }
+    async performRequest(name, ...parameters) {
+        // Only connect the cluster when no concurrent requests are running
+        if (this.shouldConnect()) {
+            this.connectCluster();
+        }
+        this.concurrentRequests += 1;
+        await this.electrum.ready();
+        let result;
+        try {
+            result = await this.electrum.request(name, ...parameters);
+        }
+        finally {
+            // Always disconnect the cluster, also if the request fails
+            // as long as no other concurrent requests are running
+            if (this.shouldDisconnect()) {
+                await this.disconnectCluster();
             }
-            this.concurrentRequests -= 1;
-            if (result instanceof Error)
-                throw result;
-            return result;
-        });
+        }
+        this.concurrentRequests -= 1;
+        if (result instanceof Error)
+            throw result;
+        return result;
     }
     shouldConnect() {
         if (this.manualConnectionManagement)

package/dist/network/FullStackNetworkProvider.js

@@ -0,0 +1,33 @@
+export default class FullStackNetworkProvider {
+    /**
+     * @example
+     * const BCHJS = require("@psf/bch-js")
+     * let bchjs = new BCHJS({
+     *   restURL: 'https://api.fullstack.cash/v3/',
+     *   apiToken: 'eyJhbGciO...' // Your JWT token here.
+     * })
+     */
+    constructor(network, bchjs) {
+        this.network = network;
+        this.bchjs = bchjs;
+    }
+    async getUtxos(address) {
+        const result = await this.bchjs.Electrumx.utxo(address);
+        const utxos = (result.utxos ?? []).map((utxo) => ({
+            txid: utxo.tx_hash,
+            vout: utxo.tx_pos,
+            satoshis: BigInt(utxo.value),
+        }));
+        return utxos;
+    }
+    async getBlockHeight() {
+        return this.bchjs.Blockchain.getBlockCount();
+    }
+    async getRawTransaction(txid) {
+        return this.bchjs.RawTransactions.getRawTransaction(txid);
+    }
+    async sendRawTransaction(txHex) {
+        return this.bchjs.RawTransactions.sendRawTransaction(txHex);
+    }
+}
+//# sourceMappingURL=FullStackNetworkProvider.js.map

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

@@ -1,5 +1,4 @@
 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 → network}/index.js

@@ -1,4 +1,3 @@
-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/utils.d.ts → utils.d.ts}

@@ -1,20 +1,24 @@
 import { Transaction } from '@bitauth/libauth';
 import { Script } from '@cashscript/utils';
-import { Utxo, Output, Recipient } from './interfaces.js';
+import { Utxo, Output, Recipient, LibauthOutput } from './interfaces.js';
 import { FailedTransactionError } from './Errors.js';
 export declare function validateRecipient(recipient: Recipient): void;
+export declare function calculateDust(recipient: Recipient): number;
+export declare function getOutputSize(output: Output): number;
+export declare function encodeOutput(output: Output): Uint8Array;
+export declare function cashScriptOutputToLibauthOutput(output: Output): LibauthOutput;
+export declare function libauthOutputToCashScriptOutput(output: LibauthOutput): Output;
 export declare function getInputSize(inputScript: Uint8Array): number;
 export declare function getPreimageSize(script: Uint8Array): number;
 export declare function getTxSizeWithoutInputs(outputs: Output[]): number;
 export declare function createInputScript(redeemScript: Script, encodedArgs: Uint8Array[], selector?: number, preimage?: Uint8Array): Uint8Array;
 export declare function createOpReturnOutput(opReturnData: string[]): Output;
-export declare function createSighashPreimage(transaction: Transaction, input: {
-    satoshis: number;
-}, inputIndex: number, coveredBytecode: Uint8Array, hashtype: number): Uint8Array;
+export declare function createSighashPreimage(transaction: Transaction, inputs: Utxo[], inputIndex: number, coveredBytecode: Uint8Array, hashtype: number): Uint8Array;
 export declare function buildError(reason: string, meepStr: string): FailedTransactionError;
 export declare function meep(tx: any, utxos: Utxo[], script: Script): string;
-export declare function scriptToAddress(script: Script, network: string): string;
-export declare function scriptToLockingBytecode(script: Script): Uint8Array;
+export declare function scriptToAddress(script: Script, network: string, addressType: 'p2sh20' | 'p2sh32', tokenSupport: boolean): string;
+export declare function scriptToLockingBytecode(script: Script, addressType: 'p2sh20' | 'p2sh32'): Uint8Array;
+export declare function utxoComparator(a: Utxo, b: Utxo): number;
 /**
 * Helper function to convert an address to a locking script
 *

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

@@ -1,13 +1,67 @@
-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 { cashAddressToLockingBytecode, decodeCashAddress, addressContentsToLockingBytecode, lockingBytecodeToCashAddress, binToHex, generateSigningSerializationBCH, utf8ToBin, hexToBin, flattenBinArray, LockingBytecodeType, encodeTransactionOutput, } from '@bitauth/libauth';
+import { encodeInt, hash160, hash256, Op, scriptToBytecode, } from '@cashscript/utils';
 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';
+import { VERSION_SIZE, LOCKTIME_SIZE } from './constants.js';
+import { OutputSatoshisTooSmallError, TokensToNonTokenAddressError, Reason, FailedTransactionError, FailedRequireError, FailedTimeCheckError, FailedSigCheckError, } from './Errors.js';
 // ////////// PARAMETER VALIDATION ////////////////////////////////////////////
 export function validateRecipient(recipient) {
-    if (recipient.amount < DUST_LIMIT) {
-        throw new OutputSatoshisTooSmallError(recipient.amount);
+    const minimumAmount = calculateDust(recipient);
+    if (recipient.amount < minimumAmount) {
+        throw new OutputSatoshisTooSmallError(recipient.amount, BigInt(minimumAmount));
     }
+    if (recipient.token) {
+        if (!isTokenAddress(recipient.to)) {
+            throw new TokensToNonTokenAddressError(recipient.to);
+        }
+    }
+}
+export function calculateDust(recipient) {
+    const outputSize = getOutputSize(recipient);
+    // Formula used to calculate the minimum allowed output
+    const dustAmount = 444 + outputSize * 3;
+    return dustAmount;
+}
+export function getOutputSize(output) {
+    const encodedOutput = encodeOutput(output);
+    return encodedOutput.byteLength;
+}
+export function encodeOutput(output) {
+    return encodeTransactionOutput(cashScriptOutputToLibauthOutput(output));
+}
+export function cashScriptOutputToLibauthOutput(output) {
+    return {
+        lockingBytecode: typeof output.to === 'string' ? addressToLockScript(output.to) : output.to,
+        valueSatoshis: output.amount,
+        token: output.token && {
+            ...output.token,
+            category: hexToBin(output.token.category),
+            nft: output.token.nft && {
+                ...output.token.nft,
+                commitment: hexToBin(output.token.nft.commitment),
+            },
+        },
+    };
+}
+export function libauthOutputToCashScriptOutput(output) {
+    return {
+        to: output.lockingBytecode,
+        amount: output.valueSatoshis,
+        token: output.token && {
+            ...output.token,
+            category: binToHex(output.token.category),
+            nft: output.token.nft && {
+                ...output.token.nft,
+                commitment: binToHex(output.token.nft.commitment),
+            },
+        },
+    };
+}
+function isTokenAddress(address) {
+    const result = decodeCashAddress(address);
+    if (typeof result === 'string')
+        throw new Error(result);
+    const supportsTokens = (result.type === 'p2pkhWithTokens' || result.type === 'p2shWithTokens');
+    return supportsTokens;
 }
 // ////////// SIZE CALCULATIONS ///////////////////////////////////////////////
 export function getInputSize(inputScript) {
@@ -36,15 +90,9 @@ export function getTxSizeWithoutInputs(outputs) {
     //   Script (?)*
     // LockTime (4B)
     let size = VERSION_SIZE + LOCKTIME_SIZE;
-    size += outputs.reduce((acc, output) => {
-        if (typeof output.to === 'string') {
-            return acc + P2PKH_OUTPUT_SIZE;
-        }
-        // Size of an OP_RETURN output = byteLength + 8 (amount) + 2 (scriptSize)
-        return acc + output.to.byteLength + 8 + 2;
-    }, 0);
+    size += outputs.reduce((acc, output) => acc + getOutputSize(output), 0);
     // Add tx-out count (accounting for a potential change output)
-    size += encodeInt(outputs.length + 1).byteLength;
+    size += encodeInt(BigInt(outputs.length + 1)).byteLength;
     return size;
 }
 // ////////// BUILD OBJECTS ///////////////////////////////////////////////////
@@ -54,7 +102,7 @@ export function createInputScript(redeemScript, encodedArgs, selector, preimage)
     if (preimage !== undefined)
         unlockScript.push(preimage);
     if (selector !== undefined)
-        unlockScript.push(encodeInt(selector));
+        unlockScript.push(encodeInt(BigInt(selector)));
     // Create input script and compile it to bytecode
     const inputScript = [...unlockScript, scriptToBytecode(redeemScript)];
     return scriptToBytecode(inputScript);
@@ -64,35 +112,25 @@ export function createOpReturnOutput(opReturnData) {
         Op.OP_RETURN,
         ...opReturnData.map((output) => toBin(output)),
     ];
-    return { to: encodeNullDataScript(script), amount: 0 };
+    return { to: encodeNullDataScript(script), amount: 0n };
 }
 function toBin(output) {
     const data = output.replace(/^0x/, '');
     const encode = data === output ? utf8ToBin : hexToBin;
     return encode(data);
 }
-export function createSighashPreimage(transaction, input, inputIndex, coveredBytecode, hashtype) {
-    const state = createTransactionContextCommon({
-        inputIndex,
-        sourceOutput: { satoshis: bigIntToBinUint64LE(BigInt(input.satoshis)) },
-        spendingTransaction: transaction,
-    });
-    const sighashPreimage = generateSigningSerializationBCH({
-        correspondingOutput: state.correspondingOutput,
-        coveredBytecode,
-        forkId: new Uint8Array([0, 0, 0]),
-        locktime: state.locktime,
-        outpointIndex: state.outpointIndex,
-        outpointTransactionHash: state.outpointTransactionHash,
-        outputValue: state.outputValue,
-        sequenceNumber: state.sequenceNumber,
-        sha256: { hash: sha256 },
-        signingSerializationType: new Uint8Array([hashtype]),
-        transactionOutpoints: state.transactionOutpoints,
-        transactionOutputs: state.transactionOutputs,
-        transactionSequenceNumbers: state.transactionSequenceNumbers,
-        version: 2,
+export function createSighashPreimage(transaction, inputs, inputIndex, coveredBytecode, hashtype) {
+    const sourceOutputs = inputs.map((input) => {
+        const sourceOutput = {
+            amount: input.satoshis,
+            to: Uint8Array.of(),
+            token: input.token,
+        };
+        return cashScriptOutputToLibauthOutput(sourceOutput);
     });
+    const context = { inputIndex, sourceOutputs, transaction };
+    const signingSerializationType = new Uint8Array([hashtype]);
+    const sighashPreimage = generateSigningSerializationBCH(context, { coveredBytecode, signingSerializationType });
     return sighashPreimage;
 }
 export function buildError(reason, meepStr) {
@@ -121,21 +159,29 @@ function toRegExp(reasons) {
 }
 // ////////// MISC ////////////////////////////////////////////////////////////
 export function meep(tx, utxos, script) {
-    const scriptPubkey = binToHex(scriptToLockingBytecode(script));
+    const scriptPubkey = binToHex(scriptToLockingBytecode(script, 'p2sh20'));
     return `meep debug --tx=${tx} --idx=0 --amt=${utxos[0].satoshis} --pkscript=${scriptPubkey}`;
 }
-export function scriptToAddress(script, network) {
-    const lockingBytecode = scriptToLockingBytecode(script);
+export function scriptToAddress(script, network, addressType, tokenSupport) {
+    const lockingBytecode = scriptToLockingBytecode(script, addressType);
     const prefix = getNetworkPrefix(network);
-    const address = lockingBytecodeToCashAddress(lockingBytecode, prefix);
+    const address = lockingBytecodeToCashAddress(lockingBytecode, prefix, { tokenSupport });
     return address;
 }
-export function scriptToLockingBytecode(script) {
-    const scriptHash = hash160(scriptToBytecode(script));
-    const addressContents = { payload: scriptHash, type: AddressType.p2sh };
+export function scriptToLockingBytecode(script, addressType) {
+    const scriptBytecode = scriptToBytecode(script);
+    const scriptHash = (addressType === 'p2sh20') ? hash160(scriptBytecode) : hash256(scriptBytecode);
+    const addressContents = { payload: scriptHash, type: LockingBytecodeType[addressType] };
     const lockingBytecode = addressContentsToLockingBytecode(addressContents);
     return lockingBytecode;
 }
+export function utxoComparator(a, b) {
+    if (a.satoshis > b.satoshis)
+        return 1;
+    if (a.satoshis < b.satoshis)
+        return -1;
+    return 0;
+}
 /**
 * Helper function to convert an address to a locking script
 *
@@ -153,9 +199,7 @@ export function getNetworkPrefix(network) {
     switch (network) {
         case Network.MAINNET:
             return 'bitcoincash';
-        case Network.STAGING:
         case Network.TESTNET4:
-        case Network.TESTNET:
         case Network.TESTNET3:
         case Network.CHIPNET:
             return 'bchtest';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cashscript",
-  "version": "0.7.6",
+  "version": "0.8.0-next.1",
   "description": "Easily write and interact with Bitcoin Cash contracts",
   "keywords": [
     "bitcoin cash",
@@ -21,39 +21,41 @@
   "contributors": [
     "Gabriel Cardona <gabriel@bitcoin.com>"
   ],
-  "main": "dist/main/index",
-  "module": "dist/module/index",
-  "types": "dist/module/index",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
   "sideEffects": false,
   "directories": {
     "lib": "src",
     "test": "test"
   },
   "scripts": {
-    "build": "npm run clean && npm run compile",
+    "build": "yarn clean && yarn compile",
+    "build:test": "yarn clean:test && yarn compile:test",
     "clean": "rm -rf ./dist",
-    "compile": "npm run compile:main && npm run compile:module",
-    "compile:main": "tsc -p tsconfig.build.main.json",
-    "compile:module": "tsc -p tsconfig.build.module.json",
+    "clean:test": "rm -rf ./dist-test",
+    "compile": "tsc -p tsconfig.build.json",
+    "compile:test": "tsc -p tsconfig.test.json",
     "lint": "eslint . --ext .ts --ignore-path ../../.eslintignore",
-    "prepare": "npm run build",
-    "test": "jest --config=../../jest.config.js packages/cashscript"
+    "prepare": "yarn build",
+    "pretest": "yarn build:test",
+    "test": "NODE_OPTIONS='--experimental-vm-modules --no-warnings' jest"
   },
   "dependencies": {
-    "@bitauth/libauth": "^1.18.1",
-    "@cashscript/utils": "^0.7.6",
+    "@bitauth/libauth": "^2.0.0-alpha.8",
+    "@cashscript/utils": "^0.8.0-next.1",
     "bip68": "^1.0.4",
     "bitcoin-rpc-promise-retry": "^1.3.0",
     "delay": "^5.0.0",
     "electrum-cash": "^2.0.10"
   },
   "devDependencies": {
+    "@jest/globals": "^29.4.1",
     "@psf/bch-js": "^4.15.0",
-    "bitbox-sdk": "^8.11.2",
+    "bip39": "^3.0.4",
     "eslint": "^7.20.0",
-    "jest": "^26.6.3",
-    "ts-jest": "^26.5.1",
+    "jest": "^29.4.1",
     "typescript": "^4.1.5"
   },
-  "gitHead": "c2daf1d80579e776b28270362041152ab0ac8898"
+  "gitHead": "77c621fb963cc8e8951faebae53267d3520b7fe9"
 }