cashscript 0.11.0-next.0 → 0.11.0-next.2

package/README.md

@@ -1,6 +1,6 @@
 # CashScript
 
-![Build Status](https://github.com/CashScript/cashscript/actions/workflows/github-actions.yml/badge.svg)
+[![Build Status](https://github.com/CashScript/cashscript/actions/workflows/github-actions.yml/badge.svg)](https://github.com/CashScript/cashscript/actions/workflows/github-actions.yml)
 [![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)
@@ -14,7 +14,7 @@ See the [GitHub repository](https://github.com/CashScript/cashscript) and the [C
 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.
 
 ## The CashScript SDK
-The main way to interact with CashScript contracts and integrate them into applications is using the CashScript SDK. This SDK allows you to import `.json` artifact files that were compiled using the `cashc` compiler and convert them to `Contract` objects. These objects are used to create new contract instances. These instances are used to interact with the contracts using the functions that were implemented in the `.cash` file. For more information on the CashScript SDK, refer to the [SDK documentation](https://cashscript.org/docs/sdk/).
+The main way to interact with CashScript contracts and integrate them into applications is using the CashScript SDK. This SDK allows you to import `.json` (or `.ts`) artifact files that were compiled using the `cashc` compiler and convert them to `Contract` objects. These objects are used to create new contract instances. These instances are used to interact with the contracts using the functions that were implemented in the `.cash` file. For more information on the CashScript SDK, refer to the [SDK documentation](https://cashscript.org/docs/sdk/).
 
 ### Installation
 ```bash

package/dist/Contract.d.ts

@@ -3,8 +3,17 @@ import { Transaction } from './Transaction.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 {
-    artifact: Artifact;
+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?;
     name: string;
     address: string;
@@ -12,13 +21,13 @@ export declare class Contract {
     bytecode: string;
     bytesize: number;
     opcount: number;
-    functions: Record<string, ContractFunction>;
-    unlock: Record<string, ContractUnlocker>;
+    functions: TResolved['functions'];
+    unlock: TResolved['unlock'];
     redeemScript: Script;
     provider: NetworkProvider;
     addressType: AddressType;
     encodedConstructorArgs: Uint8Array[];
-    constructor(artifact: Artifact, constructorArgs: ConstructorArgument[], options?: ContractOptions | undefined);
+    constructor(artifact: TArtifact, constructorArgs: TResolved['constructorInputs'], options?: ContractOptions | undefined);
     getBalance(): Promise<bigint>;
     getUtxos(): Promise<Utxo[]>;
     private createFunction;

package/dist/Contract.js

@@ -1,22 +1,26 @@
 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, encodeFunctionArguments, } 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';
-        const expectedProperties = ['abi', 'bytecode', 'constructorInputs', 'contractName'];
+        const expectedProperties = ['abi', 'bytecode', 'constructorInputs', 'contractName', 'compiler'];
         if (!expectedProperties.every((property) => property in artifact)) {
             throw new Error('Invalid or incomplete artifact provided');
         }
+        if (!semver.satisfies(artifact.compiler.version, '>=0.7.0', { includePrerelease: true })) {
+            throw new Error(`Artifact compiled with unsupported compiler version: ${artifact.compiler.version}, required >=0.7.0`);
+        }
         if (artifact.constructorInputs.length !== constructorArgs.length) {
-            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}`);
+            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);
@@ -26,10 +30,12 @@ export class Contract {
         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);
             });
         }
@@ -38,10 +44,12 @@ export class Contract {
         this.unlock = {};
         if (artifact.abi.length === 1) {
             const f = artifact.abi[0];
+            // @ts-ignore TODO: see if we can use generics to make TypeScript happy
             this.unlock[f.name] = this.createUnlocker(f);
         }
         else {
             artifact.abi.forEach((f, i) => {
+                // @ts-ignore TODO: see if we can use generics to make TypeScript happy
                 this.unlock[f.name] = this.createUnlocker(f, i);
             });
         }
@@ -62,7 +70,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}. Expected ${abiFunction.inputs.length} arguments (${abiFunction.inputs.map(input => input.type)}) but got ${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);
@@ -73,32 +81,25 @@ 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}`);
+                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) => encodeFunctionArgument(arg, abiFunction.inputs[i].type));
             const generateUnlockingBytecode = ({ transaction, sourceOutputs, inputIndex }) => {
-                // TODO: Remove old-style covenant code for v1.0 release
-                let covenantHashType = -1;
                 const completeArgs = encodedArgs.map((arg) => {
                     if (!(arg instanceof SignatureTemplate))
                         return arg;
-                    // First signature is used for sighash preimage (maybe not the best way)
-                    if (covenantHashType < 0)
-                        covenantHashType = arg.getHashType();
+                    // Generate transaction signature from SignatureTemplate
                     const preimage = createSighashPreimage(transaction, sourceOutputs, inputIndex, bytecode, arg.getHashType());
                     const sighash = hash256(preimage);
                     return arg.generateSignature(sighash);
                 });
-                const preimage = abiFunction.covenant
-                    ? createSighashPreimage(transaction, sourceOutputs, inputIndex, bytecode, covenantHashType)
-                    : undefined;
-                const unlockingBytecode = createInputScript(this.redeemScript, completeArgs, selector, preimage);
+                const unlockingBytecode = createInputScript(this.redeemScript, completeArgs, selector);
                 return unlockingBytecode;
             };
             const generateLockingBytecode = () => addressToLockScript(this.address);
-            return { generateUnlockingBytecode, generateLockingBytecode };
+            return { generateUnlockingBytecode, generateLockingBytecode, contract: this, params: args, abiFunction };
         };
     }
 }

package/dist/Errors.d.ts

@@ -2,9 +2,15 @@ import { Artifact, RequireStatement, Type } from '@cashscript/utils';
 export declare class TypeError extends Error {
     constructor(actual: string, expected: Type);
 }
+export declare class UndefinedInputError extends Error {
+    constructor();
+}
 export declare class OutputSatoshisTooSmallError extends Error {
     constructor(satoshis: bigint, minimumAmount: bigint);
 }
+export declare class OutputTokenAmountTooSmallError extends Error {
+    constructor(amount: bigint);
+}
 export declare class TokensToNonTokenAddressError extends Error {
     constructor(address: string);
 }

package/dist/Errors.js

@@ -4,11 +4,21 @@ export class TypeError extends Error {
         super(`Found type '${actual}' where type '${expected.toString()}' was expected`);
     }
 }
+export class UndefinedInputError extends Error {
+    constructor() {
+        super('Input is undefined');
+    }
+}
 export class OutputSatoshisTooSmallError extends Error {
     constructor(satoshis, minimumAmount) {
         super(`Tried to add an output with ${satoshis} satoshis, which is less than the required minimum for this output-type (${minimumAmount})`);
     }
 }
+export class OutputTokenAmountTooSmallError extends Error {
+    constructor(amount) {
+        super(`Tried to add an output with ${amount} tokens, which is invalid`);
+    }
+}
 export class TokensToNonTokenAddressError extends Error {
     constructor(address) {
         super(`Tried to send tokens to an address without token support, ${address}.`);

package/dist/LibauthTemplate.d.ts

@@ -1,11 +1,25 @@
-import { WalletTemplate } from '@bitauth/libauth';
+import { AbiInput, Artifact } from '@cashscript/utils';
+import { WalletTemplate, WalletTemplateScenarioBytecode } from '@bitauth/libauth';
+import { Utxo, TokenDetails, LibauthTokenDetails, Output, SignatureAlgorithm, HashType } from './interfaces.js';
 import { Transaction } from './Transaction.js';
+import { EncodedFunctionArgument } from './Argument.js';
+import { Contract } from './Contract.js';
 interface BuildTemplateOptions {
     transaction: Transaction;
     transactionHex?: string;
 }
 export declare const buildTemplate: ({ transaction, transactionHex, }: BuildTemplateOptions) => Promise<WalletTemplate>;
 export declare const getBitauthUri: (template: WalletTemplate) => string;
+export declare const generateTemplateScenarioTransactionOutputLockingBytecode: (csOutput: Output, contract: Contract) => string | {};
+export declare const generateTemplateScenarioBytecode: (input: Utxo, p2pkhScriptName: string, placeholderKeyName: string, insertSlot?: boolean) => WalletTemplateScenarioBytecode | ["slot"];
+export declare const generateTemplateScenarioParametersValues: (types: readonly AbiInput[], encodedArgs: EncodedFunctionArgument[]) => Record<string, string>;
+export declare const addHexPrefixExceptEmpty: (value: string) => string;
+export declare const generateTemplateScenarioKeys: (types: readonly AbiInput[], encodedArgs: EncodedFunctionArgument[]) => Record<string, string>;
+export declare const formatParametersForDebugging: (types: readonly AbiInput[], args: EncodedFunctionArgument[]) => string;
+export declare const getSignatureAlgorithmName: (signatureAlgorithm: SignatureAlgorithm) => string;
+export declare const getHashTypeName: (hashType: HashType) => string;
+export declare const formatBytecodeForDebugging: (artifact: Artifact) => string;
+export declare const serialiseTokenDetails: (token?: TokenDetails | LibauthTokenDetails) => LibauthTemplateTokenDetails | undefined;
 export interface LibauthTemplateTokenDetails {
     amount: string;
     category: string;

package/dist/LibauthTemplate.js

@@ -11,8 +11,8 @@ export const buildTemplate = async ({ transaction, transactionHex = undefined, /
     const template = {
         $schema: 'https://ide.bitauth.com/authentication-template-v0.schema.json',
         description: 'Imported from cashscript',
-        name: contract.artifact.contractName,
-        supported: ['BCH_2023_05'],
+        name: 'CashScript Generated Debugging Template',
+        supported: ['BCH_2025_05'],
         version: 0,
         entities: generateTemplateEntities(contract.artifact, transaction.abiFunction, transaction.encodedFunctionArgs),
         scripts: generateTemplateScripts(contract.artifact, contract.addressType, transaction.abiFunction, transaction.encodedFunctionArgs, contract.encodedConstructorArgs),
@@ -28,9 +28,9 @@ export const buildTemplate = async ({ transaction, transactionHex = undefined, /
         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,
+        template.entities[snakeCase(contract.name + 'Parameters')].scripts.push(lockScriptName, unlockScriptName);
+        template.entities[snakeCase(contract.name + 'Parameters')].variables = {
+            ...template.entities[snakeCase(contract.name + 'Parameters')].variables,
             [placeholderKeyName]: {
                 description: placeholderKeyName,
                 name: placeholderKeyName,
@@ -75,12 +75,12 @@ const generateTemplateEntities = (artifact, abiFunction, encodedFunctionArgs) =>
         },
     ])));
     const entities = {
-        parameters: {
+        [snakeCase(artifact.contractName + 'Parameters')]: {
             description: 'Contract creation and function parameters',
-            name: 'parameters',
+            name: snakeCase(artifact.contractName + 'Parameters'),
             scripts: [
-                'lock',
-                'unlock_lock',
+                snakeCase(artifact.contractName + '_lock'),
+                snakeCase(artifact.contractName + '_unlock'),
             ],
             variables: {
                 ...functionParameters,
@@ -90,7 +90,7 @@ const generateTemplateEntities = (artifact, abiFunction, encodedFunctionArgs) =>
     };
     // function_index is a special variable that indicates the function to execute
     if (artifact.abi.length > 1) {
-        entities.parameters.variables.function_index = {
+        entities[snakeCase(artifact.contractName + 'Parameters')].variables.function_index = {
             description: 'Script function index to execute',
             name: 'function_index',
             type: 'WalletData',
@@ -101,14 +101,14 @@ const generateTemplateEntities = (artifact, abiFunction, encodedFunctionArgs) =>
 const generateTemplateScripts = (artifact, addressType, abiFunction, encodedFunctionArgs, encodedConstructorArgs) => {
     // definition of locking scripts and unlocking scripts with their respective bytecode
     return {
-        unlock_lock: generateTemplateUnlockScript(artifact, abiFunction, encodedFunctionArgs),
-        lock: generateTemplateLockScript(artifact, addressType, encodedConstructorArgs),
+        [snakeCase(artifact.contractName + '_unlock')]: generateTemplateUnlockScript(artifact, abiFunction, encodedFunctionArgs),
+        [snakeCase(artifact.contractName + '_lock')]: generateTemplateLockScript(artifact, addressType, encodedConstructorArgs),
     };
 };
 const generateTemplateLockScript = (artifact, addressType, constructorArguments) => {
     return {
         lockingType: addressType,
-        name: 'lock',
+        name: snakeCase(artifact.contractName + '_lock'),
         script: [
             `// "${artifact.contractName}" contract constructor parameters`,
             formatParametersForDebugging(artifact.constructorInputs, constructorArguments),
@@ -125,15 +125,15 @@ const generateTemplateUnlockScript = (artifact, abiFunction, encodedFunctionArgs
         : [];
     return {
         // this unlocking script must pass our only scenario
-        passes: ['evaluate_function'],
-        name: 'unlock',
+        passes: [snakeCase(artifact.contractName + 'Evaluate')],
+        name: snakeCase(artifact.contractName + '_unlock'),
         script: [
             `// "${abiFunction.name}" function parameters`,
             formatParametersForDebugging(abiFunction.inputs, encodedFunctionArgs),
             '',
             ...functionIndexString,
         ].join('\n'),
-        unlocks: 'lock',
+        unlocks: snakeCase(artifact.contractName + '_lock'),
     };
 };
 const generateTemplateScenarios = (contract, transaction, transactionHex, artifact, abiFunction, encodedFunctionArgs, encodedConstructorArgs) => {
@@ -142,8 +142,8 @@ const generateTemplateScenarios = (contract, transaction, transactionHex, artifa
         throw Error(libauthTransaction);
     const scenarios = {
         // single scenario to spend out transaction under test given the CashScript parameters provided
-        evaluate_function: {
-            name: 'Evaluate',
+        [snakeCase(artifact.contractName + 'Evaluate')]: {
+            name: snakeCase(artifact.contractName + 'Evaluate'),
             description: 'An example evaluation where this script execution passes.',
             data: {
                 // encode values for the variables defined above in `entities` property
@@ -163,7 +163,7 @@ const generateTemplateScenarios = (contract, transaction, transactionHex, artifa
     };
     if (artifact.abi.length > 1) {
         const functionIndex = artifact.abi.findIndex((func) => func.name === transaction.abiFunction.name);
-        scenarios.evaluate_function.data.bytecode.function_index = functionIndex.toString();
+        scenarios[snakeCase(artifact.contractName + 'Evaluate')].data.bytecode.function_index = functionIndex.toString();
     }
     return scenarios;
 };
@@ -190,13 +190,27 @@ const generateTemplateScenarioTransaction = (contract, libauthTransaction, csTra
     const version = libauthTransaction.version;
     return { inputs, locktime, outputs, version };
 };
-const generateTemplateScenarioTransactionOutputLockingBytecode = (csOutput, contract) => {
+export const generateTemplateScenarioTransactionOutputLockingBytecode = (csOutput, contract) => {
     if (csOutput.to instanceof Uint8Array)
         return binToHex(csOutput.to);
     if ([contract.address, contract.tokenAddress].includes(csOutput.to))
         return {};
     return binToHex(addressToLockScript(csOutput.to));
 };
+/**
+ * Generates source outputs for a BitAuth template scenario
+ *
+ * @param csTransaction - The CashScript transaction to generate source outputs for
+ * @returns An array of BitAuth template scenario outputs with locking scripts and values
+ *
+ * For each input in the transaction:
+ * - Generates appropriate locking bytecode (P2PKH or contract)
+ * - Includes the input value in satoshis
+ * - Includes any token details if present
+ *
+ * The slotIndex tracks which input is the contract input vs P2PKH inputs
+ * to properly generate the locking scripts.
+ */
 const generateTemplateScenarioSourceOutputs = (csTransaction) => {
     const slotIndex = csTransaction.inputs.findIndex((input) => !isUtxoP2PKH(input));
     return csTransaction.inputs.map((input, index) => {
@@ -208,7 +222,7 @@ const generateTemplateScenarioSourceOutputs = (csTransaction) => {
     });
 };
 // Used for generating the locking / unlocking bytecode for source outputs and inputs
-const generateTemplateScenarioBytecode = (input, p2pkhScriptName, placeholderKeyName, insertSlot) => {
+export const generateTemplateScenarioBytecode = (input, p2pkhScriptName, placeholderKeyName, insertSlot) => {
     if (isUtxoP2PKH(input)) {
         return {
             script: p2pkhScriptName,
@@ -223,26 +237,29 @@ const generateTemplateScenarioBytecode = (input, p2pkhScriptName, placeholderKey
     }
     return insertSlot ? ['slot'] : {};
 };
-const generateTemplateScenarioParametersValues = (types, encodedArgs) => {
+export const generateTemplateScenarioParametersValues = (types, encodedArgs) => {
     const typesAndArguments = zip(types, encodedArgs);
     const entries = typesAndArguments
         // SignatureTemplates are handled by the 'keys' object in the scenario
         .filter(([, arg]) => !(arg instanceof SignatureTemplate))
         .map(([input, arg]) => {
         const encodedArgumentHex = binToHex(arg);
-        const prefixedEncodedArgument = encodedArgumentHex.length > 0 ? `0x${encodedArgumentHex}` : '';
+        const prefixedEncodedArgument = addHexPrefixExceptEmpty(encodedArgumentHex);
         return [snakeCase(input.name), prefixedEncodedArgument];
     });
     return Object.fromEntries(entries);
 };
-const generateTemplateScenarioKeys = (types, encodedArgs) => {
+export const addHexPrefixExceptEmpty = (value) => {
+    return value.length > 0 ? `0x${value}` : '';
+};
+export 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)]);
     return Object.fromEntries(entries);
 };
-const formatParametersForDebugging = (types, args) => {
+export const formatParametersForDebugging = (types, args) => {
     if (types.length === 0)
         return '// none';
     // We reverse the arguments because the order of the arguments in the bytecode is reversed
@@ -259,14 +276,14 @@ const formatParametersForDebugging = (types, args) => {
         return `<${snakeCase(input.name)}> // ${typeStr} = <${`0x${binToHex(arg)}`}>`;
     }).join('\n');
 };
-const getSignatureAlgorithmName = (signatureAlgorithm) => {
+export const getSignatureAlgorithmName = (signatureAlgorithm) => {
     const signatureAlgorithmNames = {
         [SignatureAlgorithm.SCHNORR]: 'schnorr_signature',
         [SignatureAlgorithm.ECDSA]: 'ecdsa_signature',
     };
     return signatureAlgorithmNames[signatureAlgorithm];
 };
-const getHashTypeName = (hashType) => {
+export const getHashTypeName = (hashType) => {
     const hashtypeNames = {
         [HashType.SIGHASH_ALL]: 'all_outputs',
         [HashType.SIGHASH_ALL | HashType.SIGHASH_ANYONECANPAY]: 'all_outputs_single_input',
@@ -283,7 +300,7 @@ const getHashTypeName = (hashType) => {
     };
     return hashtypeNames[hashType];
 };
-const formatBytecodeForDebugging = (artifact) => {
+export const formatBytecodeForDebugging = (artifact) => {
     if (!artifact.debug) {
         return artifact.bytecode
             .split(' ')
@@ -292,7 +309,7 @@ const formatBytecodeForDebugging = (artifact) => {
     }
     return formatBitAuthScript(bytecodeToScript(hexToBin(artifact.debug.bytecode)), artifact.debug.sourceMap, artifact.source);
 };
-const serialiseTokenDetails = (token) => {
+export const serialiseTokenDetails = (token) => {
     if (!token)
         return undefined;
     return {

package/dist/SignatureTemplate.js

@@ -46,6 +46,7 @@ export default class SignatureTemplate {
                 const unlockingBytecode = scriptToBytecode([signature, publicKey]);
                 return unlockingBytecode;
             },
+            template: this,
         };
     }
 }

package/dist/Transaction.d.ts

@@ -3,7 +3,7 @@ import { AbiFunction } from '@cashscript/utils';
 import { Utxo, Output, Recipient, TokenDetails, TransactionDetails, Unlocker } from './interfaces.js';
 import SignatureTemplate from './SignatureTemplate.js';
 import { Contract } from './Contract.js';
-import { DebugResult } from './debugging.js';
+import { DebugResults } from './debugging.js';
 import { EncodedFunctionArgument } from './Argument.js';
 export declare class Transaction {
     contract: Contract;
@@ -37,7 +37,7 @@ export declare class Transaction {
     build(): Promise<string>;
     send(): Promise<TransactionDetails>;
     send(raw: true): Promise<string>;
-    debug(): Promise<DebugResult>;
+    debug(): Promise<DebugResults>;
     bitauthUri(): Promise<string>;
     getLibauthTemplate(): Promise<WalletTemplate>;
     private getTxDetails;

package/dist/Transaction.js

@@ -1,9 +1,9 @@
 import { hexToBin, decodeTransaction, } from '@bitauth/libauth';
 import delay from 'delay';
-import { encodeBip68, placeholder, scriptToBytecode, } from '@cashscript/utils';
+import { encodeBip68, placeholder, } from '@cashscript/utils';
 import deepEqual from 'fast-deep-equal';
 import { isUtxoP2PKH, SignatureAlgorithm, } from './interfaces.js';
-import { createInputScript, getInputSize, createOpReturnOutput, getTxSizeWithoutInputs, getPreimageSize, validateOutput, utxoComparator, calculateDust, getOutputSize, utxoTokenComparator, } from './utils.js';
+import { createInputScript, getInputSize, createOpReturnOutput, getTxSizeWithoutInputs, 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';
@@ -101,10 +101,7 @@ export class Transaction {
     async send(raw) {
         const tx = await this.build();
         // 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();
-        }
+        await this.debug();
         try {
             const txid = await this.contract.provider.sendRawTransaction(tx);
             return raw ? await this.getTxDetails(txid, raw) : await this.getTxDetails(txid);
@@ -120,7 +117,7 @@ export class Transaction {
             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);
+        return debugTemplate(template, [this.contract.artifact]);
     }
     async bitauthUri() {
         const template = await this.getLibauthTemplate();
@@ -259,13 +256,8 @@ export class Transaction {
             // (see https://transactionfee.info/charts/bitcoin-script-ecdsa-length/)
             return placeholder(73);
         });
-        // Create a placeholder preimage of the correct size
-        const placeholderPreimage = this.abiFunction.covenant
-            ? placeholder(getPreimageSize(scriptToBytecode(this.contract.redeemScript)))
-            : undefined;
-        // Create a placeholder input script for size calculation using the placeholder
-        // arguments and correctly sized placeholder preimage
-        const placeholderScript = createInputScript(this.contract.redeemScript, placeholderArgs, this.selector, placeholderPreimage);
+        // Create a placeholder input script for size calculation using the placeholder arguments
+        const placeholderScript = createInputScript(this.contract.redeemScript, placeholderArgs, this.selector);
         // Add one extra byte per input to over-estimate tx-in count
         const contractInputSize = getInputSize(placeholderScript) + 1;
         // Note that we use the addPrecision function to add "decimal points" to BigInt numbers

package/dist/TransactionBuilder.d.ts

@@ -1,5 +1,7 @@
+import { Transaction as LibauthTransaction, WalletTemplate } from '@bitauth/libauth';
 import { Unlocker, Output, TransactionDetails, UnlockableUtxo, Utxo, InputOptions } from './interfaces.js';
 import { NetworkProvider } from './network/index.js';
+import { DebugResults } from './debugging.js';
 export interface TransactionBuilderOptions {
     provider: NetworkProvider;
 }
@@ -7,8 +9,8 @@ export declare class TransactionBuilder {
     provider: NetworkProvider;
     inputs: UnlockableUtxo[];
     outputs: Output[];
-    private locktime;
-    private maxFee?;
+    locktime: number;
+    maxFee?: bigint;
     constructor(options: TransactionBuilderOptions);
     addInput(utxo: Utxo, unlocker: Unlocker, options?: InputOptions): this;
     addInputs(utxos: Utxo[], unlocker: Unlocker, options?: InputOptions): this;
@@ -19,7 +21,11 @@ export declare class TransactionBuilder {
     setLocktime(locktime: number): this;
     setMaxFee(maxFee: bigint): this;
     private checkMaxFee;
+    buildLibauthTransaction(): LibauthTransaction;
     build(): string;
+    debug(): Promise<DebugResults>;
+    bitauthUri(): string;
+    getLibauthTemplate(): WalletTemplate;
     send(): Promise<TransactionDetails>;
     send(raw: true): Promise<string>;
     private getTxDetails;

package/dist/TransactionBuilder.js

@@ -1,20 +1,23 @@
 import { binToHex, decodeTransaction, encodeTransaction, hexToBin, } from '@bitauth/libauth';
 import delay from 'delay';
 import { isUnlockableUtxo, } from './interfaces.js';
-import { cashScriptOutputToLibauthOutput, createOpReturnOutput, validateOutput, } from './utils.js';
+import { cashScriptOutputToLibauthOutput, createOpReturnOutput, validateInput, validateOutput, } from './utils.js';
 import { FailedTransactionError } from './Errors.js';
+import { getBitauthUri } from './LibauthTemplate.js';
+import { debugLibauthTemplate, getLibauthTemplates } from './advanced/LibauthTemplate.js';
 const DEFAULT_SEQUENCE = 0xfffffffe;
 export class TransactionBuilder {
     constructor(options) {
         this.inputs = [];
         this.outputs = [];
+        this.locktime = 0;
         this.provider = options.provider;
     }
     addInput(utxo, unlocker, options) {
-        this.inputs.push({ ...utxo, unlocker, options });
-        return this;
+        return this.addInputs([utxo], unlocker, options);
     }
     addInputs(utxos, unlocker, options) {
+        utxos.forEach(validateInput);
         if ((!unlocker && utxos.some((utxo) => !isUnlockableUtxo(utxo)))
             || (unlocker && utxos.some((utxo) => isUnlockableUtxo(utxo)))) {
             throw new Error('Either all UTXOs must have an individual unlocker specified, or no UTXOs must have an individual unlocker specified and a shared unlocker must be provided');
@@ -57,7 +60,7 @@ export class TransactionBuilder {
             throw new Error(`Transaction fee of ${fee} is higher than max fee of ${this.maxFee}`);
         }
     }
-    build() {
+    buildLibauthTransaction() {
         this.checkMaxFee();
         const inputs = this.inputs.map((utxo) => ({
             outpointIndex: utxo.vout,
@@ -85,10 +88,27 @@ export class TransactionBuilder {
         inputScripts.forEach((script, i) => {
             transaction.inputs[i].unlockingBytecode = script;
         });
+        return transaction;
+    }
+    build() {
+        const transaction = this.buildLibauthTransaction();
         return binToHex(encodeTransaction(transaction));
     }
+    // method to debug the transaction with libauth VM, throws upon evaluation error
+    // TODO: Remove the async in the future (this currently breaks our debugging tests)
+    async debug() {
+        return debugLibauthTemplate(this.getLibauthTemplate(), this);
+    }
+    bitauthUri() {
+        return getBitauthUri(this.getLibauthTemplate());
+    }
+    getLibauthTemplate() {
+        return getLibauthTemplates(this);
+    }
     async send(raw) {
         const tx = this.build();
+        // Debug the transaction locally before sending so any errors are caught early
+        await this.debug();
         try {
             const txid = await this.provider.sendRawTransaction(tx);
             return raw ? await this.getTxDetails(txid, raw) : await this.getTxDetails(txid);