cashscript 0.11.5 → 0.12.1

package/README.md

@@ -37,17 +37,29 @@ Using the CashScript SDK, you can import contract artifact files, create new ins
   const provider = new ElectrumNetworkProvider('mainnet');
 
   // Create a new P2PKH contract with constructor arguments: { pkh: pkh }
-  const contract = new Contract(P2PKH, [pkh], provider);
+  const contract = new Contract(P2PKH, [pkh], { provider });
 
   // Get contract balance & output address + balance
   console.log('contract address:', contract.address);
   console.log('contract balance:', await contract.getBalance());
 
-  // Call the spend function with the owner's signature
-  // And use it to send 0. 000 100 00 BCH back to the contract's address
-  const txDetails = await contract.functions
-    .spend(pk, new SignatureTemplate(keypair))
-    .to(contract.address, 10000)
+  const transactionBuilder = new TransactionBuilder({ provider });
+  const contractUtxos = await contract.getUtxos();
+
+  const sendAmount = 10_000n;
+  const destinationAddress = '... some address ...';
+
+  // Calculate the change amount, accounting for a miner fee of 1000 satoshis
+  const changeAmount = contractUtxos[0].satoshis - sendAmount - 1000n;
+
+  // Construct a transaction with the transaction builder
+  const txDetails = await transactionBuilder
+    // Add a contract input that spends from the contract using the 'spend' function
+    .addInput(contractUtxos[0], contract.unlock.spend(pk, new SignatureTemplate(keypair)))
+    // Add an output that sends 0. 000 100 00 BCH back to the destination address
+    .addOutput({ to: destinationAddress, amount: sendAmount })
+    // Add a change output that sends the change back to the contract's address
+    .addOutput({ to: contract.address, amount: changeAmount })
     .send();
 
   console.log(txDetails);

package/dist/Argument.js

@@ -34,15 +34,19 @@ export function encodeFunctionArgument(argument, typeStr) {
     if (!(argument instanceof Uint8Array)) {
         throw Error(`Value for type ${type} should be a Uint8Array or hex string`);
     }
-    // Redefine SIG as a bytes65 so it is included in the size checks below
-    // Note that ONLY Schnorr signatures are accepted
-    if (type === PrimitiveType.SIG && argument.byteLength !== 0) {
-        type = new BytesType(65);
+    // Redefine SIG as a bytes65 (Schnorr) or bytes71, bytes72, bytes73 (ECDSA) or bytes0 (for NULLFAIL)
+    if (type === PrimitiveType.SIG) {
+        if (![0, 65, 71, 72, 73].includes(argument.byteLength)) {
+            throw new TypeError(`bytes${argument.byteLength}`, type);
+        }
+        type = new BytesType(argument.byteLength);
     }
-    // Redefine DATASIG as a bytes64 so it is included in the size checks below
-    // Note that ONLY Schnorr signatures are accepted
-    if (type === PrimitiveType.DATASIG && argument.byteLength !== 0) {
-        type = new BytesType(64);
+    // Redefine DATASIG as a bytes64 (Schnorr) or bytes70, bytes71, bytes72 (ECDSA) or bytes0 (for NULLFAIL)
+    if (type === PrimitiveType.DATASIG) {
+        if (![0, 64, 70, 71, 72].includes(argument.byteLength)) {
+            throw new TypeError(`bytes${argument.byteLength}`, type);
+        }
+        type = new BytesType(argument.byteLength);
     }
     // Bounded bytes types require a correctly sized argument
     if (type instanceof BytesType && type.bound && argument.byteLength !== type.bound) {

package/dist/Contract.d.ts

@@ -1,36 +1,30 @@
 import { Artifact, Script } from '@cashscript/utils';
-import { Transaction } from './Transaction.js';
-import { ConstructorArgument, FunctionArgument } from './Argument.js';
+import { ConstructorArgument } from './Argument.js';
 import { Unlocker, ContractOptions, Utxo, AddressType } from './interfaces.js';
 import NetworkProvider from './network/NetworkProvider.js';
 import { ParamsToTuple, AbiToFunctionMap } from './types/type-inference.js';
 export declare class Contract<TArtifact extends Artifact = Artifact, TResolved extends {
     constructorInputs: ConstructorArgument[];
-    functions: Record<string, any>;
     unlock: Record<string, any>;
 } = {
     constructorInputs: ParamsToTuple<TArtifact['constructorInputs']>;
-    functions: AbiToFunctionMap<TArtifact['abi'], Transaction>;
     unlock: AbiToFunctionMap<TArtifact['abi'], Unlocker>;
 }> {
     artifact: TArtifact;
-    private options?;
+    private options;
     name: string;
     address: string;
     tokenAddress: string;
     bytecode: string;
     bytesize: number;
     opcount: number;
-    functions: TResolved['functions'];
     unlock: TResolved['unlock'];
     redeemScript: Script;
     provider: NetworkProvider;
     addressType: AddressType;
     encodedConstructorArgs: Uint8Array[];
-    constructor(artifact: TArtifact, constructorArgs: TResolved['constructorInputs'], options?: ContractOptions | undefined);
+    constructor(artifact: TArtifact, constructorArgs: TResolved['constructorInputs'], options: ContractOptions);
     getBalance(): Promise<bigint>;
     getUtxos(): Promise<Utxo[]>;
-    private createFunction;
     private createUnlocker;
 }
-export type ContractFunction = (...args: FunctionArgument[]) => Transaction;

package/dist/Contract.js

@@ -1,17 +1,15 @@
 import { binToHex } from '@bitauth/libauth';
 import { asmToScript, calculateBytesize, countOpcodes, generateRedeemScript, hash256, scriptToBytecode, } from '@cashscript/utils';
-import { Transaction } from './Transaction.js';
-import { encodeFunctionArgument, encodeConstructorArguments, encodeFunctionArguments, } from './Argument.js';
+import { encodeFunctionArgument, encodeConstructorArguments, } from './Argument.js';
 import { addressToLockScript, createInputScript, createSighashPreimage, scriptToAddress, } from './utils.js';
 import SignatureTemplate from './SignatureTemplate.js';
-import { ElectrumNetworkProvider } from './network/index.js';
 import semver from 'semver';
 export class Contract {
     constructor(artifact, constructorArgs, options) {
         this.artifact = artifact;
         this.options = options;
-        this.provider = this.options?.provider ?? new ElectrumNetworkProvider();
-        this.addressType = this.options?.addressType ?? 'p2sh32';
+        this.provider = this.options.provider;
+        this.addressType = this.options.addressType ?? 'p2sh32';
         const expectedProperties = ['abi', 'bytecode', 'constructorInputs', 'contractName', 'compiler'];
         if (!expectedProperties.every((property) => property in artifact)) {
             throw new Error('Invalid or incomplete artifact provided');
@@ -25,21 +23,7 @@ export class Contract {
         // Encode arguments (this also performs type checking)
         this.encodedConstructorArgs = encodeConstructorArguments(artifact, constructorArgs);
         this.redeemScript = generateRedeemScript(asmToScript(this.artifact.bytecode), this.encodedConstructorArgs);
-        // Populate the functions object with the contract's functions
-        // (with a special case for single function, which has no "function selector")
-        this.functions = {};
-        if (artifact.abi.length === 1) {
-            const f = artifact.abi[0];
-            // @ts-ignore TODO: see if we can use generics to make TypeScript happy
-            this.functions[f.name] = this.createFunction(f);
-        }
-        else {
-            artifact.abi.forEach((f, i) => {
-                // @ts-ignore TODO: see if we can use generics to make TypeScript happy
-                this.functions[f.name] = this.createFunction(f, i);
-            });
-        }
-        // Populate the functions object with the contract's functions
+        // Populate the 'unlock' object with the contract's functions
         // (with a special case for single function, which has no "function selector")
         this.unlock = {};
         if (artifact.abi.length === 1) {
@@ -67,17 +51,6 @@ export class Contract {
     async getUtxos() {
         return this.provider.getUtxos(this.address);
     }
-    createFunction(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}`);
-            }
-            // Encode passed args (this also performs type checking)
-            const encodedArgs = encodeFunctionArguments(abiFunction, args);
-            const unlocker = this.createUnlocker(abiFunction, selector)(...args);
-            return new Transaction(this, unlocker, abiFunction, encodedArgs, selector);
-        };
-    }
     createUnlocker(abiFunction, selector) {
         return (...args) => {
             if (abiFunction.inputs.length !== args.length) {

package/dist/Errors.d.ts

@@ -19,8 +19,8 @@ export declare class NoDebugInformationInArtifactError extends Error {
 }
 export declare class FailedTransactionError extends Error {
     reason: string;
-    bitauthUri?: string | undefined;
-    constructor(reason: string, bitauthUri?: string | undefined);
+    bitauthUri: string;
+    constructor(reason: string, bitauthUri: string);
 }
 export declare class FailedTransactionEvaluationError extends FailedTransactionError {
     artifact: Artifact;

package/dist/SignatureTemplate.d.ts

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

package/dist/SignatureTemplate.js

@@ -1,4 +1,4 @@
-import { decodePrivateKeyWif, secp256k1, SigningSerializationFlag } from '@bitauth/libauth';
+import { decodePrivateKeyWif, hexToBin, isHex, secp256k1, SigningSerializationFlag } from '@bitauth/libauth';
 import { hash256, scriptToBytecode } from '@cashscript/utils';
 import { HashType, SignatureAlgorithm, } from './interfaces.js';
 import { createSighashPreimage, publicKeyToP2PKHLockingBytecode } from './utils.js';
@@ -11,18 +11,27 @@ export default class SignatureTemplate {
             this.privateKey = decodeWif(wif);
         }
         else if (typeof signer === 'string') {
-            this.privateKey = decodeWif(signer);
+            const maybeHexString = signer.startsWith('0x') ? signer.slice(2) : signer;
+            if (isHex(maybeHexString)) {
+                this.privateKey = hexToBin(maybeHexString);
+            }
+            else {
+                this.privateKey = decodeWif(maybeHexString);
+            }
         }
         else {
             this.privateKey = signer;
         }
     }
-    // TODO: Allow signing of non-transaction messages (i.e. don't add the hashtype)
     generateSignature(payload, bchForkId) {
+        const signature = this.signMessageHash(payload);
+        return Uint8Array.from([...signature, this.getHashType(bchForkId)]);
+    }
+    signMessageHash(payload) {
         const signature = this.signatureAlgorithm === SignatureAlgorithm.SCHNORR
             ? secp256k1.signMessageHashSchnorr(this.privateKey, payload)
             : secp256k1.signMessageHashDER(this.privateKey, payload);
-        return Uint8Array.from([...signature, this.getHashType(bchForkId)]);
+        return signature;
     }
     getHashType(bchForkId = true) {
         return bchForkId ? (this.hashtype | SigningSerializationFlag.forkId) : this.hashtype;

package/dist/TransactionBuilder.d.ts

@@ -1,18 +1,21 @@
 import { Transaction as LibauthTransaction, WalletTemplate } from '@bitauth/libauth';
-import { Unlocker, Output, TransactionDetails, UnlockableUtxo, Utxo, InputOptions } from './interfaces.js';
+import { Unlocker, Output, TransactionDetails, UnlockableUtxo, Utxo, InputOptions, VmResourceUsage } from './interfaces.js';
 import { NetworkProvider } from './network/index.js';
 import { DebugResults } from './debugging.js';
 import { WcTransactionOptions } from './walletconnect-utils.js';
 import { WcTransactionObject } from './walletconnect-utils.js';
 export interface TransactionBuilderOptions {
     provider: NetworkProvider;
+    maximumFeeSatoshis?: bigint;
+    maximumFeeSatsPerByte?: number;
+    allowImplicitFungibleTokenBurn?: boolean;
 }
 export declare class TransactionBuilder {
     provider: NetworkProvider;
     inputs: UnlockableUtxo[];
     outputs: Output[];
     locktime: number;
-    maxFee?: bigint;
+    options: TransactionBuilderOptions;
     constructor(options: TransactionBuilderOptions);
     addInput(utxo: Utxo, unlocker: Unlocker, options?: InputOptions): this;
     addInputs(utxos: Utxo[], unlocker: Unlocker, options?: InputOptions): this;
@@ -21,12 +24,13 @@ export declare class TransactionBuilder {
     addOutputs(outputs: Output[]): this;
     addOpReturnOutput(chunks: string[]): this;
     setLocktime(locktime: number): this;
-    setMaxFee(maxFee: bigint): this;
     private checkMaxFee;
+    private checkFungibleTokenBurn;
     buildLibauthTransaction(): LibauthTransaction;
     build(): string;
     debug(): DebugResults;
-    bitauthUri(): string;
+    getVmResourceUsage(verbose?: boolean): Array<VmResourceUsage>;
+    getBitauthUri(): string;
     getLibauthTemplate(): WalletTemplate;
     send(): Promise<TransactionDetails>;
     send(raw: true): Promise<string>;

package/dist/TransactionBuilder.js

@@ -1,9 +1,8 @@
 import { binToHex, decodeTransaction, decodeTransactionUnsafe, encodeTransaction, hexToBin, } from '@bitauth/libauth';
-import { isUnlockableUtxo, isStandardUnlockableUtxo, isP2PKHUnlocker, } from './interfaces.js';
+import { isUnlockableUtxo, isStandardUnlockableUtxo, isContractUnlocker, } from './interfaces.js';
 import { cashScriptOutputToLibauthOutput, createOpReturnOutput, delay, generateLibauthSourceOutputs, validateInput, validateOutput, } from './utils.js';
 import { FailedTransactionError } from './Errors.js';
-import { getBitauthUri } from './LibauthTemplate.js';
-import { debugLibauthTemplate, getLibauthTemplates } from './advanced/LibauthTemplate.js';
+import { debugLibauthTemplate, getLibauthTemplate, getBitauthUri } from './libauth-template/LibauthTemplate.js';
 import { getWcContractInfo } from './walletconnect-utils.js';
 import semver from 'semver';
 const DEFAULT_SEQUENCE = 0xfffffffe;
@@ -13,6 +12,10 @@ export class TransactionBuilder {
         this.outputs = [];
         this.locktime = 0;
         this.provider = options.provider;
+        this.options = {
+            allowImplicitFungibleTokenBurn: options.allowImplicitFungibleTokenBurn ?? false,
+            ...options,
+        };
     }
     addInput(utxo, unlocker, options) {
         return this.addInputs([utxo], unlocker, options);
@@ -47,22 +50,45 @@ export class TransactionBuilder {
         this.locktime = locktime;
         return this;
     }
-    setMaxFee(maxFee) {
-        this.maxFee = maxFee;
-        return this;
-    }
-    checkMaxFee() {
-        if (!this.maxFee)
-            return;
+    checkMaxFee(transaction) {
         const totalInputAmount = this.inputs.reduce((total, input) => total + input.satoshis, 0n);
         const totalOutputAmount = this.outputs.reduce((total, output) => total + output.amount, 0n);
         const fee = totalInputAmount - totalOutputAmount;
-        if (fee > this.maxFee) {
-            throw new Error(`Transaction fee of ${fee} is higher than max fee of ${this.maxFee}`);
+        if (this.options.maximumFeeSatoshis && fee > this.options.maximumFeeSatoshis) {
+            throw new Error(`Transaction fee of ${fee} is higher than max fee of ${this.options.maximumFeeSatoshis}`);
+        }
+        if (this.options.maximumFeeSatsPerByte) {
+            const transactionSize = encodeTransaction(transaction).byteLength;
+            const feePerByte = Number((Number(fee) / transactionSize).toFixed(2));
+            if (feePerByte > this.options.maximumFeeSatsPerByte) {
+                throw new Error(`Transaction fee per byte of ${feePerByte} is higher than max fee per byte of ${this.options.maximumFeeSatsPerByte}`);
+            }
+        }
+    }
+    checkFungibleTokenBurn() {
+        if (this.options.allowImplicitFungibleTokenBurn)
+            return;
+        const tokenInputAmounts = {};
+        const tokenOutputAmounts = {};
+        for (const input of this.inputs) {
+            if (input.token?.amount) {
+                tokenInputAmounts[input.token.category] = (tokenInputAmounts[input.token.category] || 0n) + input.token.amount;
+            }
+        }
+        for (const output of this.outputs) {
+            if (output.token?.amount) {
+                tokenOutputAmounts[output.token.category] = (tokenOutputAmounts[output.token.category] || 0n) + output.token.amount;
+            }
+        }
+        for (const [category, inputAmount] of Object.entries(tokenInputAmounts)) {
+            const outputAmount = tokenOutputAmounts[category] || 0n;
+            if (outputAmount < inputAmount) {
+                throw new Error(`Implicit burning of fungible tokens for category ${category} is not allowed (input amount: ${inputAmount}, output amount: ${outputAmount}). If this is intended, set allowImplicitFungibleTokenBurn to true.`);
+            }
         }
     }
     buildLibauthTransaction() {
-        this.checkMaxFee();
+        this.checkFungibleTokenBurn();
         const inputs = this.inputs.map((utxo) => ({
             outpointIndex: utxo.vout,
             outpointTransactionHash: hexToBin(utxo.txid),
@@ -82,6 +108,7 @@ export class TransactionBuilder {
         inputScripts.forEach((script, i) => {
             transaction.inputs[i].unlockingBytecode = script;
         });
+        this.checkMaxFee(transaction);
         return transaction;
     }
     build() {
@@ -89,10 +116,6 @@ export class TransactionBuilder {
         return binToHex(encodeTransaction(transaction));
     }
     debug() {
-        // do not debug a pure P2PKH-spend transaction
-        if (this.inputs.every((input) => isP2PKHUnlocker(input.unlocker))) {
-            return {};
-        }
         if (this.inputs.some((input) => !isStandardUnlockableUtxo(input))) {
             throw new Error('Cannot debug a transaction with custom unlocker');
         }
@@ -105,12 +128,42 @@ export class TransactionBuilder {
         }
         return debugLibauthTemplate(this.getLibauthTemplate(), this);
     }
-    bitauthUri() {
+    getVmResourceUsage(verbose = false) {
+        // Note that only StandardUnlockableUtxo inputs are supported for debugging, so any transaction with custom unlockers
+        // cannot be debugged (and therefore cannot return VM resource usage)
+        const results = this.debug();
+        const vmResourceUsage = [];
+        const tableData = [];
+        const formatMetric = (value, total, withPercentage = false) => `${formatNumber(value)} / ${formatNumber(total)}${withPercentage ? ` (${(value / total * 100).toFixed(0)}%)` : ''}`;
+        const formatNumber = (value) => value.toLocaleString('en');
+        const resultEntries = Object.entries(results);
+        for (const [index, input] of this.inputs.entries()) {
+            const [, result] = resultEntries.find(([entryKey]) => entryKey.includes(`input${index}`)) ?? [];
+            const metrics = result?.at(-1)?.metrics;
+            // Should not happen
+            if (!metrics)
+                throw new Error('VM resource could not be calculated');
+            vmResourceUsage.push(metrics);
+            tableData.push({
+                'Contract - Function': isContractUnlocker(input.unlocker) ? `${input.unlocker.contract.name} - ${input.unlocker.abiFunction.name}` : 'P2PKH Input',
+                Ops: metrics.evaluatedInstructionCount,
+                'Op Cost Budget Usage': formatMetric(metrics.operationCost, metrics.maximumOperationCost, true),
+                SigChecks: formatMetric(metrics.signatureCheckCount, metrics.maximumSignatureCheckCount),
+                Hashes: formatMetric(metrics.hashDigestIterations, metrics.maximumHashDigestIterations),
+            });
+        }
+        if (verbose) {
+            console.log('VM Resource usage by inputs:');
+            console.table(tableData);
+        }
+        return vmResourceUsage;
+    }
+    getBitauthUri() {
         console.warn('WARNING: it is unsafe to use this Bitauth URI when using real private keys as they are included in the transaction template');
         return getBitauthUri(this.getLibauthTemplate());
     }
     getLibauthTemplate() {
-        return getLibauthTemplates(this);
+        return getLibauthTemplate(this);
     }
     async send(raw) {
         const tx = this.build();
@@ -125,7 +178,7 @@ export class TransactionBuilder {
         }
         catch (e) {
             const reason = e.error ?? e.message;
-            throw new FailedTransactionError(reason);
+            throw new FailedTransactionError(reason, this.getBitauthUri());
         }
     }
     async getTxDetails(txid, raw) {

package/dist/debugging.js

@@ -1,8 +1,24 @@
-import { AuthenticationErrorCommon, binToHex, createCompiler, createVirtualMachineBch2025, decodeAuthenticationInstructions, encodeAuthenticationInstruction, walletTemplateToCompilerConfiguration } from '@bitauth/libauth';
+import { AuthenticationErrorCommon, binToHex, createCompiler, createVirtualMachineBch2023, createVirtualMachineBch2025, createVirtualMachineBch2026, createVirtualMachineBchSpec, decodeAuthenticationInstructions, encodeAuthenticationInstruction, walletTemplateToCompilerConfiguration } from '@bitauth/libauth';
 import { Op, PrimitiveType, asmToBytecode, 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';
+import { getBitauthUri } from './libauth-template/LibauthTemplate.js';
+/* eslint-enable @typescript-eslint/indent */
+const createVirtualMachine = (vmTarget) => {
+    switch (vmTarget) {
+        case 'BCH_2023_05':
+            return createVirtualMachineBch2023();
+        case 'BCH_2025_05':
+            return createVirtualMachineBch2025();
+        case 'BCH_2026_05':
+            return createVirtualMachineBch2026();
+        case 'BCH_SPEC':
+            // TODO: This typecast is shitty, but it's hard to fix
+            return createVirtualMachineBchSpec();
+        default:
+            throw new Error(`Debugging is not supported for the ${vmTarget} virtual machine.`);
+    }
+};
 // debugs the template, optionally logging the execution data
 export const debugTemplate = (template, artifacts) => {
     // If a contract has the same name, but a different bytecode, then it is considered a name collision
@@ -14,13 +30,7 @@ export const debugTemplate = (template, artifacts) => {
     const unlockingScriptIds = Object.keys(template.scripts).filter((key) => 'unlocks' in template.scripts[key]);
     for (const unlockingScriptId of unlockingScriptIds) {
         const scenarioIds = template.scripts[unlockingScriptId].passes ?? [];
-        // There are no scenarios defined for P2PKH placeholder scripts, so we skip them
-        if (scenarioIds.length === 0)
-            continue;
         const matchingArtifact = artifacts.find((artifact) => unlockingScriptId.startsWith(artifact.contractName));
-        if (!matchingArtifact) {
-            throw new Error(`No artifact found for unlocking script ${unlockingScriptId}`);
-        }
         for (const scenarioId of scenarioIds) {
             results[`${unlockingScriptId}.${scenarioId}`] = debugSingleScenario(template, matchingArtifact, unlockingScriptId, scenarioId);
         }
@@ -38,11 +48,14 @@ const debugSingleScenario = (template, artifact, unlockingScriptId, scenarioId)
     // https://libauth.org/types/AuthenticationProgramStateControlStack.html
     const executedDebugSteps = lockingScriptDebugResult
         .filter((debugStep) => debugStep.controlStack.every(item => item === true));
-    const executedLogs = (artifact.debug?.logs ?? [])
-        .filter((log) => executedDebugSteps.some((debugStep) => log.ip === debugStep.ip));
-    for (const log of executedLogs) {
-        const inputIndex = extractInputIndexFromScenario(scenarioId);
-        logConsoleLogStatement(log, executedDebugSteps, artifact, inputIndex);
+    // 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) {
+            const inputIndex = extractInputIndexFromScenario(scenarioId);
+            logConsoleLogStatement(log, executedDebugSteps, artifact, inputIndex, vm);
+        }
     }
     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
@@ -60,9 +73,15 @@ const debugSingleScenario = (template, artifact, unlockingScriptId, scenarioId)
         // Note that we do NOT use this adjusted IP when passing the failing IP into the FailedRequireError.
         const isNullFail = lastExecutedDebugStep.error.includes(AuthenticationErrorCommon.nonNullSignatureFailure);
         const requireStatementIp = failingIp + (isNullFail && isSignatureCheckWithoutVerify(failingInstruction) ? 1 : 0);
+        const { program: { inputIndex }, error } = lastExecutedDebugStep;
+        // If there is no artifact, this is a P2PKH debug error, error can occur when final CHECKSIG fails with NULLFAIL or when
+        // public key does not match pkh in EQUALVERIFY
+        // Note: due to P2PKHUnlocker implementation, the CHECKSIG cannot fail in practice, only the EQUALVERIFY can fail
+        if (!artifact) {
+            throw new FailedTransactionError(error, getBitauthUri(template));
+        }
         const requireStatement = (artifact.debug?.requires ?? [])
             .find((statement) => statement.ip === requireStatementIp);
-        const { program: { inputIndex }, error } = lastExecutedDebugStep;
         if (requireStatement) {
             // Note that we use failingIp here rather than requireStatementIp, see comment above
             throw new FailedRequireError(artifact, failingIp, requireStatement, inputIndex, getBitauthUri(template), error);
@@ -82,9 +101,14 @@ const debugSingleScenario = (template, artifact, unlockingScriptId, scenarioId)
         // logDebugSteps(executedDebugSteps, lastExecutedDebugStep.instructions);
         // console.warn('message', finalExecutedVerifyIp);
         // console.warn(artifact.debug?.requires);
+        const { program: { inputIndex } } = lastExecutedDebugStep;
+        // If there is no artifact, this is a P2PKH debug error, final verify can only occur when final CHECKSIG failed
+        // Note: due to P2PKHUnlocker implementation, this cannot happen in practice
+        if (!artifact) {
+            throw new FailedTransactionError(evaluationResult, getBitauthUri(template));
+        }
         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));
         }
@@ -102,7 +126,7 @@ const extractInputIndexFromScenario = (scenarioId) => {
 // internal util. instantiates the virtual machine and compiles the template into a program
 const createProgram = (template, unlockingScriptId, scenarioId) => {
     const configuration = walletTemplateToCompilerConfiguration(template);
-    const vm = createVirtualMachineBch2025();
+    const vm = createVirtualMachine(template.supported[0]);
     const compiler = createCompiler(configuration);
     if (!template.scripts[unlockingScriptId]) {
         throw new Error(`No unlock script found in template for ID ${unlockingScriptId}`);
@@ -123,18 +147,18 @@ const createProgram = (template, unlockingScriptId, scenarioId) => {
     }
     return { vm, program: scenarioGeneration.scenario.program };
 };
-const logConsoleLogStatement = (log, debugSteps, artifact, inputIndex) => {
+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);
+        const transformedDebugStep = applyStackItemTransformations(element, debugStep, vm);
         return decodeStackItem(element, transformedDebugStep.stack);
     });
     console.log(`[Input #${inputIndex}] ${line} ${decodedData.join(' ')}`);
 };
-const applyStackItemTransformations = (element, debugStep) => {
+const applyStackItemTransformations = (element, debugStep, vm) => {
     if (!element.transformations)
         return debugStep;
     const transformationsBytecode = asmToBytecode(element.transformations);
@@ -150,8 +174,9 @@ const applyStackItemTransformations = (element, debugStep) => {
         instructions: transformationsAuthenticationInstructions,
         signedMessages: [],
         program: { ...debugStep.program },
+        functionTable: debugStep.functionTable ?? {},
+        functionCount: debugStep.functionCount ?? 0,
     };
-    const vm = createVirtualMachineBch2025();
     const transformationsEndState = vm.stateEvaluate(transformationsStartState);
     return transformationsEndState;
 };

package/dist/index.d.ts

@@ -1,6 +1,5 @@
 export { default as SignatureTemplate } from './SignatureTemplate.js';
-export { Contract, type ContractFunction } from './Contract.js';
-export { Transaction } from './Transaction.js';
+export { Contract } from './Contract.js';
 export { TransactionBuilder } from './TransactionBuilder.js';
 export { type ConstructorArgument, type FunctionArgument, type EncodedConstructorArgument, type EncodedFunctionArgument, encodeFunctionArgument, } from './Argument.js';
 export type { Artifact, AbiFunction, AbiInput } from '@cashscript/utils';

package/dist/index.js

@@ -1,6 +1,5 @@
 export { default as SignatureTemplate } from './SignatureTemplate.js';
 export { Contract } from './Contract.js';
-export { Transaction } from './Transaction.js';
 export { TransactionBuilder } from './TransactionBuilder.js';
 export { encodeFunctionArgument, } from './Argument.js';
 export * as utils from '@cashscript/utils';

package/dist/interfaces.d.ts

@@ -1,4 +1,4 @@
-import { type Transaction } from '@bitauth/libauth';
+import { AuthenticationProgramStateResourceLimits, type Transaction } from '@bitauth/libauth';
 import type { NetworkProvider } from './network/index.js';
 import type SignatureTemplate from './SignatureTemplate.js';
 import { Contract } from './Contract.js';
@@ -47,10 +47,6 @@ export declare function isContractUnlocker(unlocker: Unlocker): unlocker is Cont
 export declare function isP2PKHUnlocker(unlocker: Unlocker): unlocker is P2PKHUnlocker;
 export declare function isStandardUnlocker(unlocker: Unlocker): unlocker is StandardUnlocker;
 export declare function isPlaceholderUnlocker(unlocker: Unlocker): unlocker is PlaceholderP2PKHUnlocker;
-export interface UtxoP2PKH extends Utxo {
-    template: SignatureTemplate;
-}
-export declare function isUtxoP2PKH(utxo: Utxo): utxo is UtxoP2PKH;
 export interface Recipient {
     to: string;
     amount: bigint;
@@ -107,12 +103,20 @@ export declare const Network: {
     REGTEST: "regtest";
 };
 export type Network = (typeof Network)[keyof typeof Network];
+export declare const VmTarget: {
+    BCH_2023_05: "BCH_2023_05";
+    BCH_2025_05: "BCH_2025_05";
+    BCH_2026_05: "BCH_2026_05";
+    BCH_SPEC: "BCH_SPEC";
+};
+export type VmTarget = (typeof VmTarget)[keyof typeof VmTarget];
 export interface TransactionDetails extends Transaction {
     txid: string;
     hex: string;
 }
 export interface ContractOptions {
-    provider?: NetworkProvider;
+    provider: NetworkProvider;
     addressType?: AddressType;
 }
 export type AddressType = 'p2sh20' | 'p2sh32';
+export type VmResourceUsage = AuthenticationProgramStateResourceLimits['metrics'];

package/dist/interfaces.js

@@ -16,9 +16,6 @@ export function isStandardUnlocker(unlocker) {
 export function isPlaceholderUnlocker(unlocker) {
     return 'placeholder' in unlocker;
 }
-export function isUtxoP2PKH(utxo) {
-    return 'template' in utxo;
-}
 export var SignatureAlgorithm;
 (function (SignatureAlgorithm) {
     SignatureAlgorithm[SignatureAlgorithm["ECDSA"] = 0] = "ECDSA";
@@ -43,4 +40,10 @@ export const Network = {
     MOCKNET: literal('mocknet'),
     REGTEST: literal('regtest'),
 };
+export const VmTarget = {
+    BCH_2023_05: literal('BCH_2023_05'),
+    BCH_2025_05: literal('BCH_2025_05'),
+    BCH_2026_05: literal('BCH_2026_05'),
+    BCH_SPEC: literal('BCH_SPEC'),
+};
 //# sourceMappingURL=interfaces.js.map

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

@@ -0,0 +1,6 @@
+import { WalletTemplate } from '@bitauth/libauth';
+import { DebugResults } from '../debugging.js';
+import { TransactionBuilder } from '../TransactionBuilder.js';
+export declare const getLibauthTemplate: (transactionBuilder: TransactionBuilder) => WalletTemplate;
+export declare const debugLibauthTemplate: (template: WalletTemplate, transaction: TransactionBuilder) => DebugResults;
+export declare const getBitauthUri: (template: WalletTemplate) => string;