cashscript 0.10.0-next.5 → 0.10.0-next.6

package/README.md

@@ -8,7 +8,7 @@
 
 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/Contract.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,6 +72,9 @@ 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));

package/dist/Errors.d.ts

@@ -1,4 +1,4 @@
-import { Type } from '@cashscript/utils';
+import { RequireStatement, Type } from '@cashscript/utils';
 export declare class TypeError extends Error {
     constructor(actual: string, expected: Type);
 }
@@ -10,16 +10,18 @@ export declare class TokensToNonTokenAddressError extends Error {
 }
 export declare class FailedTransactionError extends Error {
     reason: string;
-    debugStr?: string | undefined;
-    constructor(reason: string, debugStr?: string | undefined);
+    bitauthUri?: string | undefined;
+    constructor(reason: string, bitauthUri?: string | undefined);
 }
-export declare class FailedRequireError extends FailedTransactionError {
+export declare class FailedRequireError extends Error {
+    contractName: string;
+    requireStatement: RequireStatement;
+    inputIndex: number;
+    libauthErrorMessage?: string | undefined;
+    bitauthUri?: string;
+    constructor(contractName: string, requireStatement: RequireStatement, inputIndex: number, libauthErrorMessage?: string | undefined);
 }
-export declare class FailedTimeCheckError extends FailedTransactionError {
-}
-export declare class FailedSigCheckError extends FailedTransactionError {
-}
-export declare enum Reason {
+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",

package/dist/Errors.js

@@ -14,66 +14,72 @@ export class TokensToNonTokenAddressError extends Error {
     }
 }
 export class FailedTransactionError extends Error {
-    constructor(reason, debugStr) {
-        super(`Transaction failed with reason: ${reason}${debugStr ? `\n\n${debugStr}` : ''}`);
+    constructor(reason, bitauthUri) {
+        super(`${reason}\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 FailedSigCheckError extends FailedTransactionError {
+// 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;
+        this.requireStatement = requireStatement;
+        this.inputIndex = inputIndex;
+        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 = {}));
+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 = {}));
 //# sourceMappingURL=Errors.js.map

package/dist/Transaction.js

@@ -4,13 +4,14 @@ 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 { FailedRequireError, FailedTransactionError } from './Errors.js';
 export class Transaction {
     constructor(contract, unlocker, abiFunction, encodedFunctionArgs, selector) {
         this.contract = contract;
@@ -102,7 +103,22 @@ 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;
+        }
+        try {
+            // TODO: Can we move this to MockNetworkProvider?
             if (this.contract.provider instanceof MockNetworkProvider) {
                 template = await buildTemplate({
                     transaction: this,
@@ -113,29 +129,9 @@ export class Transaction {
             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

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

@@ -1,12 +1,13 @@
-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 } from './Errors.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);
     }
     return verifyResult;
 };
@@ -24,34 +25,42 @@ 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.
         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);
+        // TODO: Also log the require statement that failed (e.g. "require(1 == 2, '1 is not equal to 2')")
         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}`);
+            const { program: { inputIndex }, error } = lastExecutedDebugStep;
+            throw new FailedRequireError(artifact.contractName, requireStatement, inputIndex, error);
         }
-        throw new Error(`Error in evaluating input index ${lastExecutedDebugStep.program.inputIndex}.\n${lastExecutedDebugStep.error}`);
+        throw new FailedTransactionError(`Error in evaluating input index ${lastExecutedDebugStep.program.inputIndex}.\n${lastExecutedDebugStep.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);
+        // logDebugSteps(executedDebugSteps, lastExecutedDebugStep.instructions);
+        // console.warn('message', finalExecutedVerifyIp);
+        // console.warn(artifact.debug?.requires);
+        const requireStatement = (artifact.debug?.requires ?? [])
+            .find((message) => message.ip === finalExecutedVerifyIp);
+        if (requireStatement) {
+            const { program: { inputIndex }, error } = lastExecutedDebugStep;
+            throw new FailedRequireError(artifact.contractName, requireStatement, inputIndex, error);
         }
-        throw new Error(evaluationResult + stackContentsMessage);
+        throw new FailedTransactionError(`Error in evaluating input index ${lastExecutedDebugStep.program.inputIndex}.\n${evaluationResult}`);
     }
     return fullDebugSteps;
 };
@@ -67,25 +76,28 @@ const createProgram = (template) => {
         scenarioId: 'evaluate_function',
     });
     if (typeof scenarioGeneration === 'string') {
-        throw new Error(scenarioGeneration);
+        throw new FailedTransactionError(scenarioGeneration);
     }
     if (typeof scenarioGeneration.scenario === 'string') {
-        throw new Error(scenarioGeneration.scenario);
+        throw new FailedTransactionError(scenarioGeneration.scenario);
     }
     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 +125,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 +136,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/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;

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,32 +135,6 @@ 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, '\\)'));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cashscript",
-  "version": "0.10.0-next.5",
+  "version": "0.10.0-next.6",
   "description": "Easily write and interact with Bitcoin Cash contracts",
   "keywords": [
     "bitcoin cash",
@@ -44,7 +44,7 @@
   },
   "dependencies": {
     "@bitauth/libauth": "^2.0.0",
-    "@cashscript/utils": "^0.10.0-next.5",
+    "@cashscript/utils": "^0.10.0-next.6",
     "bip68": "^1.0.4",
     "bitcoin-rpc-promise-retry": "^1.3.0",
     "delay": "^5.0.0",
@@ -61,5 +61,5 @@
     "jest": "^29.4.1",
     "typescript": "^4.1.5"
   },
-  "gitHead": "3d6611410e8c7ed9d760071a8c639e91c2cbb477"
+  "gitHead": "b26f1f20b89df6d857a5860eebd3bcc7668faa4e"
 }