cashscript 0.9.1 → 0.10.0-next.0

package/dist/{Transaction.js → src/Transaction.js}

@@ -1,17 +1,19 @@
 import bip68 from 'bip68';
-import { hexToBin, binToHex, encodeTransaction, decodeTransaction, } from '@bitauth/libauth';
+import { hexToBin, decodeTransaction, } from '@bitauth/libauth';
 import delay from 'delay';
-import { hash256, placeholder, scriptToBytecode, } from '@cashscript/utils';
+import { placeholder, scriptToBytecode, } from '@cashscript/utils';
 import deepEqual from 'fast-deep-equal';
 import { isUtxoP2PKH, } from './interfaces.js';
-import { meep, createInputScript, getInputSize, createOpReturnOutput, getTxSizeWithoutInputs, getPreimageSize, buildError, createSighashPreimage, validateRecipient, utxoComparator, cashScriptOutputToLibauthOutput, calculateDust, getOutputSize, addressToLockScript, publicKeyToP2PKHLockingBytecode, utxoTokenComparator, } from './utils.js';
+import { createInputScript, getInputSize, createOpReturnOutput, getTxSizeWithoutInputs, getPreimageSize, buildError, validateOutput, utxoComparator, calculateDust, getOutputSize, utxoTokenComparator, } from './utils.js';
 import SignatureTemplate from './SignatureTemplate.js';
 import { P2PKH_INPUT_SIZE } from './constants.js';
+import { TransactionBuilder } from './TransactionBuilder.js';
+import MockNetworkProvider from './network/MockNetworkProvider.js';
+import { buildTemplate, debugTemplate, evaluateTemplate, getBitauthUri, } from './LibauthTemplate.js';
 export class Transaction {
-    constructor(address, provider, redeemScript, abiFunction, args, selector) {
-        this.address = address;
-        this.provider = provider;
-        this.redeemScript = redeemScript;
+    constructor(contract, unlocker, abiFunction, args, selector) {
+        this.contract = contract;
+        this.unlocker = unlocker;
         this.abiFunction = abiFunction;
         this.args = args;
         this.selector = selector;
@@ -43,7 +45,7 @@ export class Transaction {
             return this.to([recipient]);
         }
         if (Array.isArray(toOrOutputs) && amount === undefined) {
-            toOrOutputs.forEach(validateRecipient);
+            toOrOutputs.forEach(validateOutput);
             this.outputs = this.outputs.concat(toOrOutputs);
             return this;
         }
@@ -81,84 +83,78 @@ export class Transaction {
         return this;
     }
     async build() {
-        this.locktime = this.locktime ?? await this.provider.getBlockHeight();
+        this.locktime = this.locktime ?? await this.contract.provider.getBlockHeight();
         await this.setInputsAndOutputs();
-        const bytecode = scriptToBytecode(this.redeemScript);
-        const lockingBytecode = addressToLockScript(this.address);
-        const inputs = this.inputs.map((utxo) => ({
-            outpointIndex: utxo.vout,
-            outpointTransactionHash: hexToBin(utxo.txid),
-            sequenceNumber: this.sequence,
-            unlockingBytecode: new Uint8Array(),
-        }));
-        // Generate source outputs from inputs (for signing with SIGHASH_UTXOS)
-        const sourceOutputs = this.inputs.map((input) => {
-            const sourceOutput = {
-                amount: input.satoshis,
-                to: isUtxoP2PKH(input) ? publicKeyToP2PKHLockingBytecode(input.template.getPublicKey()) : lockingBytecode,
-                token: input.token,
-            };
-            return cashScriptOutputToLibauthOutput(sourceOutput);
-        });
-        const outputs = this.outputs.map(cashScriptOutputToLibauthOutput);
-        const transaction = {
-            inputs,
-            locktime: this.locktime,
-            outputs,
-            version: 2,
-        };
-        const inputScripts = [];
-        this.inputs.forEach((utxo, i) => {
-            // UTXO's with signature templates are signed using P2PKH
+        const builder = new TransactionBuilder({ provider: this.contract.provider });
+        this.inputs.forEach((utxo) => {
             if (isUtxoP2PKH(utxo)) {
-                const pubkey = utxo.template.getPublicKey();
-                const prevOutScript = publicKeyToP2PKHLockingBytecode(pubkey);
-                const hashtype = utxo.template.getHashType();
-                const preimage = createSighashPreimage(transaction, sourceOutputs, i, prevOutScript, hashtype);
-                const sighash = hash256(preimage);
-                const signature = utxo.template.generateSignature(sighash);
-                const inputScript = scriptToBytecode([signature, pubkey]);
-                inputScripts.push(inputScript);
-                return;
+                builder.addInput(utxo, utxo.template.unlockP2PKH(), { sequence: this.sequence });
+            }
+            else {
+                builder.addInput(utxo, this.unlocker, { sequence: this.sequence });
             }
-            let covenantHashType = -1;
-            const completeArgs = this.args.map((arg) => {
-                if (!(arg instanceof SignatureTemplate))
-                    return arg;
-                // First signature is used for sighash preimage (maybe not the best way)
-                if (covenantHashType < 0)
-                    covenantHashType = arg.getHashType();
-                const preimage = createSighashPreimage(transaction, sourceOutputs, i, bytecode, arg.getHashType());
-                const sighash = hash256(preimage);
-                return arg.generateSignature(sighash);
-            });
-            const preimage = this.abiFunction.covenant
-                ? createSighashPreimage(transaction, sourceOutputs, i, bytecode, covenantHashType)
-                : undefined;
-            const inputScript = createInputScript(this.redeemScript, completeArgs, this.selector, preimage);
-            inputScripts.push(inputScript);
-        });
-        inputScripts.forEach((script, i) => {
-            transaction.inputs[i].unlockingBytecode = script;
         });
-        return binToHex(encodeTransaction(transaction));
+        builder.addOutputs(this.outputs);
+        builder.setLocktime(this.locktime);
+        return builder.build();
     }
     async send(raw) {
         const tx = await this.build();
+        let template;
         try {
-            const txid = await this.provider.sendRawTransaction(tx);
+            if (this.contract.provider instanceof MockNetworkProvider) {
+                template = await buildTemplate({
+                    transaction: this,
+                    transactionHex: tx,
+                });
+                evaluateTemplate(template);
+            }
+            const txid = await this.contract.provider.sendRawTransaction(tx);
             return raw ? await this.getTxDetails(txid, raw) : await this.getTxDetails(txid);
         }
-        catch (e) {
-            const reason = e.error ?? e.message;
-            throw buildError(reason, meep(tx, this.inputs, this.redeemScript));
+        catch (maybeNodeError) {
+            if (!template) {
+                template = await buildTemplate({
+                    transaction: this,
+                    transactionHex: tx,
+                });
+            }
+            const reason = maybeNodeError.error ?? maybeNodeError.message ?? maybeNodeError;
+            const bitauthUri = getBitauthUri(template);
+            try {
+                debugTemplate(template, this.contract.artifact);
+            }
+            catch (libauthError) {
+                if (this.contract.provider instanceof MockNetworkProvider) {
+                    throw buildError(libauthError, bitauthUri);
+                }
+                else {
+                    const message = `${libauthError}\n\nUnderlying node error: ${reason}`;
+                    throw buildError(message, bitauthUri);
+                }
+            }
+            // this must be unreachable
+            throw buildError(reason, bitauthUri);
         }
     }
+    // method to debug the transaction with libauth VM, throws upon evaluation error
+    async debug() {
+        const template = await buildTemplate({
+            transaction: this,
+        });
+        return debugTemplate(template, this.contract.artifact);
+    }
+    async bitauthUri() {
+        const template = await buildTemplate({
+            transaction: this,
+        });
+        return getBitauthUri(template);
+    }
     async getTxDetails(txid, raw) {
         for (let retries = 0; retries < 1200; retries += 1) {
             await delay(500);
             try {
-                const hex = await this.provider.getRawTransaction(txid);
+                const hex = await this.contract.provider.getRawTransaction(txid);
                 if (raw)
                     return hex;
                 const libauthTransaction = decodeTransaction(hexToBin(hex));
@@ -171,15 +167,14 @@ export class Transaction {
         // Should not happen
         throw new Error('Could not retrieve transaction details for over 10 minutes');
     }
-    async meep() {
-        const tx = await this.build();
-        return meep(tx, this.inputs, this.redeemScript);
-    }
     async setInputsAndOutputs() {
         if (this.outputs.length === 0) {
             throw Error('Attempted to build a transaction without outputs');
         }
-        const allUtxos = await this.provider.getUtxos(this.address);
+        // Fetched utxos are only used when no inputs are available, so only fetch in that case.
+        const allUtxos = this.inputs.length === 0
+            ? await this.contract.provider.getUtxos(this.contract.address)
+            : [];
         const tokenInputs = this.inputs.length > 0
             ? this.inputs.filter((input) => input.token)
             : selectAllTokenUtxos(allUtxos, this.outputs);
@@ -188,7 +183,7 @@ export class Transaction {
             selectAllTokenUtxos(this.inputs, this.outputs);
         }
         if (this.tokenChange) {
-            const tokenChangeOutputs = createFungibleTokenChangeOutputs(tokenInputs, this.outputs, this.address);
+            const tokenChangeOutputs = createFungibleTokenChangeOutputs(tokenInputs, this.outputs, this.contract.tokenAddress);
             this.outputs.push(...tokenChangeOutputs);
         }
         // Construct list with all nfts in inputs
@@ -268,7 +263,7 @@ export class Transaction {
                             commitment: unusedNft.commitment,
                         },
                     };
-                    const nftChangeOutput = { to: this.address, amount: BigInt(1000), token: tokenDetails };
+                    const nftChangeOutput = { to: this.contract.tokenAddress, amount: BigInt(1000), token: tokenDetails };
                     this.outputs.push(nftChangeOutput);
                 }
             }
@@ -277,11 +272,11 @@ export class Transaction {
         const placeholderArgs = this.args.map((arg) => (arg instanceof SignatureTemplate ? placeholder(65) : arg));
         // Create a placeholder preimage of the correct size
         const placeholderPreimage = this.abiFunction.covenant
-            ? placeholder(getPreimageSize(scriptToBytecode(this.redeemScript)))
+            ? placeholder(getPreimageSize(scriptToBytecode(this.contract.redeemScript)))
             : undefined;
         // Create a placeholder input script for size calculation using the placeholder
         // arguments and correctly sized placeholder preimage
-        const placeholderScript = createInputScript(this.redeemScript, placeholderArgs, this.selector, placeholderPreimage);
+        const placeholderScript = createInputScript(this.contract.redeemScript, placeholderArgs, this.selector, placeholderPreimage);
         // Add one extra byte per input to over-estimate tx-in count
         const contractInputSize = getInputSize(placeholderScript) + 1;
         // Note that we use the addPrecision function to add "decimal points" to BigInt numbers
@@ -331,11 +326,11 @@ export class Transaction {
         }
         // Account for the fee of adding a change output
         if (!this.hardcodedFee) {
-            const changeOutputSize = getOutputSize({ to: this.address, amount: 0n });
+            const changeOutputSize = getOutputSize({ to: this.contract.address, amount: 0n });
             change -= BigInt(changeOutputSize * this.feePerByte);
         }
         // Add a change output if applicable
-        const changeOutput = { to: this.address, amount: change };
+        const changeOutput = { to: this.contract.address, amount: change };
         if (change >= this.minChange && change >= calculateDust(changeOutput)) {
             this.outputs.push(changeOutput);
         }

package/dist/{TransactionBuilder.js → src/TransactionBuilder.js}

@@ -1,7 +1,7 @@
 import { binToHex, decodeTransaction, encodeTransaction, hexToBin, } from '@bitauth/libauth';
 import delay from 'delay';
 import { isUnlockableUtxo, } from './interfaces.js';
-import { buildError, cashScriptOutputToLibauthOutput, createOpReturnOutput } from './utils.js';
+import { buildError, cashScriptOutputToLibauthOutput, createOpReturnOutput, validateOutput, } from './utils.js';
 const DEFAULT_SEQUENCE = 0xfffffffe;
 export class TransactionBuilder {
     constructor(options) {
@@ -26,10 +26,10 @@ export class TransactionBuilder {
         return this;
     }
     addOutput(output) {
-        this.outputs.push(output);
-        return this;
+        return this.addOutputs([output]);
     }
     addOutputs(outputs) {
+        outputs.forEach(validateOutput);
         this.outputs = this.outputs.concat(outputs);
         return this;
     }

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

@@ -6,6 +6,7 @@ export { TransactionBuilder } from './TransactionBuilder.js';
 export { Argument, encodeArgument } from './Argument.js';
 export { Artifact, AbiFunction, AbiInput } from '@cashscript/utils';
 export * as utils from '@cashscript/utils';
-export { Utxo, Recipient, SignatureAlgorithm, HashType, Network, isUtxoP2PKH, } from './interfaces.js';
+export * from './interfaces.js';
 export * from './Errors.js';
-export { NetworkProvider, BitcoinRpcNetworkProvider, ElectrumNetworkProvider, FullStackNetworkProvider, } from './network/index.js';
+export { NetworkProvider, BitcoinRpcNetworkProvider, ElectrumNetworkProvider, FullStackNetworkProvider, MockNetworkProvider, } from './network/index.js';
+export { randomUtxo, randomToken, randomNFT } from './utils.js';

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

@@ -5,7 +5,8 @@ export { Transaction } from './Transaction.js';
 export { TransactionBuilder } from './TransactionBuilder.js';
 export { encodeArgument } from './Argument.js';
 export * as utils from '@cashscript/utils';
-export { SignatureAlgorithm, HashType, Network, isUtxoP2PKH, } from './interfaces.js';
+export * from './interfaces.js';
 export * from './Errors.js';
-export { BitcoinRpcNetworkProvider, ElectrumNetworkProvider, FullStackNetworkProvider, } from './network/index.js';
+export { BitcoinRpcNetworkProvider, ElectrumNetworkProvider, FullStackNetworkProvider, MockNetworkProvider, } from './network/index.js';
+export { randomUtxo, randomToken, randomNFT } from './utils.js';
 //# sourceMappingURL=index.js.map

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

@@ -1,4 +1,4 @@
-import type { 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 {

package/dist/src/network/MockNetworkProvider.d.ts

@@ -0,0 +1,14 @@
+import { Utxo, Network } from '../interfaces.js';
+import NetworkProvider from './NetworkProvider.js';
+export default class MockNetworkProvider implements NetworkProvider {
+    private utxoMap;
+    private transactionMap;
+    network: Network;
+    constructor();
+    getUtxos(address: string): Promise<Utxo[]>;
+    getBlockHeight(): Promise<number>;
+    getRawTransaction(txid: string): Promise<string>;
+    sendRawTransaction(txHex: string): Promise<string>;
+    addUtxo(address: string, utxo: Utxo): void;
+    reset(): void;
+}

package/dist/src/network/MockNetworkProvider.js

@@ -0,0 +1,46 @@
+import { binToHex, hexToBin } from '@bitauth/libauth';
+import { sha256 } from '@cashscript/utils';
+import { Network } from '../interfaces.js';
+import { randomUtxo } from '../utils.js';
+// redeclare the addresses from vars.ts instead of importing them
+const aliceAddress = 'bchtest:qpgjmwev3spwlwkgmyjrr2s2cvlkkzlewq62mzgjnp';
+const bobAddress = 'bchtest:qz6q5gqnxdldkr07xpls5474mmzmlesd6qnux4skuc';
+const carolAddress = 'bchtest:qqsr7nqwe6rq5crj63gy5gdqchpnwmguusmr7tfmsj';
+export default class MockNetworkProvider {
+    constructor() {
+        this.utxoMap = {};
+        this.transactionMap = {};
+        this.network = Network.CHIPNET;
+        for (let i = 0; i < 3; i += 1) {
+            this.addUtxo(aliceAddress, randomUtxo());
+            this.addUtxo(bobAddress, randomUtxo());
+            this.addUtxo(carolAddress, randomUtxo());
+        }
+    }
+    async getUtxos(address) {
+        return this.utxoMap[address];
+    }
+    async getBlockHeight() {
+        return 133700;
+    }
+    async getRawTransaction(txid) {
+        return this.transactionMap[txid];
+    }
+    async sendRawTransaction(txHex) {
+        const transactionBin = hexToBin(txHex);
+        const txid = binToHex(sha256(sha256(transactionBin)).reverse());
+        this.transactionMap[txid] = txHex;
+        return txid;
+    }
+    addUtxo(address, utxo) {
+        if (!this.utxoMap[address]) {
+            this.utxoMap[address] = [];
+        }
+        this.utxoMap[address].push(utxo);
+    }
+    reset() {
+        this.utxoMap = {};
+        this.transactionMap = {};
+    }
+}
+//# sourceMappingURL=MockNetworkProvider.js.map

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

@@ -2,3 +2,4 @@ export { default as NetworkProvider } from './NetworkProvider.js';
 export { default as BitcoinRpcNetworkProvider } from './BitcoinRpcNetworkProvider.js';
 export { default as ElectrumNetworkProvider } from './ElectrumNetworkProvider.js';
 export { default as FullStackNetworkProvider } from './FullStackNetworkProvider.js';
+export { default as MockNetworkProvider } from './MockNetworkProvider.js';

package/dist/{network → src/network}/index.js

@@ -1,4 +1,5 @@
 export { default as BitcoinRpcNetworkProvider } from './BitcoinRpcNetworkProvider.js';
 export { default as ElectrumNetworkProvider } from './ElectrumNetworkProvider.js';
 export { default as FullStackNetworkProvider } from './FullStackNetworkProvider.js';
+export { default as MockNetworkProvider } from './MockNetworkProvider.js';
 //# sourceMappingURL=index.js.map

package/dist/{utils.d.ts → src/utils.d.ts}

@@ -1,9 +1,9 @@
 import { Transaction } from '@bitauth/libauth';
 import { Script } from '@cashscript/utils';
-import { Utxo, Output, Recipient, LibauthOutput } from './interfaces.js';
+import { Utxo, Output, LibauthOutput, TokenDetails } 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 validateOutput(output: Output): void;
+export declare function calculateDust(output: Output): number;
 export declare function getOutputSize(output: Output): number;
 export declare function encodeOutput(output: Output): Uint8Array;
 export declare function cashScriptOutputToLibauthOutput(output: Output): LibauthOutput;
@@ -14,8 +14,8 @@ 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, sourceOutputs: LibauthOutput[], 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 buildError(reason: string, debugStr?: string): FailedTransactionError;
+export declare function toRegExp(reasons: string[]): RegExp;
 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 publicKeyToP2PKHLockingBytecode(publicKey: Uint8Array): Uint8Array;
@@ -30,3 +30,6 @@ export declare function utxoTokenComparator(a: Utxo, b: Utxo): number;
 */
 export declare function addressToLockScript(address: string): Uint8Array;
 export declare function getNetworkPrefix(network: string): 'bitcoincash' | 'bchtest' | 'bchreg';
+export declare const randomUtxo: (defaults?: Partial<Utxo> | undefined) => Utxo;
+export declare const randomToken: (defaults?: Partial<TokenDetails> | undefined) => TokenDetails;
+export declare const randomNFT: (defaults?: Partial<TokenDetails> | undefined) => TokenDetails;

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

@@ -1,22 +1,24 @@
-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 { cashAddressToLockingBytecode, decodeCashAddress, addressContentsToLockingBytecode, lockingBytecodeToCashAddress, binToHex, generateSigningSerializationBCH, utf8ToBin, hexToBin, flattenBinArray, LockingBytecodeType, encodeTransactionOutput, isHex, bigIntToCompactSize, AuthenticationErrorCommon, NonFungibleTokenCapability, bigIntToVmNumber, } from '@bitauth/libauth';
+import { encodeInt, hash160, hash256, sha256, Op, scriptToBytecode, } from '@cashscript/utils';
 import { Network, } from './interfaces.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) {
-    const minimumAmount = calculateDust(recipient);
-    if (recipient.amount < minimumAmount) {
-        throw new OutputSatoshisTooSmallError(recipient.amount, BigInt(minimumAmount));
+export function validateOutput(output) {
+    if (typeof output.to !== 'string')
+        return;
+    const minimumAmount = calculateDust(output);
+    if (output.amount < minimumAmount) {
+        throw new OutputSatoshisTooSmallError(output.amount, BigInt(minimumAmount));
     }
-    if (recipient.token) {
-        if (!isTokenAddress(recipient.to)) {
-            throw new TokensToNonTokenAddressError(recipient.to);
+    if (output.token) {
+        if (!isTokenAddress(output.to)) {
+            throw new TokensToNonTokenAddressError(output.to);
         }
     }
 }
-export function calculateDust(recipient) {
-    const outputSize = getOutputSize(recipient);
+export function calculateDust(output) {
+    const outputSize = getOutputSize(output);
     // Formula used to calculate the minimum allowed output
     const dustAmount = 444 + outputSize * 3;
     return dustAmount;
@@ -29,6 +31,14 @@ export function encodeOutput(output) {
     return encodeTransactionOutput(cashScriptOutputToLibauthOutput(output));
 }
 export function cashScriptOutputToLibauthOutput(output) {
+    if (output.token) {
+        if (typeof output.token.category !== 'string' || !isHex(output.token.category)) {
+            throw new Error(`Provided token category ${output.token?.category} is not a hex string`);
+        }
+        if (output.token.nft && (typeof output.token.nft.commitment !== 'string' || !isHex(output.token.nft.commitment))) {
+            throw new Error(`Provided token commitment ${output.token.nft?.commitment} is not a hex string`);
+        }
+    }
     return {
         lockingBytecode: typeof output.to === 'string' ? addressToLockScript(output.to) : output.to,
         valueSatoshis: output.amount,
@@ -92,7 +102,7 @@ export function getTxSizeWithoutInputs(outputs) {
     let size = VERSION_SIZE + LOCKTIME_SIZE;
     size += outputs.reduce((acc, output) => acc + getOutputSize(output), 0);
     // Add tx-out count (accounting for a potential change output)
-    size += encodeInt(BigInt(outputs.length + 1)).byteLength;
+    size += bigIntToCompactSize(BigInt(outputs.length + 1)).byteLength;
     return size;
 }
 // ////////// BUILD OBJECTS ///////////////////////////////////////////////////
@@ -125,35 +135,35 @@ export function createSighashPreimage(transaction, sourceOutputs, inputIndex, co
     const sighashPreimage = generateSigningSerializationBCH(context, { coveredBytecode, signingSerializationType });
     return sighashPreimage;
 }
-export function buildError(reason, meepStr) {
+export function buildError(reason, debugStr) {
     const require = [
         Reason.EVAL_FALSE, Reason.VERIFY, Reason.EQUALVERIFY, Reason.CHECKMULTISIGVERIFY,
         Reason.CHECKSIGVERIFY, Reason.CHECKDATASIGVERIFY, Reason.NUMEQUALVERIFY,
+        AuthenticationErrorCommon.failedVerify,
+    ];
+    const timeCheck = [
+        Reason.NEGATIVE_LOCKTIME, Reason.UNSATISFIED_LOCKTIME,
+        AuthenticationErrorCommon.negativeLocktime, AuthenticationErrorCommon.unsatisfiedLocktime,
     ];
-    const timeCheck = [Reason.NEGATIVE_LOCKTIME, Reason.UNSATISFIED_LOCKTIME];
     const sigCheck = [
         Reason.SIG_COUNT, Reason.PUBKEY_COUNT, Reason.SIG_HASHTYPE, Reason.SIG_DER,
         Reason.SIG_HIGH_S, Reason.SIG_NULLFAIL, Reason.SIG_BADLENGTH, Reason.SIG_NONSCHNORR,
+        AuthenticationErrorCommon.nonNullSignatureFailure,
     ];
     if (toRegExp(require).test(reason)) {
-        return new FailedRequireError(reason, meepStr);
+        return new FailedRequireError(reason, debugStr);
     }
     if (toRegExp(timeCheck).test(reason)) {
-        return new FailedTimeCheckError(reason, meepStr);
+        return new FailedTimeCheckError(reason, debugStr);
     }
     if (toRegExp(sigCheck).test(reason)) {
-        return new FailedSigCheckError(reason, meepStr);
+        return new FailedSigCheckError(reason, debugStr);
     }
-    return new FailedTransactionError(reason, meepStr);
+    return new FailedTransactionError(reason, debugStr);
 }
-function toRegExp(reasons) {
+export function toRegExp(reasons) {
     return new RegExp(reasons.join('|').replace(/\(/g, '\\(').replace(/\)/g, '\\)'));
 }
-// ////////// MISC ////////////////////////////////////////////////////////////
-export function meep(tx, utxos, 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, addressType, tokenSupport) {
     const lockingBytecode = scriptToLockingBytecode(script, addressType);
     const prefix = getNetworkPrefix(network);
@@ -239,4 +249,31 @@ function getPushDataOpcode(data) {
         return Uint8Array.from([0x4c, byteLength]);
     throw Error('Pushdata too large');
 }
+const randomInt = () => BigInt(Math.floor(Math.random() * 10000));
+export const randomUtxo = (defaults) => ({
+    ...{
+        txid: binToHex(sha256(bigIntToVmNumber(randomInt()))),
+        vout: Math.floor(Math.random() * 10),
+        satoshis: 20000n + randomInt(),
+    },
+    ...defaults,
+});
+export const randomToken = (defaults) => ({
+    ...{
+        category: binToHex(sha256(bigIntToVmNumber(randomInt()))),
+        amount: 10000n + randomInt(),
+    },
+    ...defaults,
+});
+export const randomNFT = (defaults) => ({
+    ...{
+        category: binToHex(sha256(bigIntToVmNumber(randomInt()))),
+        amount: 0n,
+        nft: {
+            commitment: binToHex(sha256(bigIntToVmNumber(randomInt()))).slice(0, 8),
+            capability: NonFungibleTokenCapability.none,
+        },
+    },
+    ...defaults,
+});
 //# sourceMappingURL=utils.js.map

package/dist/test/JestExtensions.d.ts

@@ -0,0 +1,9 @@
+export {};
+declare global {
+    namespace jest {
+        interface Matchers<R> {
+            toLog(value: RegExp | string): Promise<void>;
+            toFailRequireWith(value: RegExp | string): Promise<void>;
+        }
+    }
+}

package/dist/test/JestExtensions.js

@@ -0,0 +1,66 @@
+import { printExpected, printReceived, matcherHint } from 'jest-matcher-utils';
+expect.extend({
+    async toLog(transaction, match) {
+        const spyOnLoggerError = jest.spyOn(console, 'log');
+        // silence actual stdout output
+        spyOnLoggerError.mockImplementation(() => { });
+        try {
+            await transaction.debug();
+        }
+        catch { }
+        let message = '';
+        const failMessage = (received, expected) => () => `${matcherHint('.toLog', 'received', 'expected')}
+
+Expected: ${printExpected(expected)}
+Received: ${printReceived(received)}`;
+        try {
+            expect(spyOnLoggerError).toBeCalledWith(expect.stringMatching(match));
+        }
+        catch (error) {
+            message = error;
+        }
+        const received = spyOnLoggerError.mock.calls[0][0];
+        spyOnLoggerError.mockClear();
+        return {
+            message: failMessage(received, match),
+            pass: !message,
+        };
+    },
+});
+expect.extend({
+    async toFailRequireWith(transaction, match) {
+        let message = '';
+        let failMessage = () => { };
+        try {
+            await transaction.debug();
+            failMessage = () => () => `${matcherHint('.toFailRequireWith', undefined, '')}
+
+Contract function did not fail a require statement`;
+        }
+        catch (error) {
+            message = error;
+        }
+        // should not have failed
+        if (this.isNot) {
+            return {
+                message: () => `${matcherHint('.toFailRequireWith', 'received', '', { isNot: true })}`,
+                pass: false,
+            };
+        }
+        if (message) {
+            try {
+                expect(message).toMatch(match);
+                message = '';
+            }
+            catch (error) {
+                message = error.message;
+                failMessage = () => () => message.replace('.toMatch', '.toFailRequireWith');
+            }
+        }
+        return {
+            message: failMessage(message, match),
+            pass: !message,
+        };
+    },
+});
+//# sourceMappingURL=JestExtensions.js.map