cashscript 0.10.0-next.6 → 0.10.1

package/README.md

@@ -1,7 +1,7 @@
 # CashScript
 
 ![Build Status](https://github.com/CashScript/cashscript/actions/workflows/github-actions.yml/badge.svg)
-[![Coverage Status](https://img.shields.io/codecov/c/github/Bitcoin-com/cashscript.svg)](https://codecov.io/gh/Bitcoin-com/cashscript/)
+[![Coverage Status](https://img.shields.io/codecov/c/github/CashScript/cashscript.svg)](https://codecov.io/gh/CashScript/cashscript/)
 [![NPM Version](https://img.shields.io/npm/v/cashscript.svg)](https://www.npmjs.com/package/cashscript)
 [![NPM Monthly Downloads](https://img.shields.io/npm/dm/cashscript.svg)](https://www.npmjs.com/package/cashscript)
 [![NPM License](https://img.shields.io/npm/l/cashscript.svg)](https://www.npmjs.com/package/cashscript)

package/dist/Argument.d.ts

@@ -1,9 +1,10 @@
 import { AbiFunction, Artifact } from '@cashscript/utils';
 import SignatureTemplate from './SignatureTemplate.js';
-export declare type Argument = bigint | boolean | string | Uint8Array | SignatureTemplate;
-export declare type EncodedArgument = Uint8Array | SignatureTemplate;
-export declare type EncodeFunction = (arg: Argument, typeStr: string) => EncodedArgument;
-export declare function encodeArgument(argument: Argument, typeStr: string): EncodedArgument;
-export declare const encodeConstructorArguments: (artifact: Artifact, constructorArgs: Argument[], encodeFunction?: EncodeFunction) => Uint8Array[];
-export declare const encodeFunctionArguments: (abiFunction: AbiFunction, functionArgs: Argument[], encodeFunction?: EncodeFunction) => EncodedArgument[];
-export declare function encodeArgumentForLibauthTemplate(argument: Argument, typeStr: string): Uint8Array | SignatureTemplate;
+export type ConstructorArgument = bigint | boolean | string | Uint8Array;
+export type FunctionArgument = ConstructorArgument | SignatureTemplate;
+export type EncodedConstructorArgument = Uint8Array;
+export type EncodedFunctionArgument = Uint8Array | SignatureTemplate;
+export type EncodeFunction = (arg: FunctionArgument, typeStr: string) => EncodedFunctionArgument;
+export declare function encodeFunctionArgument(argument: FunctionArgument, typeStr: string): EncodedFunctionArgument;
+export declare const encodeConstructorArguments: (artifact: Artifact, constructorArgs: ConstructorArgument[], encodeFunction?: EncodeFunction) => Uint8Array[];
+export declare const encodeFunctionArguments: (abiFunction: AbiFunction, functionArgs: FunctionArgument[], encodeFunction?: EncodeFunction) => EncodedFunctionArgument[];

package/dist/Argument.js

@@ -2,7 +2,7 @@ import { hexToBin } from '@bitauth/libauth';
 import { BytesType, encodeBool, encodeInt, encodeString, parseType, PrimitiveType, } from '@cashscript/utils';
 import { TypeError } from './Errors.js';
 import SignatureTemplate from './SignatureTemplate.js';
-export function encodeArgument(argument, typeStr) {
+export function encodeFunctionArgument(argument, typeStr) {
     let type = parseType(typeStr);
     if (type === PrimitiveType.BOOL) {
         if (typeof argument !== 'boolean') {
@@ -50,7 +50,7 @@ export function encodeArgument(argument, typeStr) {
     }
     return argument;
 }
-export const encodeConstructorArguments = (artifact, constructorArgs, encodeFunction = encodeArgument) => {
+export const encodeConstructorArguments = (artifact, constructorArgs, encodeFunction = encodeFunctionArgument) => {
     // Check there's no signature templates in the constructor
     if (constructorArgs.some((arg) => arg instanceof SignatureTemplate)) {
         throw new Error('Cannot use signatures in constructor');
@@ -59,15 +59,8 @@ export const encodeConstructorArguments = (artifact, constructorArgs, encodeFunc
         .map((arg, i) => encodeFunction(arg, artifact.constructorInputs[i].type));
     return encodedArgs;
 };
-export const encodeFunctionArguments = (abiFunction, functionArgs, encodeFunction = encodeArgument) => {
+export const encodeFunctionArguments = (abiFunction, functionArgs, encodeFunction = encodeFunctionArgument) => {
     const encodedArgs = functionArgs.map((arg, i) => encodeFunction(arg, abiFunction.inputs[i].type));
     return encodedArgs;
 };
-// Note: BitAuth IDE requires 0 to be encoded as a single byte (rather than the default empty byte array)
-// TODO: Double check this with Pat
-export function encodeArgumentForLibauthTemplate(argument, typeStr) {
-    if (typeStr === PrimitiveType.INT && argument === 0n)
-        return Uint8Array.from([0]);
-    return encodeArgument(argument, typeStr);
-}
 //# sourceMappingURL=Argument.js.map

package/dist/Contract.d.ts

@@ -1,6 +1,6 @@
 import { Artifact, Script } from '@cashscript/utils';
 import { Transaction } from './Transaction.js';
-import { Argument } from './Argument.js';
+import { ConstructorArgument, FunctionArgument } from './Argument.js';
 import { Unlocker, ContractOptions, Utxo, AddressType } from './interfaces.js';
 import NetworkProvider from './network/NetworkProvider.js';
 export declare class Contract {
@@ -18,11 +18,11 @@ export declare class Contract {
     provider: NetworkProvider;
     addressType: AddressType;
     encodedConstructorArgs: Uint8Array[];
-    constructor(artifact: Artifact, constructorArgs: Argument[], options?: ContractOptions | undefined);
+    constructor(artifact: Artifact, constructorArgs: ConstructorArgument[], options?: ContractOptions | undefined);
     getBalance(): Promise<bigint>;
     getUtxos(): Promise<Utxo[]>;
     private createFunction;
     private createUnlocker;
 }
-export declare type ContractFunction = (...args: Argument[]) => Transaction;
-export declare type ContractUnlocker = (...args: Argument[]) => Unlocker;
+export type ContractFunction = (...args: FunctionArgument[]) => Transaction;
+export type ContractUnlocker = (...args: FunctionArgument[]) => Unlocker;

package/dist/Contract.js

@@ -1,7 +1,7 @@
 import { binToHex } from '@bitauth/libauth';
 import { asmToScript, calculateBytesize, countOpcodes, generateRedeemScript, hash256, scriptToBytecode, } from '@cashscript/utils';
 import { Transaction } from './Transaction.js';
-import { encodeArgument, encodeConstructorArguments, encodeFunctionArguments } from './Argument.js';
+import { encodeFunctionArgument, encodeConstructorArguments, encodeFunctionArguments } from './Argument.js';
 import { addressToLockScript, createInputScript, createSighashPreimage, scriptToAddress, } from './utils.js';
 import SignatureTemplate from './SignatureTemplate.js';
 import { ElectrumNetworkProvider } from './network/index.js';
@@ -77,7 +77,7 @@ export class Contract {
             }
             const bytecode = scriptToBytecode(this.redeemScript);
             const encodedArgs = args
-                .map((arg, i) => encodeArgument(arg, abiFunction.inputs[i].type));
+                .map((arg, i) => encodeFunctionArgument(arg, abiFunction.inputs[i].type));
             const generateUnlockingBytecode = ({ transaction, sourceOutputs, inputIndex }) => {
                 // TODO: Remove old-style covenant code for v1.0 release
                 let covenantHashType = -1;

package/dist/Errors.d.ts

@@ -1,4 +1,4 @@
-import { RequireStatement, Type } from '@cashscript/utils';
+import { Artifact, RequireStatement, Type } from '@cashscript/utils';
 export declare class TypeError extends Error {
     constructor(actual: string, expected: Type);
 }
@@ -8,64 +8,28 @@ export declare class OutputSatoshisTooSmallError extends Error {
 export declare class TokensToNonTokenAddressError extends Error {
     constructor(address: string);
 }
+export declare class NoDebugInformationInArtifactError extends Error {
+    constructor();
+}
 export declare class FailedTransactionError extends Error {
     reason: string;
     bitauthUri?: string | undefined;
     constructor(reason: string, bitauthUri?: string | undefined);
 }
-export declare class FailedRequireError extends Error {
-    contractName: string;
+export declare class FailedTransactionEvaluationError extends FailedTransactionError {
+    artifact: Artifact;
+    failingInstructionPointer: number;
+    inputIndex: number;
+    bitauthUri: string;
+    libauthErrorMessage: string;
+    constructor(artifact: Artifact, failingInstructionPointer: number, inputIndex: number, bitauthUri: string, libauthErrorMessage: string);
+}
+export declare class FailedRequireError extends FailedTransactionError {
+    artifact: Artifact;
+    failingInstructionPointer: number;
     requireStatement: RequireStatement;
     inputIndex: number;
+    bitauthUri: string;
     libauthErrorMessage?: string | undefined;
-    bitauthUri?: string;
-    constructor(contractName: string, requireStatement: RequireStatement, inputIndex: number, libauthErrorMessage?: string | undefined);
-}
-export declare enum NodeErrorReason {
-    EVAL_FALSE = "Script evaluated without error but finished with a false/empty top stack element",
-    VERIFY = "Script failed an OP_VERIFY operation",
-    EQUALVERIFY = "Script failed an OP_EQUALVERIFY operation",
-    CHECKMULTISIGVERIFY = "Script failed an OP_CHECKMULTISIGVERIFY operation",
-    CHECKSIGVERIFY = "Script failed an OP_CHECKSIGVERIFY operation",
-    CHECKDATASIGVERIFY = "Script failed an OP_CHECKDATASIGVERIFY operation",
-    NUMEQUALVERIFY = "Script failed an OP_NUMEQUALVERIFY operation",
-    SCRIPT_SIZE = "Script is too big",
-    PUSH_SIZE = "Push value size limit exceeded",
-    OP_COUNT = "Operation limit exceeded",
-    STACK_SIZE = "Stack size limit exceeded",
-    SIG_COUNT = "Signature count negative or greater than pubkey count",
-    PUBKEY_COUNT = "Pubkey count negative or limit exceeded",
-    INVALID_OPERAND_SIZE = "Invalid operand size",
-    INVALID_NUMBER_RANGE = "Given operand is not a number within the valid range",
-    IMPOSSIBLE_ENCODING = "The requested encoding is impossible to satisfy",
-    INVALID_SPLIT_RANGE = "Invalid OP_SPLIT range",
-    INVALID_BIT_COUNT = "Invalid number of bit set in OP_CHECKMULTISIG",
-    BAD_OPCODE = "Opcode missing or not understood",
-    DISABLED_OPCODE = "Attempted to use a disabled opcode",
-    INVALID_STACK_OPERATION = "Operation not valid with the current stack size",
-    INVALID_ALTSTACK_OPERATION = "Operation not valid with the current altstack size",
-    OP_RETURN = "OP_RETURN was encountered",
-    UNBALANCED_CONDITIONAL = "Invalid OP_IF construction",
-    DIV_BY_ZERO = "Division by zero error",
-    MOD_BY_ZERO = "Modulo by zero error",
-    INVALID_BITFIELD_SIZE = "Bitfield of unexpected size error",
-    INVALID_BIT_RANGE = "Bitfield's bit out of the expected range",
-    NEGATIVE_LOCKTIME = "Negative locktime",
-    UNSATISFIED_LOCKTIME = "Locktime requirement not satisfied",
-    SIG_HASHTYPE = "Signature hash type missing or not understood",
-    SIG_DER = "Non-canonical DER signature",
-    MINIMALDATA = "Data push larger than necessary",
-    SIG_PUSHONLY = "Only push operators allowed in signature scripts",
-    SIG_HIGH_S = "Non-canonical signature: S value is unnecessarily high",
-    MINIMALIF = "OP_IF/NOTIF argument must be minimal",
-    SIG_NULLFAIL = "Signature must be zero for failed CHECK(MULTI)SIG operation",
-    SIG_BADLENGTH = "Signature cannot be 65 bytes in CHECKMULTISIG",
-    SIG_NONSCHNORR = "Only Schnorr signatures allowed in this operation",
-    DISCOURAGE_UPGRADABLE_NOPS = "NOPx reserved for soft-fork upgrades",
-    PUBKEYTYPE = "Public key is neither compressed or uncompressed",
-    CLEANSTACK = "Script did not clean its stack",
-    NONCOMPRESSED_PUBKEY = "Using non-compressed public key",
-    ILLEGAL_FORKID = "Illegal use of SIGHASH_FORKID",
-    MUST_USE_FORKID = "Signature must use SIGHASH_FORKID",
-    UNKNOWN = "unknown error"
+    constructor(artifact: Artifact, failingInstructionPointer: number, requireStatement: RequireStatement, inputIndex: number, bitauthUri: string, libauthErrorMessage?: string | undefined);
 }

package/dist/Errors.js

@@ -1,3 +1,4 @@
+import { sourceMapToLocationData } from '@cashscript/utils';
 export class TypeError extends Error {
     constructor(actual, expected) {
         super(`Found type '${actual}' where type '${expected.toString()}' was expected`);
@@ -13,73 +14,68 @@ export class TokensToNonTokenAddressError extends Error {
         super(`Tried to send tokens to an address without token support, ${address}.`);
     }
 }
+export class NoDebugInformationInArtifactError extends Error {
+    constructor() {
+        super('No debug information found in artifact, please recompile with cashc version 0.10.0 or newer.');
+    }
+}
 export class FailedTransactionError extends Error {
     constructor(reason, bitauthUri) {
-        super(`${reason}\n\nBitauth URI: ${bitauthUri}`);
+        super(`${reason}${bitauthUri ? `\n\nBitauth URI: ${bitauthUri}` : ''}`);
         this.reason = reason;
         this.bitauthUri = bitauthUri;
     }
 }
-// TODO: Add tests for some non-require evaluation errors (e.g. invalid op_split range)
-export class FailedRequireError extends Error {
-    constructor(contractName, requireStatement, inputIndex, libauthErrorMessage) {
-        const baseMessage = `${contractName}.cash:${requireStatement.line} Require statement failed at line ${requireStatement.line}`;
-        const fullMessage = `${baseMessage} with the following message: ${requireStatement.message}`;
-        super(requireStatement.message ? fullMessage : baseMessage);
-        this.contractName = contractName;
+export class FailedTransactionEvaluationError extends FailedTransactionError {
+    constructor(artifact, failingInstructionPointer, inputIndex, bitauthUri, libauthErrorMessage) {
+        let message = `${artifact.contractName}.cash Error in transaction at input ${inputIndex} in contract ${artifact.contractName}.cash.\nReason: ${libauthErrorMessage}`;
+        if (artifact.debug) {
+            const { statement, lineNumber } = getLocationDataForInstructionPointer(artifact, failingInstructionPointer);
+            message = `${artifact.contractName}.cash:${lineNumber} Error in transaction at input ${inputIndex} in contract ${artifact.contractName}.cash at line ${lineNumber}.\nReason: ${libauthErrorMessage}\nFailing statement: ${statement}`;
+        }
+        super(message, bitauthUri);
+        this.artifact = artifact;
+        this.failingInstructionPointer = failingInstructionPointer;
+        this.inputIndex = inputIndex;
+        this.bitauthUri = bitauthUri;
+        this.libauthErrorMessage = libauthErrorMessage;
+    }
+}
+export class FailedRequireError extends FailedTransactionError {
+    constructor(artifact, failingInstructionPointer, requireStatement, inputIndex, bitauthUri, libauthErrorMessage) {
+        let { statement, lineNumber } = getLocationDataForInstructionPointer(artifact, failingInstructionPointer);
+        if (!statement.includes('require')) {
+            statement = requireStatement.message
+                ? `require(${statement}, "${requireStatement.message}")`
+                : `require(${statement})`;
+            // Sometimes in reconstructed multiline require statements, we get double commas
+            statement = statement.replace(/,,/g, ',');
+        }
+        const baseMessage = `${artifact.contractName}.cash:${lineNumber} Require statement failed at input ${inputIndex} in contract ${artifact.contractName}.cash at line ${lineNumber}`;
+        const baseMessageWithRequireMessage = `${baseMessage} with the following message: ${requireStatement.message}`;
+        const fullMessage = `${requireStatement.message ? baseMessageWithRequireMessage : baseMessage}.\nFailing statement: ${statement}`;
+        super(fullMessage, bitauthUri);
+        this.artifact = artifact;
+        this.failingInstructionPointer = failingInstructionPointer;
         this.requireStatement = requireStatement;
         this.inputIndex = inputIndex;
+        this.bitauthUri = bitauthUri;
         this.libauthErrorMessage = libauthErrorMessage;
     }
 }
-// TODO: Expand these reasons with non-script failures (like tx-mempool-conflict)
-export var NodeErrorReason;
-(function (NodeErrorReason) {
-    NodeErrorReason["EVAL_FALSE"] = "Script evaluated without error but finished with a false/empty top stack element";
-    NodeErrorReason["VERIFY"] = "Script failed an OP_VERIFY operation";
-    NodeErrorReason["EQUALVERIFY"] = "Script failed an OP_EQUALVERIFY operation";
-    NodeErrorReason["CHECKMULTISIGVERIFY"] = "Script failed an OP_CHECKMULTISIGVERIFY operation";
-    NodeErrorReason["CHECKSIGVERIFY"] = "Script failed an OP_CHECKSIGVERIFY operation";
-    NodeErrorReason["CHECKDATASIGVERIFY"] = "Script failed an OP_CHECKDATASIGVERIFY operation";
-    NodeErrorReason["NUMEQUALVERIFY"] = "Script failed an OP_NUMEQUALVERIFY operation";
-    NodeErrorReason["SCRIPT_SIZE"] = "Script is too big";
-    NodeErrorReason["PUSH_SIZE"] = "Push value size limit exceeded";
-    NodeErrorReason["OP_COUNT"] = "Operation limit exceeded";
-    NodeErrorReason["STACK_SIZE"] = "Stack size limit exceeded";
-    NodeErrorReason["SIG_COUNT"] = "Signature count negative or greater than pubkey count";
-    NodeErrorReason["PUBKEY_COUNT"] = "Pubkey count negative or limit exceeded";
-    NodeErrorReason["INVALID_OPERAND_SIZE"] = "Invalid operand size";
-    NodeErrorReason["INVALID_NUMBER_RANGE"] = "Given operand is not a number within the valid range";
-    NodeErrorReason["IMPOSSIBLE_ENCODING"] = "The requested encoding is impossible to satisfy";
-    NodeErrorReason["INVALID_SPLIT_RANGE"] = "Invalid OP_SPLIT range";
-    NodeErrorReason["INVALID_BIT_COUNT"] = "Invalid number of bit set in OP_CHECKMULTISIG";
-    NodeErrorReason["BAD_OPCODE"] = "Opcode missing or not understood";
-    NodeErrorReason["DISABLED_OPCODE"] = "Attempted to use a disabled opcode";
-    NodeErrorReason["INVALID_STACK_OPERATION"] = "Operation not valid with the current stack size";
-    NodeErrorReason["INVALID_ALTSTACK_OPERATION"] = "Operation not valid with the current altstack size";
-    NodeErrorReason["OP_RETURN"] = "OP_RETURN was encountered";
-    NodeErrorReason["UNBALANCED_CONDITIONAL"] = "Invalid OP_IF construction";
-    NodeErrorReason["DIV_BY_ZERO"] = "Division by zero error";
-    NodeErrorReason["MOD_BY_ZERO"] = "Modulo by zero error";
-    NodeErrorReason["INVALID_BITFIELD_SIZE"] = "Bitfield of unexpected size error";
-    NodeErrorReason["INVALID_BIT_RANGE"] = "Bitfield's bit out of the expected range";
-    NodeErrorReason["NEGATIVE_LOCKTIME"] = "Negative locktime";
-    NodeErrorReason["UNSATISFIED_LOCKTIME"] = "Locktime requirement not satisfied";
-    NodeErrorReason["SIG_HASHTYPE"] = "Signature hash type missing or not understood";
-    NodeErrorReason["SIG_DER"] = "Non-canonical DER signature";
-    NodeErrorReason["MINIMALDATA"] = "Data push larger than necessary";
-    NodeErrorReason["SIG_PUSHONLY"] = "Only push operators allowed in signature scripts";
-    NodeErrorReason["SIG_HIGH_S"] = "Non-canonical signature: S value is unnecessarily high";
-    NodeErrorReason["MINIMALIF"] = "OP_IF/NOTIF argument must be minimal";
-    NodeErrorReason["SIG_NULLFAIL"] = "Signature must be zero for failed CHECK(MULTI)SIG operation";
-    NodeErrorReason["SIG_BADLENGTH"] = "Signature cannot be 65 bytes in CHECKMULTISIG";
-    NodeErrorReason["SIG_NONSCHNORR"] = "Only Schnorr signatures allowed in this operation";
-    NodeErrorReason["DISCOURAGE_UPGRADABLE_NOPS"] = "NOPx reserved for soft-fork upgrades";
-    NodeErrorReason["PUBKEYTYPE"] = "Public key is neither compressed or uncompressed";
-    NodeErrorReason["CLEANSTACK"] = "Script did not clean its stack";
-    NodeErrorReason["NONCOMPRESSED_PUBKEY"] = "Using non-compressed public key";
-    NodeErrorReason["ILLEGAL_FORKID"] = "Illegal use of SIGHASH_FORKID";
-    NodeErrorReason["MUST_USE_FORKID"] = "Signature must use SIGHASH_FORKID";
-    NodeErrorReason["UNKNOWN"] = "unknown error";
-})(NodeErrorReason || (NodeErrorReason = {}));
+const getLocationDataForInstructionPointer = (artifact, instructionPointer) => {
+    const locationData = sourceMapToLocationData(artifact.debug.sourceMap);
+    // We subtract the constructor inputs because these are present in the evaluation (and thus the instruction pointer)
+    // but they are not present in the source code (and thus the location data)
+    const modifiedInstructionPointer = instructionPointer - artifact.constructorInputs.length;
+    const { location } = locationData[modifiedInstructionPointer];
+    const failingLines = artifact.source.split('\n').slice(location.start.line - 1, location.end.line);
+    // Slice off the start and end of the statement's start and end lines to only return the failing part
+    // Note that we first slice off the end, to avoid shifting the end column index
+    failingLines[failingLines.length - 1] = failingLines[failingLines.length - 1].slice(0, location.end.column);
+    failingLines[0] = failingLines[0].slice(location.start.column);
+    const statement = failingLines.join('\n');
+    const lineNumber = location.start.line;
+    return { statement, lineNumber };
+};
 //# sourceMappingURL=Errors.js.map

package/dist/LibauthTemplate.js

@@ -1,49 +1,55 @@
-import { PrimitiveType, bytecodeToScript, formatBitAuthScript, } from '@cashscript/utils';
+import { bytecodeToScript, formatBitAuthScript, } from '@cashscript/utils';
 import { hexToBin, decodeTransaction, binToHex, binToBase64, utf8ToBin, isHex, } from '@bitauth/libauth';
 import { deflate } from 'pako';
-import { isUtxoP2PKH, } from './interfaces.js';
+import { isUtxoP2PKH, SignatureAlgorithm, HashType, } from './interfaces.js';
 import SignatureTemplate from './SignatureTemplate.js';
 import { addressToLockScript, extendedStringify, snakeCase, zip } from './utils.js';
-// TODO: Can we change this so we don't need to pass in both the transaction and the transactionHex?
 export const buildTemplate = async ({ transaction, transactionHex = undefined, // set this argument to prevent unnecessary call `transaction.build()`
  }) => {
     const contract = transaction.contract;
     const txHex = transactionHex ?? await transaction.build();
-    const hasSignatureTemplates = transaction.inputs.filter((input) => isUtxoP2PKH(input)).length > 0;
     const template = {
         $schema: 'https://ide.bitauth.com/authentication-template-v0.schema.json',
         description: 'Imported from cashscript',
         name: contract.artifact.contractName,
         supported: ['BCH_2023_05'],
         version: 0,
-        entities: generateTemplateEntities(contract.artifact, transaction.abiFunction),
+        entities: generateTemplateEntities(contract.artifact, transaction.abiFunction, transaction.encodedFunctionArgs),
         scripts: generateTemplateScripts(contract.artifact, contract.addressType, transaction.abiFunction, transaction.encodedFunctionArgs, contract.encodedConstructorArgs),
-        scenarios: generateTemplateScenarios(contract, transaction, txHex, contract.artifact, transaction.abiFunction, transaction.encodedFunctionArgs, contract.encodedConstructorArgs, hasSignatureTemplates),
+        scenarios: generateTemplateScenarios(contract, transaction, txHex, contract.artifact, transaction.abiFunction, transaction.encodedFunctionArgs, contract.encodedConstructorArgs),
     };
-    // add extra variables for the p2pkh utxos spent together with our contract
-    if (hasSignatureTemplates) {
-        template.entities.parameters.scripts.push('p2pkh_placeholder_lock', 'p2pkh_placeholder_unlock');
+    transaction.inputs
+        .forEach((input, index) => {
+        if (!isUtxoP2PKH(input))
+            return;
+        const lockScriptName = `p2pkh_placeholder_lock_${index}`;
+        const unlockScriptName = `p2pkh_placeholder_unlock_${index}`;
+        const placeholderKeyName = `placeholder_key_${index}`;
+        const signatureAlgorithmName = getSignatureAlgorithmName(input.template.getSignatureAlgorithm());
+        const hashtypeName = getHashTypeName(input.template.getHashType(false));
+        const signatureString = `${placeholderKeyName}.${signatureAlgorithmName}.${hashtypeName}`;
+        template.entities.parameters.scripts.push(lockScriptName, unlockScriptName);
         template.entities.parameters.variables = {
             ...template.entities.parameters.variables,
-            placeholder_key: {
-                description: 'placeholder_key',
-                name: 'placeholder_key',
+            [placeholderKeyName]: {
+                description: placeholderKeyName,
+                name: placeholderKeyName,
                 type: 'Key',
             },
         };
         // add extra unlocking and locking script for P2PKH inputs spent alongside our contract
-        // this is needed for correct cross-referrences in the template
-        template.scripts.p2pkh_placeholder_unlock = {
-            name: 'p2pkh_placeholder_unlock',
-            script: '<placeholder_key.schnorr_signature.all_outputs>\n<placeholder_key.public_key>',
-            unlocks: 'p2pkh_placeholder_lock',
+        // this is needed for correct cross-references in the template
+        template.scripts[unlockScriptName] = {
+            name: unlockScriptName,
+            script: `<${signatureString}>\n<${placeholderKeyName}.public_key>`,
+            unlocks: lockScriptName,
         };
-        template.scripts.p2pkh_placeholder_lock = {
+        template.scripts[lockScriptName] = {
             lockingType: 'standard',
-            name: 'p2pkh_placeholder_lock',
-            script: 'OP_DUP\nOP_HASH160 <$(<placeholder_key.public_key> OP_HASH160\n)> OP_EQUALVERIFY\nOP_CHECKSIG',
+            name: lockScriptName,
+            script: `OP_DUP\nOP_HASH160 <$(<${placeholderKeyName}.public_key> OP_HASH160\n)> OP_EQUALVERIFY\nOP_CHECKSIG`,
         };
-    }
+    });
     return template;
 };
 export const getBitauthUri = (template) => {
@@ -51,13 +57,13 @@ export const getBitauthUri = (template) => {
     const payload = base64toBase64Url(binToBase64(deflate(utf8ToBin(extendedStringify(template)))));
     return `https://ide.bitauth.com/import-template/${payload}`;
 };
-const generateTemplateEntities = (artifact, abiFunction) => {
-    const functionParameters = Object.fromEntries(abiFunction.inputs.map((input) => ([
+const generateTemplateEntities = (artifact, abiFunction, encodedFunctionArgs) => {
+    const functionParameters = Object.fromEntries(abiFunction.inputs.map((input, index) => ([
         snakeCase(input.name),
         {
             description: `"${input.name}" parameter of function "${abiFunction.name}"`,
             name: input.name,
-            type: input.type === PrimitiveType.SIG ? 'Key' : 'WalletData',
+            type: encodedFunctionArgs[index] instanceof SignatureTemplate ? 'Key' : 'WalletData',
         },
     ])));
     const constructorParameters = Object.fromEntries(artifact.constructorInputs.map((input) => ([
@@ -130,7 +136,7 @@ const generateTemplateUnlockScript = (artifact, abiFunction, encodedFunctionArgs
         unlocks: 'lock',
     };
 };
-const generateTemplateScenarios = (contract, transaction, transactionHex, artifact, abiFunction, encodedFunctionArgs, encodedConstructorArgs, hasSignatureTemplates) => {
+const generateTemplateScenarios = (contract, transaction, transactionHex, artifact, abiFunction, encodedFunctionArgs, encodedConstructorArgs) => {
     const libauthTransaction = decodeTransaction(hexToBin(transactionHex));
     if (typeof libauthTransaction === 'string')
         throw Error(libauthTransaction);
@@ -145,11 +151,10 @@ const generateTemplateScenarios = (contract, transaction, transactionHex, artifa
                     ...generateTemplateScenarioParametersValues(abiFunction.inputs, encodedFunctionArgs),
                     ...generateTemplateScenarioParametersValues(artifact.constructorInputs, encodedConstructorArgs),
                 },
-                // TODO: Don't hardcode these values
                 currentBlockHeight: 2,
                 currentBlockTime: Math.round(+new Date() / 1000),
                 keys: {
-                    privateKeys: generateTemplateScenarioKeys(abiFunction.inputs, encodedFunctionArgs, hasSignatureTemplates),
+                    privateKeys: generateTemplateScenarioKeys(abiFunction.inputs, encodedFunctionArgs),
                 },
             },
             transaction: generateTemplateScenarioTransaction(contract, libauthTransaction, transaction),
@@ -165,21 +170,17 @@ const generateTemplateScenarios = (contract, transaction, transactionHex, artifa
 const generateTemplateScenarioTransaction = (contract, libauthTransaction, csTransaction) => {
     const slotIndex = csTransaction.inputs.findIndex((input) => !isUtxoP2PKH(input));
     const inputs = libauthTransaction.inputs.map((input, index) => {
-        const csInput = csTransaction.inputs[index]; // TODO: Change
+        const csInput = csTransaction.inputs[index];
         return {
             outpointIndex: input.outpointIndex,
-            outpointTransactionHash: 
-            // TODO: This should always be Uint8Array according to the libauth transaction types
-            input.outpointTransactionHash instanceof Uint8Array
-                ? binToHex(input.outpointTransactionHash)
-                : input.outpointTransactionHash,
+            outpointTransactionHash: binToHex(input.outpointTransactionHash),
             sequenceNumber: input.sequenceNumber,
-            unlockingBytecode: generateTemplateScenarioBytecode(csInput, 'p2pkh_placeholder_unlock', index === slotIndex),
+            unlockingBytecode: generateTemplateScenarioBytecode(csInput, `p2pkh_placeholder_unlock_${index}`, `placeholder_key_${index}`, index === slotIndex),
         };
     });
     const locktime = libauthTransaction.locktime;
     const outputs = libauthTransaction.outputs.map((output, index) => {
-        const csOutput = csTransaction.outputs[index]; // TODO: Change
+        const csOutput = csTransaction.outputs[index];
         return {
             lockingBytecode: generateTemplateScenarioTransactionOutputLockingBytecode(csOutput, contract),
             token: serialiseTokenDetails(output.token),
@@ -200,21 +201,21 @@ const generateTemplateScenarioSourceOutputs = (csTransaction) => {
     const slotIndex = csTransaction.inputs.findIndex((input) => !isUtxoP2PKH(input));
     return csTransaction.inputs.map((input, index) => {
         return {
-            lockingBytecode: generateTemplateScenarioBytecode(input, 'p2pkh_placeholder_lock', index === slotIndex),
+            lockingBytecode: generateTemplateScenarioBytecode(input, `p2pkh_placeholder_lock_${index}`, `placeholder_key_${index}`, index === slotIndex),
             valueSatoshis: Number(input.satoshis),
             token: serialiseTokenDetails(input.token),
         };
     });
 };
 // Used for generating the locking / unlocking bytecode for source outputs and inputs
-const generateTemplateScenarioBytecode = (input, p2pkhScriptName, insertSlot) => {
+const generateTemplateScenarioBytecode = (input, p2pkhScriptName, placeholderKeyName, insertSlot) => {
     if (isUtxoP2PKH(input)) {
         return {
             script: p2pkhScriptName,
             overrides: {
                 keys: {
                     privateKeys: {
-                        placeholder_key: binToHex(input.template.privateKey),
+                        [placeholderKeyName]: binToHex(input.template.privateKey),
                     },
                 },
             },
@@ -229,21 +230,17 @@ const generateTemplateScenarioParametersValues = (types, encodedArgs) => {
         .filter(([, arg]) => !(arg instanceof SignatureTemplate))
         .map(([input, arg]) => {
         const encodedArgumentHex = binToHex(arg);
-        // TODO: Is this really necessary?
-        const prefixedEncodedArgument = encodedArgumentHex.length ? `0x${encodedArgumentHex}` : encodedArgumentHex;
+        const prefixedEncodedArgument = encodedArgumentHex.length > 0 ? `0x${encodedArgumentHex}` : '';
         return [snakeCase(input.name), prefixedEncodedArgument];
     });
     return Object.fromEntries(entries);
 };
-const generateTemplateScenarioKeys = (types, encodedArgs, hasSignatureTemplates) => {
+const generateTemplateScenarioKeys = (types, encodedArgs) => {
     const typesAndArguments = zip(types, encodedArgs);
     const entries = typesAndArguments
         .filter(([, arg]) => arg instanceof SignatureTemplate)
         .map(([input, arg]) => [snakeCase(input.name), binToHex(arg.privateKey)]);
-    const placeholderKey = hasSignatureTemplates
-        ? [['placeholder_key', '0x0000000000000000000000000000000000000000000000000000000000000000']]
-        : [];
-    return Object.fromEntries([...entries, ...placeholderKey]);
+    return Object.fromEntries(entries);
 };
 const formatParametersForDebugging = (types, args) => {
     if (types.length === 0)
@@ -252,8 +249,9 @@ const formatParametersForDebugging = (types, args) => {
     const typesAndArguments = zip(types, args).reverse();
     return typesAndArguments.map(([input, arg]) => {
         if (arg instanceof SignatureTemplate) {
-            // TODO: Different signing algorithms / hashtypes
-            return `<${snakeCase(input.name)}.schnorr_signature.all_outputs> // ${input.type}`;
+            const signatureAlgorithmName = getSignatureAlgorithmName(arg.getSignatureAlgorithm());
+            const hashtypeName = getHashTypeName(arg.getHashType(false));
+            return `<${snakeCase(input.name)}.${signatureAlgorithmName}.${hashtypeName}> // ${input.type}`;
         }
         const typeStr = input.type === 'bytes' ? `bytes${arg.length}` : input.type;
         // we output these values as pushdata, comment will contain the type and the value of the variable
@@ -261,9 +259,32 @@ const formatParametersForDebugging = (types, args) => {
         return `<${snakeCase(input.name)}> // ${typeStr} = <${`0x${binToHex(arg)}`}>`;
     }).join('\n');
 };
+const getSignatureAlgorithmName = (signatureAlgorithm) => {
+    const signatureAlgorithmNames = {
+        [SignatureAlgorithm.SCHNORR]: 'schnorr_signature',
+        [SignatureAlgorithm.ECDSA]: 'ecdsa_signature',
+    };
+    return signatureAlgorithmNames[signatureAlgorithm];
+};
+const getHashTypeName = (hashType) => {
+    const hashtypeNames = {
+        [HashType.SIGHASH_ALL]: 'all_outputs',
+        [HashType.SIGHASH_ALL | HashType.SIGHASH_ANYONECANPAY]: 'all_outputs_single_input',
+        [HashType.SIGHASH_ALL | HashType.SIGHASH_UTXOS]: 'all_outputs_all_utxos',
+        [HashType.SIGHASH_ALL | HashType.SIGHASH_ANYONECANPAY | HashType.SIGHASH_UTXOS]: 'all_outputs_single_input_INVALID_all_utxos',
+        [HashType.SIGHASH_SINGLE]: 'corresponding_output',
+        [HashType.SIGHASH_SINGLE | HashType.SIGHASH_ANYONECANPAY]: 'corresponding_output_single_input',
+        [HashType.SIGHASH_SINGLE | HashType.SIGHASH_UTXOS]: 'corresponding_output_all_utxos',
+        [HashType.SIGHASH_SINGLE | HashType.SIGHASH_ANYONECANPAY | HashType.SIGHASH_UTXOS]: 'corresponding_output_single_input_INVALID_all_utxos',
+        [HashType.SIGHASH_NONE]: 'no_outputs',
+        [HashType.SIGHASH_NONE | HashType.SIGHASH_ANYONECANPAY]: 'no_outputs_single_input',
+        [HashType.SIGHASH_NONE | HashType.SIGHASH_UTXOS]: 'no_outputs_all_utxos',
+        [HashType.SIGHASH_NONE | HashType.SIGHASH_ANYONECANPAY | HashType.SIGHASH_UTXOS]: 'no_outputs_single_input_INVALID_all_utxos',
+    };
+    return hashtypeNames[hashType];
+};
 const formatBytecodeForDebugging = (artifact) => {
     if (!artifact.debug) {
-        // TODO: See if we can merge this with code from @cashscript/utils -> script.ts
         return artifact.bytecode
             .split(' ')
             .map((asmElement) => (isHex(asmElement) ? `<0x${asmElement}>` : asmElement))
@@ -271,7 +292,6 @@ const formatBytecodeForDebugging = (artifact) => {
     }
     return formatBitAuthScript(bytecodeToScript(hexToBin(artifact.debug.bytecode)), artifact.debug.sourceMap, artifact.source);
 };
-// TODO: Maybe move / refactor
 const serialiseTokenDetails = (token) => {
     if (!token)
         return undefined;

package/dist/SignatureTemplate.d.ts

@@ -6,6 +6,7 @@ export default class SignatureTemplate {
     constructor(signer: Keypair | Uint8Array | string, hashtype?: HashType, signatureAlgorithm?: SignatureAlgorithm);
     generateSignature(payload: Uint8Array, bchForkId?: boolean): Uint8Array;
     getHashType(bchForkId?: boolean): number;
+    getSignatureAlgorithm(): SignatureAlgorithm;
     getPublicKey(): Uint8Array;
     unlockP2PKH(): Unlocker;
 }

package/dist/SignatureTemplate.js

@@ -27,6 +27,9 @@ export default class SignatureTemplate {
     getHashType(bchForkId = true) {
         return bchForkId ? (this.hashtype | SigningSerializationFlag.forkId) : this.hashtype;
     }
+    getSignatureAlgorithm() {
+        return this.signatureAlgorithm;
+    }
     getPublicKey() {
         return secp256k1.derivePublicKeyCompressed(this.privateKey);
     }

package/dist/Transaction.d.ts

@@ -4,12 +4,12 @@ import { Utxo, Output, Recipient, TokenDetails, TransactionDetails, Unlocker } f
 import SignatureTemplate from './SignatureTemplate.js';
 import { Contract } from './Contract.js';
 import { DebugResult } from './debugging.js';
-import { EncodedArgument } from './Argument.js';
+import { EncodedFunctionArgument } from './Argument.js';
 export declare class Transaction {
     contract: Contract;
     private unlocker;
     abiFunction: AbiFunction;
-    encodedFunctionArgs: EncodedArgument[];
+    encodedFunctionArgs: EncodedFunctionArgument[];
     private selector?;
     inputs: Utxo[];
     outputs: Output[];
@@ -19,7 +19,7 @@ export declare class Transaction {
     private hardcodedFee;
     private minChange;
     private tokenChange;
-    constructor(contract: Contract, unlocker: Unlocker, abiFunction: AbiFunction, encodedFunctionArgs: EncodedArgument[], selector?: number | undefined);
+    constructor(contract: Contract, unlocker: Unlocker, abiFunction: AbiFunction, encodedFunctionArgs: EncodedFunctionArgument[], selector?: number | undefined);
     from(input: Utxo): this;
     from(inputs: Utxo[]): this;
     fromP2PKH(input: Utxo, template: SignatureTemplate): this;

package/dist/Transaction.js

@@ -8,10 +8,9 @@ import { createInputScript, getInputSize, createOpReturnOutput, getTxSizeWithout
 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, getBitauthUri } from './LibauthTemplate.js';
-import { debugTemplate, evaluateTemplate } from './debugging.js';
-import { FailedRequireError, FailedTransactionError } from './Errors.js';
+import { debugTemplate } from './debugging.js';
+import { FailedTransactionError } from './Errors.js';
 export class Transaction {
     constructor(contract, unlocker, abiFunction, encodedFunctionArgs, selector) {
         this.contract = contract;
@@ -102,30 +101,12 @@ export class Transaction {
     }
     async send(raw) {
         const tx = await this.build();
-        let template;
         // Debug the transaction locally before sending so any errors are caught early
-        try {
-            // Libauth debugging does not work with old-style covenents (or outdated artifacts)
-            if (!this.abiFunction.covenant && this.contract.artifact.debug) {
-                await this.debug();
-            }
-        }
-        catch (error) {
-            if (error instanceof FailedRequireError) {
-                error.bitauthUri = await this.bitauthUri();
-                error.message += `\n\nBitauth URI: ${error.bitauthUri}`;
-            }
-            throw error;
+        // Libauth debugging does not work with old-style covenants
+        if (!this.abiFunction.covenant) {
+            await this.debug();
         }
         try {
-            // TODO: Can we move this to MockNetworkProvider?
-            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);
         }
@@ -136,6 +117,9 @@ export class Transaction {
     }
     // method to debug the transaction with libauth VM, throws upon evaluation error
     async debug() {
+        if (!this.contract.artifact.debug) {
+            console.warn('No debug information found in artifact. Recompile with cashc version 0.10.0 or newer to get better debugging information.');
+        }
         const template = await this.getLibauthTemplate();
         return debugTemplate(template, this.contract.artifact);
     }
@@ -165,7 +149,7 @@ export class Transaction {
     }
     async setInputsAndOutputs() {
         if (this.outputs.length === 0) {
-            throw Error('Attempted to build a transaction without outputs');
+            throw new Error('Attempted to build a transaction without outputs');
         }
         // Fetched utxos are only used when no inputs are available, so only fetch in that case.
         const allUtxos = this.inputs.length === 0
@@ -207,7 +191,7 @@ export class Transaction {
             // Compare nfts in- and outputs, check if inputs have nfts corresponding to outputs
             // Keep list of nfts in inputs without matching output
             // First check immutable nfts, then mutable & minting nfts together
-            // This is so an immutible input gets matched first and is removed from the list of unused nfts
+            // This is so an immutable input gets matched first and is removed from the list of unused nfts
             let unusedNfts = listNftsInputs;
             for (const nftInput of listNftsInputs) {
                 if (nftInput.capability === 'none') {

package/dist/TransactionBuilder.d.ts

@@ -4,9 +4,9 @@ export interface TransactionBuilderOptions {
     provider: NetworkProvider;
 }
 export declare class TransactionBuilder {
-    private provider;
-    private inputs;
-    private outputs;
+    provider: NetworkProvider;
+    inputs: UnlockableUtxo[];
+    outputs: Output[];
     private locktime;
     private maxFee?;
     constructor(options: TransactionBuilderOptions);

package/dist/TransactionBuilder.js

@@ -17,7 +17,7 @@ export class TransactionBuilder {
     addInputs(utxos, unlocker, options) {
         if ((!unlocker && utxos.some((utxo) => !isUnlockableUtxo(utxo)))
             || (unlocker && utxos.some((utxo) => isUnlockableUtxo(utxo)))) {
-            throw new Error('Either all UTXOs must have an individual unlocker speciifed, or no UTXOs must have an individual unlocker specified and a shared unlocker must be provided');
+            throw new Error('Either all UTXOs must have an individual unlocker specified, or no UTXOs must have an individual unlocker specified and a shared unlocker must be provided');
         }
         if (!unlocker) {
             this.inputs = this.inputs.concat(utxos);

package/dist/debugging.d.ts

@@ -1,5 +1,5 @@
 import { AuthenticationProgramStateCommon, WalletTemplate } from '@bitauth/libauth';
 import { Artifact } from '@cashscript/utils';
 export declare const evaluateTemplate: (template: WalletTemplate) => boolean;
-export declare type DebugResult = AuthenticationProgramStateCommon[];
+export type DebugResult = AuthenticationProgramStateCommon[];
 export declare const debugTemplate: (template: WalletTemplate, artifact: Artifact) => DebugResult;

package/dist/debugging.js

@@ -1,13 +1,14 @@
 import { AuthenticationErrorCommon, binToHex, createCompiler, createVirtualMachineBCH2023, encodeAuthenticationInstruction, walletTemplateToCompilerConfiguration } from '@bitauth/libauth';
 import { Op, PrimitiveType, bytecodeToAsm, decodeBool, decodeInt, decodeString } from '@cashscript/utils';
 import { findLastIndex, toRegExp } from './utils.js';
-import { FailedRequireError, FailedTransactionError } from './Errors.js';
+import { FailedRequireError, FailedTransactionError, FailedTransactionEvaluationError } from './Errors.js';
+import { getBitauthUri } from './LibauthTemplate.js';
 // evaluates the fully defined template, throws upon error
 export const evaluateTemplate = (template) => {
     const { vm, program } = createProgram(template);
     const verifyResult = vm.verify(program);
     if (typeof verifyResult === 'string') {
-        throw new FailedTransactionError(verifyResult);
+        throw new FailedTransactionError(verifyResult, getBitauthUri(template));
     }
     return verifyResult;
 };
@@ -36,31 +37,37 @@ export const debugTemplate = (template, artifact) => {
         const failingIp = lastExecutedDebugStep.ip - 1;
         // Generally speaking, an error is thrown by the OP_VERIFY opcode, but for NULLFAIL, the error is thrown in the
         // preceding OP_CHECKSIG opcode. The error message is registered in the next instruction, so we need to increment
-        // the instruction pointer to get the correct error message.
+        // the instruction pointer to get the correct error message from the require messages in the artifact.
+        // Note that we do NOT use this adjusted IP when passing the failing IP into the FailedRequireError
         const isNullFail = lastExecutedDebugStep.error === AuthenticationErrorCommon.nonNullSignatureFailure;
         const requireStatementIp = failingIp + (isNullFail ? 1 : 0);
         const requireStatement = (artifact.debug?.requires ?? [])
             .find((statement) => statement.ip === requireStatementIp);
-        // TODO: Also log the require statement that failed (e.g. "require(1 == 2, '1 is not equal to 2')")
+        const { program: { inputIndex }, error } = lastExecutedDebugStep;
         if (requireStatement) {
-            const { program: { inputIndex }, error } = lastExecutedDebugStep;
-            throw new FailedRequireError(artifact.contractName, requireStatement, inputIndex, error);
+            // Note that we use failingIp here rather than requireStatementIp, see comment above
+            throw new FailedRequireError(artifact, failingIp, requireStatement, inputIndex, getBitauthUri(template), error);
         }
-        throw new FailedTransactionError(`Error in evaluating input index ${lastExecutedDebugStep.program.inputIndex}.\n${lastExecutedDebugStep.error}`);
+        // Note that we use failingIp here rather than requireStatementIp, see comment above
+        throw new FailedTransactionEvaluationError(artifact, failingIp, inputIndex, getBitauthUri(template), error);
     }
     const evaluationResult = vm.verify(program);
     if (failedFinalVerify(evaluationResult)) {
         const finalExecutedVerifyIp = getFinalExecutedVerifyIp(executedDebugSteps);
+        // The final executed verify instruction points to the "implicit" VERIFY that is added at the end of the script.
+        // This instruction does not exist in the sourcemap, so we need to decrement the instruction pointer to get the
+        // actual final executed statement (which is *not* the require statement, but the evaluation within)
+        const sourcemapInstructionPointer = finalExecutedVerifyIp - 1;
         // logDebugSteps(executedDebugSteps, lastExecutedDebugStep.instructions);
         // console.warn('message', finalExecutedVerifyIp);
         // console.warn(artifact.debug?.requires);
         const requireStatement = (artifact.debug?.requires ?? [])
             .find((message) => message.ip === finalExecutedVerifyIp);
+        const { program: { inputIndex } } = lastExecutedDebugStep;
         if (requireStatement) {
-            const { program: { inputIndex }, error } = lastExecutedDebugStep;
-            throw new FailedRequireError(artifact.contractName, requireStatement, inputIndex, error);
+            throw new FailedRequireError(artifact, sourcemapInstructionPointer, requireStatement, inputIndex, getBitauthUri(template));
         }
-        throw new FailedTransactionError(`Error in evaluating input index ${lastExecutedDebugStep.program.inputIndex}.\n${evaluationResult}`);
+        throw new FailedTransactionEvaluationError(artifact, sourcemapInstructionPointer, inputIndex, getBitauthUri(template), evaluationResult);
     }
     return fullDebugSteps;
 };
@@ -76,10 +83,10 @@ const createProgram = (template) => {
         scenarioId: 'evaluate_function',
     });
     if (typeof scenarioGeneration === 'string') {
-        throw new FailedTransactionError(scenarioGeneration);
+        throw new FailedTransactionError(scenarioGeneration, getBitauthUri(template));
     }
     if (typeof scenarioGeneration.scenario === 'string') {
-        throw new FailedTransactionError(scenarioGeneration.scenario);
+        throw new FailedTransactionError(scenarioGeneration.scenario, getBitauthUri(template));
     }
     return { vm, program: scenarioGeneration.scenario.program };
 };

package/dist/index.d.ts

@@ -1,12 +1,11 @@
-import SignatureTemplate from './SignatureTemplate.js';
-export { SignatureTemplate };
-export { Contract, ContractFunction } from './Contract.js';
+export { default as SignatureTemplate } from './SignatureTemplate.js';
+export { Contract, type ContractFunction } from './Contract.js';
 export { Transaction } from './Transaction.js';
 export { TransactionBuilder } from './TransactionBuilder.js';
-export { Argument, encodeArgument } from './Argument.js';
-export { Artifact, AbiFunction, AbiInput } from '@cashscript/utils';
+export { type ConstructorArgument, type FunctionArgument, type EncodedConstructorArgument, type EncodedFunctionArgument, encodeFunctionArgument, } from './Argument.js';
+export type { Artifact, AbiFunction, AbiInput } from '@cashscript/utils';
 export * as utils from '@cashscript/utils';
 export * from './interfaces.js';
 export * from './Errors.js';
-export { NetworkProvider, BitcoinRpcNetworkProvider, ElectrumNetworkProvider, FullStackNetworkProvider, MockNetworkProvider, } from './network/index.js';
+export { type NetworkProvider, BitcoinRpcNetworkProvider, ElectrumNetworkProvider, FullStackNetworkProvider, MockNetworkProvider, } from './network/index.js';
 export { randomUtxo, randomToken, randomNFT } from './utils.js';

package/dist/index.js

@@ -1,9 +1,8 @@
-import SignatureTemplate from './SignatureTemplate.js';
-export { SignatureTemplate };
+export { default as SignatureTemplate } from './SignatureTemplate.js';
 export { Contract } from './Contract.js';
 export { Transaction } from './Transaction.js';
 export { TransactionBuilder } from './TransactionBuilder.js';
-export { encodeArgument } from './Argument.js';
+export { encodeFunctionArgument, } from './Argument.js';
 export * as utils from '@cashscript/utils';
 export * from './interfaces.js';
 export * from './Errors.js';

package/dist/interfaces.d.ts

@@ -80,9 +80,10 @@ export declare const Network: {
     TESTNET3: "testnet3";
     TESTNET4: "testnet4";
     CHIPNET: "chipnet";
+    MOCKNET: "mocknet";
     REGTEST: "regtest";
 };
-export declare type Network = (typeof Network)[keyof typeof Network];
+export type Network = (typeof Network)[keyof typeof Network];
 export interface TransactionDetails extends Transaction {
     txid: string;
     hex: string;
@@ -91,4 +92,4 @@ export interface ContractOptions {
     provider?: NetworkProvider;
     addressType?: AddressType;
 }
-export declare type AddressType = 'p2sh20' | 'p2sh32';
+export type AddressType = 'p2sh20' | 'p2sh32';

package/dist/interfaces.js

@@ -25,6 +25,7 @@ export const Network = {
     TESTNET3: literal('testnet3'),
     TESTNET4: literal('testnet4'),
     CHIPNET: literal('chipnet'),
+    MOCKNET: literal('mocknet'),
     REGTEST: literal('regtest'),
 };
 //# sourceMappingURL=interfaces.js.map

package/dist/network/MockNetworkProvider.js

@@ -10,7 +10,7 @@ export default class MockNetworkProvider {
     constructor() {
         this.utxoMap = {};
         this.transactionMap = {};
-        this.network = Network.CHIPNET;
+        this.network = Network.MOCKNET;
         for (let i = 0; i < 3; i += 1) {
             this.addUtxo(aliceAddress, randomUtxo());
             this.addUtxo(bobAddress, randomUtxo());

package/dist/network/index.d.ts

@@ -1,4 +1,4 @@
-export { default as NetworkProvider } from './NetworkProvider.js';
+export type { 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';

package/dist/test/JestExtensions.d.ts

@@ -4,6 +4,7 @@ declare global {
         interface Matchers<R> {
             toLog(value?: RegExp | string): Promise<void>;
             toFailRequireWith(value: RegExp | string): Promise<void>;
+            toFailRequire(): Promise<void>;
         }
     }
 }

package/dist/test/JestExtensions.js

@@ -29,7 +29,7 @@ expect.extend({
         try {
             await transaction.debug();
             const matcherHint = this.utils.matcherHint('.toFailRequireWith', undefined, match.toString(), { isNot: this.isNot });
-            const message = () => `${matcherHint}\n\nContract function did not fail a require statement`;
+            const message = () => `${matcherHint}\n\nContract function did not fail a require statement.`;
             return { message, pass: false };
         }
         catch (transactionError) {
@@ -46,6 +46,18 @@ expect.extend({
             }
         }
     },
+    async toFailRequire(transaction) {
+        try {
+            await transaction.debug();
+            const message = () => 'Contract function did not fail a require statement.';
+            return { message, pass: false };
+        }
+        catch (transactionError) {
+            const receivedText = `Received string: ${this.utils.printReceived(transactionError?.message ?? '')}`;
+            const message = () => `Contract function failed a require statement.\n${receivedText}`;
+            return { message, pass: true };
+        }
+    },
 });
 export {};
 //# sourceMappingURL=JestExtensions.js.map

package/dist/utils.d.ts

@@ -28,10 +28,10 @@ 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;
+export declare const randomUtxo: (defaults?: Partial<Utxo>) => Utxo;
+export declare const randomToken: (defaults?: Partial<TokenDetails>) => TokenDetails;
+export declare const randomNFT: (defaults?: Partial<TokenDetails>) => TokenDetails;
 export declare function findLastIndex<T>(array: Array<T>, predicate: (value: T, index: number, obj: T[]) => boolean): number;
 export declare const snakeCase: (str: string) => string;
-export declare const extendedStringify: (obj: any, spaces?: number | undefined) => string;
+export declare const extendedStringify: (obj: any, spaces?: number) => string;
 export declare const zip: <T, U>(a: T[], b: U[]) => [T, U][];

package/dist/utils.js

@@ -139,10 +139,12 @@ export function toRegExp(reasons) {
     return new RegExp(reasons.join('|').replace(/\(/g, '\\(').replace(/\)/g, '\\)'));
 }
 export function scriptToAddress(script, network, addressType, tokenSupport) {
-    const lockingBytecode = scriptToLockingBytecode(script, addressType);
+    const bytecode = scriptToLockingBytecode(script, addressType);
     const prefix = getNetworkPrefix(network);
-    const address = lockingBytecodeToCashAddress(lockingBytecode, prefix, { tokenSupport });
-    return address;
+    const result = lockingBytecodeToCashAddress({ bytecode, prefix, tokenSupport });
+    if (typeof result === 'string')
+        throw new Error(result);
+    return result.address;
 }
 export function scriptToLockingBytecode(script, addressType) {
     const scriptBytecode = scriptToBytecode(script);
@@ -195,6 +197,7 @@ export function getNetworkPrefix(network) {
         case Network.TESTNET4:
         case Network.TESTNET3:
         case Network.CHIPNET:
+        case Network.MOCKNET:
             return 'bchtest';
         case Network.REGTEST:
             return 'bchreg';
@@ -221,7 +224,7 @@ function getPushDataOpcode(data) {
         return Uint8Array.from([byteLength]);
     if (byteLength < 256)
         return Uint8Array.from([0x4c, byteLength]);
-    throw Error('Pushdata too large');
+    throw new Error('Pushdata too large');
 }
 const randomInt = () => BigInt(Math.floor(Math.random() * 10000));
 export const randomUtxo = (defaults) => ({

package/jest/package.json

@@ -0,0 +1,5 @@
+{
+  "type": "module",
+  "types": "../dist/test/JestExtensions.d.ts",
+  "main": "../dist/test/JestExtensions.js"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cashscript",
-  "version": "0.10.0-next.6",
+  "version": "0.10.1",
   "description": "Easily write and interact with Bitcoin Cash contracts",
   "keywords": [
     "bitcoin cash",
@@ -10,11 +10,11 @@
   ],
   "homepage": "https://cashscript.org",
   "bugs": {
-    "url": "https://github.com/Bitcoin-com/cashscript/issues"
+    "url": "https://github.com/CashScript/cashscript/issues"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/Bitcoin-com/cashscript.git"
+    "url": "git+https://github.com/CashScript/cashscript.git"
   },
   "license": "MIT",
   "author": "Rosco Kalis <roscokalis@gmail.com>",
@@ -43,8 +43,8 @@
     "test": "NODE_OPTIONS='--experimental-vm-modules --no-warnings' jest"
   },
   "dependencies": {
-    "@bitauth/libauth": "^2.0.0",
-    "@cashscript/utils": "^0.10.0-next.6",
+    "@bitauth/libauth": "^3.0.0",
+    "@cashscript/utils": "^0.10.1",
     "bip68": "^1.0.4",
     "bitcoin-rpc-promise-retry": "^1.3.0",
     "delay": "^5.0.0",
@@ -59,7 +59,7 @@
     "bip39": "^3.0.4",
     "eslint": "^8.54.0",
     "jest": "^29.4.1",
-    "typescript": "^4.1.5"
+    "typescript": "^5.5.4"
   },
-  "gitHead": "b26f1f20b89df6d857a5860eebd3bcc7668faa4e"
+  "gitHead": "0dd95d5b05a438ac1884bdb2252aec6a4c77e5b2"
 }