cashscript 0.12.0 → 0.13.0-next.1

package/dist/debugging.js

@@ -45,16 +45,32 @@ const debugSingleScenario = (template, artifact, unlockingScriptId, scenarioId)
     // https://libauth.org/types/AuthenticationVirtualMachine.html#__type.debug
     const lockingScriptDebugResult = fullDebugSteps.slice(findLastIndex(fullDebugSteps, (state) => state.ip === 0));
     // The controlStack determines whether the current debug step is in the executed branch
+    // It also tracks loop / function usage, but for the purpose of determining whether a step was executed,
+    // we only need to check that there are no 'false' items in the control stack.
     // https://libauth.org/types/AuthenticationProgramStateControlStack.html
+    // https://github.com/bitjson/bch-loops#control-stack
     const executedDebugSteps = lockingScriptDebugResult
-        .filter((debugStep) => debugStep.controlStack.every(item => item === true));
+        .filter((debugStep) => debugStep.controlStack.every(item => item !== false));
     // P2PKH inputs do not have an artifact, so we skip the console.log handling
     if (artifact) {
-        const executedLogs = (artifact.debug?.logs ?? [])
-            .filter((log) => executedDebugSteps.some((debugStep) => log.ip === debugStep.ip));
-        for (const log of executedLogs) {
+        // Try to match each executed debug step to a log entry if it exists. Note that inside loops,
+        // the same log statement may be executed multiple times in different debug steps
+        // Also note that multiple log statements may exist for the same ip, so we need to handle all of them
+        const executedLogs = executedDebugSteps
+            .flatMap((debugStep, index) => {
+            const logEntries = artifact.debug?.logs?.filter((log) => log.ip === debugStep.ip);
+            if (!logEntries || logEntries.length === 0)
+                return [];
+            const reversedPriorDebugSteps = executedDebugSteps.slice(0, index + 1).reverse();
+            return logEntries.map((logEntry) => {
+                const decodedLogData = logEntry.data
+                    .map((dataEntry) => decodeLogDataEntry(dataEntry, reversedPriorDebugSteps, vm));
+                return { logEntry, decodedLogData };
+            });
+        });
+        for (const { logEntry, decodedLogData } of executedLogs) {
             const inputIndex = extractInputIndexFromScenario(scenarioId);
-            logConsoleLogStatement(log, executedDebugSteps, artifact, inputIndex, vm);
+            logConsoleLogStatement(logEntry, decodedLogData, artifact.contractName, inputIndex);
         }
     }
     const lastExecutedDebugStep = executedDebugSteps[executedDebugSteps.length - 1];
@@ -147,16 +163,18 @@ const createProgram = (template, unlockingScriptId, scenarioId) => {
     }
     return { vm, program: scenarioGeneration.scenario.program };
 };
-const logConsoleLogStatement = (log, debugSteps, artifact, inputIndex, vm) => {
-    let line = `${artifact.contractName}.cash:${log.line}`;
-    const decodedData = log.data.map((element) => {
-        if (typeof element === 'string')
-            return element;
-        const debugStep = debugSteps.find((step) => step.ip === element.ip);
-        const transformedDebugStep = applyStackItemTransformations(element, debugStep, vm);
-        return decodeStackItem(element, transformedDebugStep.stack);
-    });
-    console.log(`[Input #${inputIndex}] ${line} ${decodedData.join(' ')}`);
+const logConsoleLogStatement = (log, decodedLogData, contractName, inputIndex) => {
+    console.log(`[Input #${inputIndex}] ${contractName}.cash:${log.line} ${decodedLogData.join(' ')}`);
+};
+const decodeLogDataEntry = (dataEntry, reversedPriorDebugSteps, vm) => {
+    if (typeof dataEntry === 'string')
+        return dataEntry;
+    const dataEntryDebugStep = reversedPriorDebugSteps.find((step) => step.ip === dataEntry.ip);
+    if (!dataEntryDebugStep) {
+        throw new Error(`Should not happen: corresponding data entry debug step not found for entry at ip ${dataEntry.ip}`);
+    }
+    const transformedDebugStep = applyStackItemTransformations(dataEntry, dataEntryDebugStep, vm);
+    return decodeStackItem(dataEntry, transformedDebugStep.stack);
 };
 const applyStackItemTransformations = (element, debugStep, vm) => {
     if (!element.transformations)

package/dist/libauth-template/LibauthTemplate.js

@@ -1,12 +1,12 @@
 import { binToBase64, binToHex, utf8ToBin, } from '@bitauth/libauth';
 import { encodeFunctionArguments } from '../Argument.js';
 import { debugTemplate } from '../debugging.js';
-import { isContractUnlocker, isP2PKHUnlocker, isStandardUnlockableUtxo, isUnlockableUtxo, VmTarget, } from '../interfaces.js';
+import { isContractUnlocker, isP2PKHUnlocker, isStandardUnlockableUtxo, isUnlockableUtxo, } from '../interfaces.js';
 import SignatureTemplate from '../SignatureTemplate.js';
 import { addressToLockScript, extendedStringify, zip } from '../utils.js';
 import { deflate } from 'pako';
 import MockNetworkProvider from '../network/MockNetworkProvider.js';
-import { addHexPrefixExceptEmpty, formatBytecodeForDebugging, formatParametersForDebugging, getLockScriptName, getSignatureAndPubkeyFromP2PKHInput, getUnlockScriptName, lockingBytecodeIsSetToSlot, serialiseTokenDetails } from './utils.js';
+import { addHexPrefixExceptEmpty, DEFAULT_VM_TARGET, formatBytecodeForDebugging, formatParametersForDebugging, getLockScriptName, getSignatureAndPubkeyFromP2PKHInput, getUnlockScriptName, lockingBytecodeIsSetToSlot, serialiseTokenDetails } from './utils.js';
 // TODO: Add / improve descriptions throughout the template generation
 export const getLibauthTemplate = (transactionBuilder) => {
     if (transactionBuilder.inputs.some((input) => !isStandardUnlockableUtxo(input))) {
@@ -15,7 +15,7 @@ export const getLibauthTemplate = (transactionBuilder) => {
     const libauthTransaction = transactionBuilder.buildLibauthTransaction();
     const vmTarget = transactionBuilder.provider instanceof MockNetworkProvider
         ? transactionBuilder.provider.vmTarget
-        : VmTarget.BCH_2025_05;
+        : DEFAULT_VM_TARGET;
     const template = {
         $schema: 'https://ide.bitauth.com/authentication-template-v0.schema.json',
         description: 'Imported from cashscript',

package/dist/libauth-template/utils.d.ts

@@ -3,6 +3,7 @@ import { HashType, LibauthTokenDetails, SignatureAlgorithm, TokenDetails } from
 import { type WalletTemplateScenarioBytecode, Input } from '@bitauth/libauth';
 import { EncodedFunctionArgument } from '../Argument.js';
 import { Contract } from '../Contract.js';
+export declare const DEFAULT_VM_TARGET: "BCH_2026_05";
 export declare const getLockScriptName: (contract: Contract) => string;
 export declare const getUnlockScriptName: (contract: Contract, abiFunction: AbiFunction, inputIndex: number) => string;
 export declare const getSignatureAlgorithmName: (signatureAlgorithm: SignatureAlgorithm) => string;

package/dist/libauth-template/utils.js

@@ -1,8 +1,9 @@
 import { bytecodeToScript, formatBitAuthScript } from '@cashscript/utils';
-import { HashType, SignatureAlgorithm } from '../interfaces.js';
+import { HashType, SignatureAlgorithm, VmTarget } from '../interfaces.js';
 import { hexToBin, binToHex, isHex, decodeCashAddress, assertSuccess, decodeAuthenticationInstructions } from '@bitauth/libauth';
 import { zip } from '../utils.js';
 import SignatureTemplate from '../SignatureTemplate.js';
+export const DEFAULT_VM_TARGET = VmTarget.BCH_2026_05;
 export const getLockScriptName = (contract) => {
     const result = decodeCashAddress(contract.address);
     if (typeof result === 'string')

package/dist/network/MockNetworkProvider.js

@@ -1,7 +1,8 @@
 import { binToHex, decodeTransactionUnsafe, hexToBin, isHex } from '@bitauth/libauth';
 import { sha256 } from '@cashscript/utils';
-import { Network, VmTarget } from '../interfaces.js';
+import { Network } from '../interfaces.js';
 import { addressToLockScript, libauthTokenDetailsToCashScriptTokenDetails } from '../utils.js';
+import { DEFAULT_VM_TARGET } from '../libauth-template/utils.js';
 export default class MockNetworkProvider {
     constructor(options) {
         // we use lockingBytecode hex as the key for utxoMap to make cash addresses and token addresses interchangeable
@@ -10,7 +11,7 @@ export default class MockNetworkProvider {
         this.network = Network.MOCKNET;
         this.blockHeight = 133700;
         this.options = { updateUtxoSet: true, ...options };
-        this.vmTarget = this.options.vmTarget ?? VmTarget.BCH_2025_05;
+        this.vmTarget = this.options.vmTarget ?? DEFAULT_VM_TARGET;
     }
     async getUtxos(address) {
         const addressLockingBytecode = binToHex(addressToLockScript(address));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cashscript",
-  "version": "0.12.0",
+  "version": "0.13.0-next.1",
   "description": "Easily write and interact with Bitcoin Cash contracts",
   "keywords": [
     "bitcoin cash",
@@ -46,7 +46,7 @@
   },
   "dependencies": {
     "@bitauth/libauth": "^3.1.0-next.8",
-    "@cashscript/utils": "^0.12.0",
+    "@cashscript/utils": "^0.13.0-next.1",
     "@electrum-cash/network": "^4.1.3",
     "@mr-zwets/bchn-api-wrapper": "^1.0.1",
     "pako": "^2.1.0",
@@ -61,5 +61,5 @@
     "jest": "^29.7.0",
     "typescript": "^5.9.2"
   },
-  "gitHead": "dfa7ea1cfe1c369ab1dd9a919ab89b9a98331872"
+  "gitHead": "f3d3fd75400c93f4457276b56ce094b11c0986d7"
 }