cashscript 0.10.0-next.5 → 0.10.0

package/README.md

@@ -1,14 +1,14 @@
 # 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)
 
 CashScript is a high-level programming language for smart contracts on Bitcoin Cash. It offers a strong abstraction layer over Bitcoin Cash' native virtual machine, Bitcoin Script. Its syntax is based on Ethereum's smart contract language Solidity, but its functionality is very different since smart contracts on Bitcoin Cash differ greatly from smart contracts on Ethereum. For a detailed comparison of them, refer to the blog post [*Smart Contracts on Ethereum, Bitcoin and Bitcoin Cash*](https://kalis.me/smart-contracts-eth-btc-bch/).
 
-See the [GitHub repository](https://github.com/Bitcoin-com/cashscript) and the [CashScript website](https://cashscript.org) for full documentation and usage examples.
+See the [GitHub repository](https://github.com/CashScript/cashscript) and the [CashScript website](https://cashscript.org) for full documentation and usage examples.
 
 ## The CashScript Language
 CashScript is a high-level language that allows you to write Bitcoin Cash smart contracts in a straightforward and familiar way. Its syntax is inspired by Ethereum's Solidity language, but its functionality is different since the underlying systems have very different fundamentals. See the [language documentation](https://cashscript.org/docs/language/) for a full reference of the language.

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';
@@ -16,7 +16,7 @@ export class Contract {
             throw new Error('Invalid or incomplete artifact provided');
         }
         if (artifact.constructorInputs.length !== constructorArgs.length) {
-            throw new Error(`Incorrect number of arguments passed to ${artifact.contractName} constructor`);
+            throw new Error(`Incorrect number of arguments passed to ${artifact.contractName} constructor. Expected ${artifact.constructorInputs.length} arguments (${artifact.constructorInputs.map(input => input.type)}) but got ${constructorArgs.length}`);
         }
         // Encode arguments (this also performs type checking)
         this.encodedConstructorArgs = encodeConstructorArguments(artifact, constructorArgs);
@@ -62,7 +62,7 @@ export class Contract {
     createFunction(abiFunction, selector) {
         return (...args) => {
             if (abiFunction.inputs.length !== args.length) {
-                throw new Error(`Incorrect number of arguments passed to function ${abiFunction.name}`);
+                throw new Error(`Incorrect number of arguments passed to function ${abiFunction.name}. Expected ${abiFunction.inputs.length} arguments (${abiFunction.inputs.map(input => input.type)}) but got ${args.length}`);
             }
             // Encode passed args (this also performs type checking)
             const encodedArgs = encodeFunctionArguments(abiFunction, args);
@@ -72,9 +72,12 @@ export class Contract {
     }
     createUnlocker(abiFunction, selector) {
         return (...args) => {
+            if (abiFunction.inputs.length !== args.length) {
+                throw new Error(`Incorrect number of arguments passed to function ${abiFunction.name}. Expected ${abiFunction.inputs.length} arguments (${abiFunction.inputs.map(input => input.type)}) but got ${args.length}`);
+            }
             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 { Type } from '@cashscript/utils';
+import { Artifact, RequireStatement, Type } from '@cashscript/utils';
 export declare class TypeError extends Error {
     constructor(actual: string, expected: Type);
 }
@@ -8,62 +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;
-    debugStr?: string | undefined;
-    constructor(reason: string, debugStr?: string | undefined);
-}
-export declare class FailedRequireError extends FailedTransactionError {
+    bitauthUri?: string | undefined;
+    constructor(reason: string, bitauthUri?: string | undefined);
 }
-export declare class FailedTimeCheckError extends FailedTransactionError {
+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 FailedSigCheckError extends FailedTransactionError {
-}
-export declare enum Reason {
-    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"
+export declare class FailedRequireError extends FailedTransactionError {
+    artifact: Artifact;
+    failingInstructionPointer: number;
+    requireStatement: RequireStatement;
+    inputIndex: number;
+    bitauthUri: string;
+    libauthErrorMessage?: string | undefined;
+    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,67 +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, debugStr) {
-        super(`Transaction failed with reason: ${reason}${debugStr ? `\n\n${debugStr}` : ''}`);
+    constructor(reason, bitauthUri) {
+        super(`${reason}${bitauthUri ? `\n\nBitauth URI: ${bitauthUri}` : ''}`);
         this.reason = reason;
-        this.debugStr = debugStr;
+        this.bitauthUri = bitauthUri;
     }
 }
-export class FailedRequireError extends FailedTransactionError {
-}
-export class FailedTimeCheckError extends FailedTransactionError {
+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 FailedSigCheckError extends FailedTransactionError {
+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 Reason;
-(function (Reason) {
-    Reason["EVAL_FALSE"] = "Script evaluated without error but finished with a false/empty top stack element";
-    Reason["VERIFY"] = "Script failed an OP_VERIFY operation";
-    Reason["EQUALVERIFY"] = "Script failed an OP_EQUALVERIFY operation";
-    Reason["CHECKMULTISIGVERIFY"] = "Script failed an OP_CHECKMULTISIGVERIFY operation";
-    Reason["CHECKSIGVERIFY"] = "Script failed an OP_CHECKSIGVERIFY operation";
-    Reason["CHECKDATASIGVERIFY"] = "Script failed an OP_CHECKDATASIGVERIFY operation";
-    Reason["NUMEQUALVERIFY"] = "Script failed an OP_NUMEQUALVERIFY operation";
-    Reason["SCRIPT_SIZE"] = "Script is too big";
-    Reason["PUSH_SIZE"] = "Push value size limit exceeded";
-    Reason["OP_COUNT"] = "Operation limit exceeded";
-    Reason["STACK_SIZE"] = "Stack size limit exceeded";
-    Reason["SIG_COUNT"] = "Signature count negative or greater than pubkey count";
-    Reason["PUBKEY_COUNT"] = "Pubkey count negative or limit exceeded";
-    Reason["INVALID_OPERAND_SIZE"] = "Invalid operand size";
-    Reason["INVALID_NUMBER_RANGE"] = "Given operand is not a number within the valid range";
-    Reason["IMPOSSIBLE_ENCODING"] = "The requested encoding is impossible to satisfy";
-    Reason["INVALID_SPLIT_RANGE"] = "Invalid OP_SPLIT range";
-    Reason["INVALID_BIT_COUNT"] = "Invalid number of bit set in OP_CHECKMULTISIG";
-    Reason["BAD_OPCODE"] = "Opcode missing or not understood";
-    Reason["DISABLED_OPCODE"] = "Attempted to use a disabled opcode";
-    Reason["INVALID_STACK_OPERATION"] = "Operation not valid with the current stack size";
-    Reason["INVALID_ALTSTACK_OPERATION"] = "Operation not valid with the current altstack size";
-    Reason["OP_RETURN"] = "OP_RETURN was encountered";
-    Reason["UNBALANCED_CONDITIONAL"] = "Invalid OP_IF construction";
-    Reason["DIV_BY_ZERO"] = "Division by zero error";
-    Reason["MOD_BY_ZERO"] = "Modulo by zero error";
-    Reason["INVALID_BITFIELD_SIZE"] = "Bitfield of unexpected size error";
-    Reason["INVALID_BIT_RANGE"] = "Bitfield's bit out of the expected range";
-    Reason["NEGATIVE_LOCKTIME"] = "Negative locktime";
-    Reason["UNSATISFIED_LOCKTIME"] = "Locktime requirement not satisfied";
-    Reason["SIG_HASHTYPE"] = "Signature hash type missing or not understood";
-    Reason["SIG_DER"] = "Non-canonical DER signature";
-    Reason["MINIMALDATA"] = "Data push larger than necessary";
-    Reason["SIG_PUSHONLY"] = "Only push operators allowed in signature scripts";
-    Reason["SIG_HIGH_S"] = "Non-canonical signature: S value is unnecessarily high";
-    Reason["MINIMALIF"] = "OP_IF/NOTIF argument must be minimal";
-    Reason["SIG_NULLFAIL"] = "Signature must be zero for failed CHECK(MULTI)SIG operation";
-    Reason["SIG_BADLENGTH"] = "Signature cannot be 65 bytes in CHECKMULTISIG";
-    Reason["SIG_NONSCHNORR"] = "Only Schnorr signatures allowed in this operation";
-    Reason["DISCOURAGE_UPGRADABLE_NOPS"] = "NOPx reserved for soft-fork upgrades";
-    Reason["PUBKEYTYPE"] = "Public key is neither compressed or uncompressed";
-    Reason["CLEANSTACK"] = "Script did not clean its stack";
-    Reason["NONCOMPRESSED_PUBKEY"] = "Using non-compressed public key";
-    Reason["ILLEGAL_FORKID"] = "Illegal use of SIGHASH_FORKID";
-    Reason["MUST_USE_FORKID"] = "Signature must use SIGHASH_FORKID";
-    Reason["UNKNOWN"] = "unknown error";
-})(Reason || (Reason = {}));
+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',
+        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}`, 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,7 +201,7 @@ 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}`, index === slotIndex),
             valueSatoshis: Number(input.satoshis),
             token: serialiseTokenDetails(input.token),
         };
@@ -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

@@ -4,13 +4,13 @@ import delay from 'delay';
 import { placeholder, scriptToBytecode, } from '@cashscript/utils';
 import deepEqual from 'fast-deep-equal';
 import { isUtxoP2PKH, } from './interfaces.js';
-import { createInputScript, getInputSize, createOpReturnOutput, getTxSizeWithoutInputs, getPreimageSize, buildError, validateOutput, utxoComparator, calculateDust, getOutputSize, utxoTokenComparator, } from './utils.js';
+import { createInputScript, getInputSize, createOpReturnOutput, getTxSizeWithoutInputs, getPreimageSize, 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, getBitauthUri } from './LibauthTemplate.js';
-import { debugTemplate, evaluateTemplate } from './debugging.js';
+import { debugTemplate } from './debugging.js';
+import { FailedTransactionError } from './Errors.js';
 export class Transaction {
     constructor(contract, unlocker, abiFunction, encodedFunctionArgs, selector) {
         this.contract = contract;
@@ -101,45 +101,25 @@ 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
+        // Libauth debugging does not work with old-style covenants
+        if (!this.abiFunction.covenant) {
+            await this.debug();
+        }
         try {
-            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 (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);
+        catch (error) {
+            const reason = error.error ?? error.message ?? error;
+            throw new FailedTransactionError(reason, await this.bitauthUri());
         }
     }
     // 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);
     }
@@ -169,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

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

@@ -1,7 +1,8 @@
 import { binToHex, decodeTransaction, encodeTransaction, hexToBin, } from '@bitauth/libauth';
 import delay from 'delay';
 import { isUnlockableUtxo, } from './interfaces.js';
-import { buildError, cashScriptOutputToLibauthOutput, createOpReturnOutput, validateOutput, } from './utils.js';
+import { cashScriptOutputToLibauthOutput, createOpReturnOutput, validateOutput, } from './utils.js';
+import { FailedTransactionError } from './Errors.js';
 const DEFAULT_SEQUENCE = 0xfffffffe;
 export class TransactionBuilder {
     constructor(options) {
@@ -94,7 +95,7 @@ export class TransactionBuilder {
         }
         catch (e) {
             const reason = e.error ?? e.message;
-            throw buildError(reason);
+            throw new FailedTransactionError(reason);
         }
     }
     async getTxDetails(txid, raw) {

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,12 +1,14 @@
-import { AuthenticationErrorCommon, binToHex, createCompiler, createVirtualMachineBCH2023, walletTemplateToCompilerConfiguration } from '@bitauth/libauth';
-import { Op, PrimitiveType, decodeBool, decodeInt, decodeString } from '@cashscript/utils';
+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, 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 Error(verifyResult);
+        throw new FailedTransactionError(verifyResult, getBitauthUri(template));
     }
     return verifyResult;
 };
@@ -24,34 +26,48 @@ export const debugTemplate = (template, artifact) => {
     const executedLogs = (artifact.debug?.logs ?? [])
         .filter((debugStep) => executedDebugSteps.some((log) => log.ip === debugStep.ip));
     for (const log of executedLogs) {
-        const correspondingDebugStep = executedDebugSteps.find((debugStep) => debugStep.ip === log.ip);
-        logConsoleLogStatement(log, correspondingDebugStep, artifact);
+        logConsoleLogStatement(log, executedDebugSteps, artifact);
     }
     const lastExecutedDebugStep = executedDebugSteps[executedDebugSteps.length - 1];
     // If an error is present in the last step, that means a require statement in the middle of the function failed
     if (lastExecutedDebugStep.error) {
+        // In Libauth any thrown error gets registered in the instruction that happens right *after* the instruction that
+        // caused the error (in other words the OP_VERIFY). We need to decrement the instruction pointer to get the correct
+        // failing instruction.
+        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 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 messageIp = lastExecutedDebugStep.ip + (isNullFail ? 1 : 0);
-        const requireStatement = (artifact.debug?.requireMessages ?? [])
-            .find((message) => message.ip === messageIp);
+        const requireStatementIp = failingIp + (isNullFail ? 1 : 0);
+        const requireStatement = (artifact.debug?.requires ?? [])
+            .find((statement) => statement.ip === requireStatementIp);
+        const { program: { inputIndex }, error } = lastExecutedDebugStep;
         if (requireStatement) {
-            throw new Error(`${artifact.contractName}.cash:${requireStatement.line} Error in evaluating input index ${lastExecutedDebugStep.program.inputIndex} with the following message: ${requireStatement.message}.\n${lastExecutedDebugStep.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 Error(`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 stackContents = lastExecutedDebugStep.stack.map(item => `0x${binToHex(item)}`).join(', ');
-        const stackContentsMessage = `\nStack contents after evaluation: ${lastExecutedDebugStep.stack.length ? stackContents : 'empty'}`;
-        const executedInstructions = lastExecutedDebugStep.instructions
-            .filter((_, i) => executedDebugSteps.map((step) => step.ip).includes(i));
-        const cleanupSize = calculateCleanupSize(executedInstructions);
-        const finalExecutedVerify = executedDebugSteps[executedDebugSteps.length - cleanupSize - 1];
-        const finalVerifyMessage = artifact.debug?.requireMessages.find((message) => message.ip === finalExecutedVerify.ip);
-        if (finalVerifyMessage) {
-            throw new Error(`${artifact.contractName}.cash:${finalVerifyMessage.line} Error in evaluating input index ${lastExecutedDebugStep.program.inputIndex} with the following message: ${finalVerifyMessage.message}.\n${evaluationResult.replace(/Error in evaluating input index \d: /, '')}` + stackContentsMessage);
+        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) {
+            throw new FailedRequireError(artifact, sourcemapInstructionPointer, requireStatement, inputIndex, getBitauthUri(template));
         }
-        throw new Error(evaluationResult + stackContentsMessage);
+        throw new FailedTransactionEvaluationError(artifact, sourcemapInstructionPointer, inputIndex, getBitauthUri(template), evaluationResult);
     }
     return fullDebugSteps;
 };
@@ -67,25 +83,28 @@ const createProgram = (template) => {
         scenarioId: 'evaluate_function',
     });
     if (typeof scenarioGeneration === 'string') {
-        throw new Error(scenarioGeneration);
+        throw new FailedTransactionError(scenarioGeneration, getBitauthUri(template));
     }
     if (typeof scenarioGeneration.scenario === 'string') {
-        throw new Error(scenarioGeneration.scenario);
+        throw new FailedTransactionError(scenarioGeneration.scenario, getBitauthUri(template));
     }
     return { vm, program: scenarioGeneration.scenario.program };
 };
-const logConsoleLogStatement = (log, debugStep, artifact) => {
+const logConsoleLogStatement = (log, debugSteps, artifact) => {
     let line = `${artifact.contractName}.cash:${log.line}`;
-    const decodedData = log.data.map((element) => decodeLogData(element, debugStep.stack, log.ip));
+    const decodedData = log.data.map((element) => {
+        if (typeof element === 'string')
+            return element;
+        const debugStep = debugSteps.find((step) => step.ip === element.ip);
+        return decodeStackItem(element, debugStep.stack);
+    });
     console.log(`${line} ${decodedData.join(' ')}`);
 };
-const decodeLogData = (element, stack, ip) => {
-    if (typeof element === 'string')
-        return element;
+const decodeStackItem = (element, stack) => {
     // Reversed since stack is in reverse order
     const stackItem = [...stack].reverse()[element.stackIndex];
     if (!stackItem) {
-        throw Error(`Stack item at index ${element.stackIndex} not found at instruction pointer ${ip}`);
+        throw Error(`Stack item at index ${element.stackIndex} not found at instruction pointer ${element.ip}`);
     }
     if (element.type === PrimitiveType.BOOL)
         return decodeBool(stackItem);
@@ -113,7 +132,9 @@ const calculateCleanupSize = (instructions) => {
     const cleanupOpcodes = [Op.OP_ENDIF, Op.OP_NIP, Op.OP_ELSE];
     let cleanupSize = 0;
     for (const instruction of [...instructions].reverse()) {
-        if (cleanupOpcodes.includes(instruction.opcode)) {
+        // The instructions array may contain undefined elements for the final executed debug steps that are not
+        // technically instructions (e.g. the final *implicit* verify). We still want to get rid of these in the cleanup
+        if (!instruction || cleanupOpcodes.includes(instruction.opcode)) {
             cleanupSize++;
         }
         else {
@@ -122,4 +143,23 @@ const calculateCleanupSize = (instructions) => {
     }
     return cleanupSize;
 };
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const logDebugSteps = (debugSteps, instructions) => {
+    debugSteps.map((step) => {
+        const opcode = instructions[step.ip] ? bytecodeToAsm(encodeAuthenticationInstruction(instructions[step.ip])) : 'null';
+        console.warn(step.ip, opcode, step.stack, step.error);
+    });
+};
+const getFinalExecutedVerifyIp = (executedDebugSteps) => {
+    // Map every executed debug step to its corresponding instruction
+    // (note that the last executed step(s) may not have a corresponding instruction and will be `undefined`)
+    const executedInstructions = executedDebugSteps.map((step) => step.instructions[step.ip]);
+    const finalExecutedDebugStepIndex = executedDebugSteps.length - 1;
+    const cleanupSize = calculateCleanupSize(executedInstructions);
+    const finalExecutedNonCleanupStep = executedDebugSteps[finalExecutedDebugStepIndex - cleanupSize];
+    // The final verify in a function is dropped, so after cleanup, we get the final OP that was executed *before* the
+    // final verify, so we need to add one to get the actual final verify instruction
+    const finalExecutedVerifyIp = finalExecutedNonCleanupStep.ip + 1;
+    return finalExecutedVerifyIp;
+};
 //# sourceMappingURL=debugging.js.map

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

@@ -82,7 +82,7 @@ export declare const Network: {
     CHIPNET: "chipnet";
     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 +91,4 @@ export interface ContractOptions {
     provider?: NetworkProvider;
     addressType?: AddressType;
 }
-export declare type AddressType = 'p2sh20' | 'p2sh32';
+export type AddressType = 'p2sh20' | 'p2sh32';

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

@@ -1,7 +1,6 @@
 import { Transaction } from '@bitauth/libauth';
 import { Script } from '@cashscript/utils';
 import { Utxo, Output, LibauthOutput, TokenDetails, AddressType } from './interfaces.js';
-import { FailedTransactionError } from './Errors.js';
 export declare function validateOutput(output: Output): void;
 export declare function calculateDust(output: Output): number;
 export declare function getOutputSize(output: Output): number;
@@ -14,7 +13,6 @@ 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, debugStr?: string): FailedTransactionError;
 export declare function toRegExp(reasons: string[]): RegExp;
 export declare function scriptToAddress(script: Script, network: string, addressType: AddressType, tokenSupport: boolean): string;
 export declare function scriptToLockingBytecode(script: Script, addressType: AddressType): Uint8Array;
@@ -30,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

@@ -1,8 +1,8 @@
-import { cashAddressToLockingBytecode, decodeCashAddress, addressContentsToLockingBytecode, lockingBytecodeToCashAddress, binToHex, generateSigningSerializationBCH, utf8ToBin, hexToBin, flattenBinArray, LockingBytecodeType, encodeTransactionOutput, isHex, bigIntToCompactUint, AuthenticationErrorCommon, NonFungibleTokenCapability, bigIntToVmNumber, } from '@bitauth/libauth';
+import { cashAddressToLockingBytecode, decodeCashAddress, addressContentsToLockingBytecode, lockingBytecodeToCashAddress, binToHex, generateSigningSerializationBCH, utf8ToBin, hexToBin, flattenBinArray, LockingBytecodeType, encodeTransactionOutput, isHex, bigIntToCompactUint, 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';
+import { OutputSatoshisTooSmallError, TokensToNonTokenAddressError, } from './Errors.js';
 // ////////// PARAMETER VALIDATION ////////////////////////////////////////////
 export function validateOutput(output) {
     if (typeof output.to !== 'string')
@@ -135,40 +135,16 @@ export function createSighashPreimage(transaction, sourceOutputs, inputIndex, co
     const sighashPreimage = generateSigningSerializationBCH(context, { coveredBytecode, signingSerializationType });
     return sighashPreimage;
 }
-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 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, debugStr);
-    }
-    if (toRegExp(timeCheck).test(reason)) {
-        return new FailedTimeCheckError(reason, debugStr);
-    }
-    if (toRegExp(sigCheck).test(reason)) {
-        return new FailedSigCheckError(reason, debugStr);
-    }
-    return new FailedTransactionError(reason, debugStr);
-}
 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);
@@ -247,7 +223,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.5",
+  "version": "0.10.0",
   "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.5",
+    "@bitauth/libauth": "^3.0.0",
+    "@cashscript/utils": "^0.10.0",
     "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": "3d6611410e8c7ed9d760071a8c639e91c2cbb477"
+  "gitHead": "cd3031b60dc4ca2d2351608dfd838a50bcc7bbb9"
 }