cashscript 0.11.4 → 0.12.0

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;

package/dist/libauth-template/LibauthTemplate.js

@@ -0,0 +1,445 @@
+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 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';
+// TODO: Add / improve descriptions throughout the template generation
+export const getLibauthTemplate = (transactionBuilder) => {
+    if (transactionBuilder.inputs.some((input) => !isStandardUnlockableUtxo(input))) {
+        throw new Error('Cannot use debugging functionality with a transaction that contains custom unlockers');
+    }
+    const libauthTransaction = transactionBuilder.buildLibauthTransaction();
+    const vmTarget = transactionBuilder.provider instanceof MockNetworkProvider
+        ? transactionBuilder.provider.vmTarget
+        : VmTarget.BCH_2025_05;
+    const template = {
+        $schema: 'https://ide.bitauth.com/authentication-template-v0.schema.json',
+        description: 'Imported from cashscript',
+        name: 'CashScript Generated Debugging Template',
+        supported: [vmTarget],
+        version: 0,
+        entities: generateAllTemplateEntities(transactionBuilder),
+        scripts: generateAllTemplateScripts(transactionBuilder),
+        scenarios: generateAllTemplateScenarios(libauthTransaction, transactionBuilder),
+    };
+    // TODO: Refactor the below code to not have deep reassignment of scenario.sourceOutputs and scenario.transaction.outputs
+    // Initialize bytecode mappings, these will be used to map the locking and unlocking scripts and naming the scripts
+    const unlockingBytecodeToLockingBytecodeParams = {};
+    const lockingBytecodeToLockingBytecodeParams = {};
+    // We can typecast this because we check that all inputs are standard unlockable at the top of this function
+    for (const [inputIndex, input] of transactionBuilder.inputs.entries()) {
+        if (isContractUnlocker(input.unlocker)) {
+            const lockScriptName = getLockScriptName(input.unlocker.contract);
+            if (!lockScriptName)
+                continue;
+            const lockingScriptParams = generateLockingScriptParams(input.unlocker.contract, input, lockScriptName);
+            const unlockingBytecode = binToHex(libauthTransaction.inputs[inputIndex].unlockingBytecode);
+            unlockingBytecodeToLockingBytecodeParams[unlockingBytecode] = lockingScriptParams;
+            const lockingBytecode = binToHex(addressToLockScript(input.unlocker.contract.address));
+            lockingBytecodeToLockingBytecodeParams[lockingBytecode] = lockingScriptParams;
+        }
+    }
+    for (const scenario of Object.values(template.scenarios)) {
+        // For Inputs
+        for (const [idx, input] of libauthTransaction.inputs.entries()) {
+            const unlockingBytecode = binToHex(input.unlockingBytecode);
+            const lockingBytecodeParams = unlockingBytecodeToLockingBytecodeParams[unlockingBytecode];
+            // If lockingBytecodeParams is unknown, then it stays at default: {}
+            if (!lockingBytecodeParams)
+                continue;
+            //  If locking bytecode is set to ['slot'] then this is being evaluated by the scenario, so we don't replace bytecode
+            if (lockingBytecodeIsSetToSlot(scenario?.sourceOutputs?.[idx]?.lockingBytecode))
+                continue;
+            // If lockingBytecodeParams is known, and this input is not ['slot'] then assign a locking bytecode as source output
+            if (scenario.sourceOutputs?.[idx]) {
+                scenario.sourceOutputs[idx] = {
+                    ...scenario.sourceOutputs[idx],
+                    lockingBytecode: lockingBytecodeParams,
+                };
+            }
+        }
+        // For Outputs
+        for (const [idx, output] of libauthTransaction.outputs.entries()) {
+            const lockingBytecode = binToHex(output.lockingBytecode);
+            const lockingBytecodeParams = lockingBytecodeToLockingBytecodeParams[lockingBytecode];
+            // If lockingBytecodeParams is unknown, then it stays at default: {}
+            if (!lockingBytecodeParams)
+                continue;
+            //  If locking bytecode is set to ['slot'] then this is being evaluated by the scenario, so we don't replace bytecode
+            if (lockingBytecodeIsSetToSlot(scenario?.transaction?.outputs?.[idx]?.lockingBytecode))
+                continue;
+            // If lockingBytecodeParams is known, and this input is not ['slot'] then assign a locking bytecode as source output
+            if (scenario?.transaction?.outputs?.[idx]) {
+                scenario.transaction.outputs[idx] = {
+                    ...scenario.transaction.outputs[idx],
+                    lockingBytecode: lockingBytecodeParams,
+                };
+            }
+        }
+    }
+    return template;
+};
+export const debugLibauthTemplate = (template, transaction) => {
+    const allArtifacts = transaction.inputs
+        .map(input => isContractUnlocker(input.unlocker) ? input.unlocker.contract : undefined)
+        .filter((contract) => Boolean(contract))
+        .map(contract => contract.artifact);
+    return debugTemplate(template, allArtifacts);
+};
+export const getBitauthUri = (template) => {
+    const base64toBase64Url = (base64) => base64.replace(/\+/g, '-').replace(/\//g, '_');
+    const payload = base64toBase64Url(binToBase64(deflate(utf8ToBin(extendedStringify(template)))));
+    return `https://ide.bitauth.com/import-template/${payload}`;
+};
+const generateAllTemplateEntities = (transactionBuilder) => {
+    const entities = transactionBuilder.inputs.map((input, inputIndex) => {
+        if (isP2PKHUnlocker(input.unlocker)) {
+            return generateTemplateEntitiesP2PKH(inputIndex);
+        }
+        if (isContractUnlocker(input.unlocker)) {
+            const encodedArgs = encodeFunctionArguments(input.unlocker.abiFunction, input.unlocker.params ?? []);
+            return generateTemplateEntitiesP2SH(input.unlocker.contract, input.unlocker.abiFunction, encodedArgs, inputIndex);
+        }
+        throw new Error('Unknown unlocker type');
+    });
+    return entities.reduce((acc, entity) => ({ ...acc, ...entity }), {});
+};
+const generateAllTemplateScripts = (transactionBuilder) => {
+    const scripts = transactionBuilder.inputs.map((input, inputIndex) => {
+        if (isP2PKHUnlocker(input.unlocker)) {
+            return generateTemplateScriptsP2PKH(inputIndex);
+        }
+        if (isContractUnlocker(input.unlocker)) {
+            const encodedArgs = encodeFunctionArguments(input.unlocker.abiFunction, input.unlocker.params ?? []);
+            return generateTemplateScriptsP2SH(input.unlocker.contract, input.unlocker.abiFunction, encodedArgs, input.unlocker.contract.encodedConstructorArgs, inputIndex);
+        }
+        throw new Error('Unknown unlocker type');
+    });
+    return scripts.reduce((acc, script) => ({ ...acc, ...script }), {});
+};
+const generateAllTemplateScenarios = (libauthTransaction, transactionBuilder) => {
+    const scenarios = transactionBuilder.inputs.map((input, inputIndex) => {
+        if (isP2PKHUnlocker(input.unlocker)) {
+            return generateTemplateScenariosP2PKH(libauthTransaction, transactionBuilder, inputIndex);
+        }
+        if (isContractUnlocker(input.unlocker)) {
+            const encodedArgs = encodeFunctionArguments(input.unlocker.abiFunction, input.unlocker.params ?? []);
+            return generateTemplateScenarios(input.unlocker.contract, libauthTransaction, transactionBuilder, input.unlocker.abiFunction, encodedArgs, inputIndex);
+        }
+        throw new Error('Unknown unlocker type');
+    });
+    return scenarios.reduce((acc, scenario) => ({ ...acc, ...scenario }), {});
+};
+const generateTemplateEntitiesP2PKH = (inputIndex) => {
+    const lockScriptName = `p2pkh_placeholder_lock_${inputIndex}`;
+    const unlockScriptName = `p2pkh_placeholder_unlock_${inputIndex}`;
+    return {
+        [`signer_${inputIndex}`]: {
+            scripts: [lockScriptName, unlockScriptName],
+            description: `P2PKH data for input ${inputIndex}`,
+            name: `P2PKH Signer (input #${inputIndex})`,
+            variables: {
+                [`signature_${inputIndex}`]: {
+                    description: '',
+                    name: `P2PKH Signature (input #${inputIndex})`,
+                    type: 'WalletData',
+                },
+                [`public_key_${inputIndex}`]: {
+                    description: '',
+                    name: `P2PKH public key (input #${inputIndex})`,
+                    type: 'WalletData',
+                },
+            },
+        },
+    };
+};
+const generateTemplateEntitiesP2SH = (contract, abiFunction, encodedFunctionArgs, inputIndex) => {
+    const entities = {
+        [contract.artifact.contractName + '_input' + inputIndex + '_parameters']: {
+            description: 'Contract creation and function parameters',
+            name: `${contract.artifact.contractName} (input #${inputIndex})`,
+            scripts: [
+                getLockScriptName(contract),
+                getUnlockScriptName(contract, abiFunction, inputIndex),
+            ],
+            variables: {
+                ...createWalletTemplateVariables(contract.artifact, abiFunction, encodedFunctionArgs),
+                ...generateFunctionIndexTemplateVariable(contract.artifact.abi),
+            },
+        },
+    };
+    return entities;
+};
+const createWalletTemplateVariables = (artifact, abiFunction, encodedFunctionArgs) => {
+    const functionParameters = Object.fromEntries(abiFunction.inputs.map((input, index) => ([
+        input.name,
+        {
+            description: `"${input.name}" parameter of function "${abiFunction.name}"`,
+            name: input.name,
+            type: encodedFunctionArgs[index] instanceof SignatureTemplate ? 'Key' : 'WalletData',
+        },
+    ])));
+    const constructorParameters = Object.fromEntries(artifact.constructorInputs.map((input) => ([
+        input.name,
+        {
+            description: `"${input.name}" parameter of this contract`,
+            name: input.name,
+            type: 'WalletData',
+        },
+    ])));
+    return { ...functionParameters, ...constructorParameters };
+};
+const generateTemplateScriptsP2PKH = (inputIndex) => {
+    const lockScriptName = `p2pkh_placeholder_lock_${inputIndex}`;
+    const unlockScriptName = `p2pkh_placeholder_unlock_${inputIndex}`;
+    const scripts = {
+        [unlockScriptName]: {
+            passes: [`P2PKH_spend_input${inputIndex}_evaluate`],
+            name: `P2PKH Unlock (input #${inputIndex})`,
+            script: `<signature_${inputIndex}>\n<public_key_${inputIndex}>`,
+            unlocks: lockScriptName,
+        },
+        [lockScriptName]: {
+            lockingType: 'standard',
+            name: `P2PKH Lock (input #${inputIndex})`,
+            script: `OP_DUP\nOP_HASH160 <$(<public_key_${inputIndex}> OP_HASH160\n)> OP_EQUALVERIFY\nOP_CHECKSIG`,
+        },
+    };
+    return scripts;
+};
+const generateTemplateScriptsP2SH = (contract, abiFunction, encodedFunctionArgs, encodedConstructorArgs, inputIndex) => {
+    const unlockingScriptName = getUnlockScriptName(contract, abiFunction, inputIndex);
+    const lockingScriptName = getLockScriptName(contract);
+    return {
+        [unlockingScriptName]: generateTemplateUnlockScript(contract, abiFunction, encodedFunctionArgs, inputIndex),
+        [lockingScriptName]: generateTemplateLockScript(contract, encodedConstructorArgs),
+    };
+};
+const generateTemplateLockScript = (contract, constructorArguments) => {
+    return {
+        lockingType: contract.addressType,
+        name: contract.artifact.contractName,
+        script: [
+            `// "${contract.artifact.contractName}" contract constructor parameters`,
+            formatParametersForDebugging(contract.artifact.constructorInputs, constructorArguments),
+            '',
+            '// bytecode',
+            formatBytecodeForDebugging(contract.artifact),
+        ].join('\n'),
+    };
+};
+const generateTemplateUnlockScript = (contract, abiFunction, encodedFunctionArgs, inputIndex) => {
+    const scenarioIdentifier = `${contract.artifact.contractName}_${abiFunction.name}_input${inputIndex}_evaluate`;
+    const functionIndex = contract.artifact.abi.findIndex((func) => func.name === abiFunction.name);
+    const functionIndexString = contract.artifact.abi.length > 1
+        ? ['// function index in contract', `<function_index> // int = <${functionIndex}>`, '']
+        : [];
+    return {
+        // this unlocking script must pass our only scenario
+        passes: [scenarioIdentifier],
+        name: `${abiFunction.name} (input #${inputIndex})`,
+        script: [
+            `// "${abiFunction.name}" function parameters`,
+            formatParametersForDebugging(abiFunction.inputs, encodedFunctionArgs),
+            '',
+            ...functionIndexString,
+        ].join('\n'),
+        unlocks: getLockScriptName(contract),
+    };
+};
+const generateTemplateScenarios = (contract, libauthTransaction, transactionBuilder, abiFunction, encodedFunctionArgs, inputIndex) => {
+    const artifact = contract.artifact;
+    const encodedConstructorArgs = contract.encodedConstructorArgs;
+    const scenarioIdentifier = `${artifact.contractName}_${abiFunction.name}_input${inputIndex}_evaluate`;
+    const scenarios = {
+        // single scenario to spend out transaction under test given the CashScript parameters provided
+        [scenarioIdentifier]: {
+            name: `Evaluate ${artifact.contractName} ${abiFunction.name} (input #${inputIndex})`,
+            description: 'An example evaluation where this script execution passes.',
+            data: {
+                // encode values for the variables defined above in `entities` property
+                bytecode: {
+                    ...generateTemplateScenarioParametersFunctionIndex(abiFunction, contract.artifact.abi),
+                    ...generateTemplateScenarioParametersValues(abiFunction.inputs, encodedFunctionArgs),
+                    ...generateTemplateScenarioParametersValues(artifact.constructorInputs, encodedConstructorArgs),
+                },
+                keys: {
+                    privateKeys: generateTemplateScenarioKeys(abiFunction.inputs, encodedFunctionArgs),
+                },
+            },
+            transaction: generateTemplateScenarioTransaction(contract, libauthTransaction, transactionBuilder, inputIndex),
+            sourceOutputs: generateTemplateScenarioSourceOutputs(transactionBuilder, libauthTransaction, inputIndex),
+        },
+    };
+    return scenarios;
+};
+const generateTemplateScenariosP2PKH = (libauthTransaction, transactionBuilder, inputIndex) => {
+    const scenarioIdentifier = `P2PKH_spend_input${inputIndex}_evaluate`;
+    const { signature, publicKey } = getSignatureAndPubkeyFromP2PKHInput(libauthTransaction.inputs[inputIndex]);
+    const scenarios = {
+        // single scenario to spend out transaction under test given the CashScript parameters provided
+        [scenarioIdentifier]: {
+            name: `Evaluate P2PKH spend (input #${inputIndex})`,
+            description: 'An example evaluation where this script execution passes.',
+            data: {
+                // encode values for the variables defined above in `entities` property
+                bytecode: {
+                    [`signature_${inputIndex}`]: `0x${binToHex(signature)}`,
+                    [`public_key_${inputIndex}`]: `0x${binToHex(publicKey)}`,
+                },
+            },
+            transaction: generateTemplateScenarioTransaction(undefined, libauthTransaction, transactionBuilder, inputIndex),
+            sourceOutputs: generateTemplateScenarioSourceOutputs(transactionBuilder, libauthTransaction, inputIndex),
+        },
+    };
+    return scenarios;
+};
+const generateTemplateScenarioTransaction = (contract, libauthTransaction, transactionBuilder, slotIndex) => {
+    const zippedInputs = zip(transactionBuilder.inputs, libauthTransaction.inputs);
+    const inputs = zippedInputs.map(([csInput, libauthInput], inputIndex) => {
+        return {
+            outpointIndex: libauthInput.outpointIndex,
+            outpointTransactionHash: binToHex(libauthInput.outpointTransactionHash),
+            sequenceNumber: libauthInput.sequenceNumber,
+            unlockingBytecode: generateTemplateScenarioBytecode(csInput, libauthInput, inputIndex, 'p2pkh_placeholder_unlock', slotIndex === inputIndex),
+        };
+    });
+    const locktime = libauthTransaction.locktime;
+    const zippedOutputs = zip(transactionBuilder.outputs, libauthTransaction.outputs);
+    const outputs = zippedOutputs.map(([csOutput, libauthOutput]) => {
+        if (csOutput && contract) {
+            return {
+                lockingBytecode: generateTemplateScenarioTransactionOutputLockingBytecode(csOutput, contract),
+                token: serialiseTokenDetails(libauthOutput.token),
+                valueSatoshis: Number(libauthOutput.valueSatoshis),
+            };
+        }
+        return {
+            lockingBytecode: `${binToHex(libauthOutput.lockingBytecode)}`,
+            token: serialiseTokenDetails(libauthOutput.token),
+            valueSatoshis: Number(libauthOutput.valueSatoshis),
+        };
+    });
+    const version = libauthTransaction.version;
+    return { inputs, locktime, outputs, version };
+};
+const generateTemplateScenarioSourceOutputs = (transactionBuilder, libauthTransaction, slotIndex) => {
+    const zippedInputs = zip(transactionBuilder.inputs, libauthTransaction.inputs);
+    return zippedInputs.map(([csInput, libauthInput], inputIndex) => {
+        return {
+            lockingBytecode: generateTemplateScenarioBytecode(csInput, libauthInput, inputIndex, 'p2pkh_placeholder_lock', inputIndex === slotIndex),
+            valueSatoshis: Number(csInput.satoshis),
+            token: serialiseTokenDetails(csInput.token),
+        };
+    });
+};
+const generateLockingScriptParams = (contract, { unlocker }, lockScriptName) => {
+    if (isP2PKHUnlocker(unlocker)) {
+        return {
+            script: lockScriptName,
+        };
+    }
+    const constructorParamsEntries = contract.artifact.constructorInputs
+        .map(({ name }, index) => [
+        name,
+        addHexPrefixExceptEmpty(binToHex(unlocker.contract.encodedConstructorArgs[index])),
+    ]);
+    const constructorParams = Object.fromEntries(constructorParamsEntries);
+    return {
+        script: lockScriptName,
+        overrides: {
+            bytecode: { ...constructorParams },
+        },
+    };
+};
+const generateUnlockingScriptParams = (csInput, libauthInput, p2pkhScriptNameTemplate, inputIndex) => {
+    if (isP2PKHUnlocker(csInput.unlocker)) {
+        const { signature, publicKey } = getSignatureAndPubkeyFromP2PKHInput(libauthInput);
+        return {
+            script: `${p2pkhScriptNameTemplate}_${inputIndex}`,
+            overrides: {
+                bytecode: {
+                    [`signature_${inputIndex}`]: `0x${binToHex(signature)}`,
+                    [`public_key_${inputIndex}`]: `0x${binToHex(publicKey)}`,
+                },
+            },
+        };
+    }
+    const abiFunction = csInput.unlocker.abiFunction;
+    const contract = csInput.unlocker.contract;
+    const encodedFunctionArgs = encodeFunctionArguments(abiFunction, csInput.unlocker.params);
+    return {
+        script: getUnlockScriptName(contract, abiFunction, inputIndex),
+        overrides: {
+            // encode values for the variables defined above in `entities` property
+            bytecode: {
+                ...generateTemplateScenarioParametersFunctionIndex(abiFunction, contract.artifact.abi),
+                ...generateTemplateScenarioParametersValues(abiFunction.inputs, encodedFunctionArgs),
+                ...generateTemplateScenarioParametersValues(contract.artifact.constructorInputs, contract.encodedConstructorArgs),
+            },
+            keys: {
+                privateKeys: generateTemplateScenarioKeys(abiFunction.inputs, encodedFunctionArgs),
+            },
+        },
+    };
+};
+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 = addHexPrefixExceptEmpty(encodedArgumentHex);
+        return [input.name, prefixedEncodedArgument];
+    });
+    return Object.fromEntries(entries);
+};
+const generateTemplateScenarioKeys = (types, encodedArgs) => {
+    const typesAndArguments = zip(types, encodedArgs);
+    const entries = typesAndArguments
+        .filter(([, arg]) => arg instanceof SignatureTemplate)
+        .map(([input, arg]) => [input.name, binToHex(arg.privateKey)]);
+    return Object.fromEntries(entries);
+};
+// Used for generating the locking / unlocking bytecode for source outputs and inputs
+const generateTemplateScenarioBytecode = (input, libauthInput, inputIndex, p2pkhScriptNameTemplate, insertSlot) => {
+    if (insertSlot)
+        return ['slot'];
+    if (isUnlockableUtxo(input) && isStandardUnlockableUtxo(input)) {
+        return generateUnlockingScriptParams(input, libauthInput, p2pkhScriptNameTemplate, inputIndex);
+    }
+    // 'slot' means that we are currently evaluating this specific input,
+    // {} means that it is the same script type, but not being evaluated
+    return {};
+};
+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));
+};
+const generateTemplateScenarioParametersFunctionIndex = (abiFunction, abi) => {
+    const functionIndex = abi.length > 1
+        ? abi.findIndex((func) => func.name === abiFunction.name)
+        : undefined;
+    return functionIndex !== undefined ? { function_index: functionIndex.toString() } : {};
+};
+const generateFunctionIndexTemplateVariable = (abi) => {
+    if (abi.length > 1) {
+        return {
+            function_index: {
+                description: 'Script function index to execute',
+                name: 'function_index',
+                type: 'WalletData',
+            },
+        };
+    }
+    return {};
+};
+//# sourceMappingURL=LibauthTemplate.js.map

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

@@ -0,0 +1,27 @@
+import { AbiFunction, AbiInput, Artifact } from '@cashscript/utils';
+import { HashType, LibauthTokenDetails, SignatureAlgorithm, TokenDetails } from '../interfaces.js';
+import { type WalletTemplateScenarioBytecode, Input } from '@bitauth/libauth';
+import { EncodedFunctionArgument } from '../Argument.js';
+import { Contract } from '../Contract.js';
+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;
+export declare const getHashTypeName: (hashType: HashType) => string;
+export declare const addHexPrefixExceptEmpty: (value: string) => string;
+export declare const formatParametersForDebugging: (types: readonly AbiInput[], args: EncodedFunctionArgument[]) => string;
+export declare const formatBytecodeForDebugging: (artifact: Artifact) => string;
+export declare const serialiseTokenDetails: (token?: TokenDetails | LibauthTokenDetails) => LibauthTemplateTokenDetails | undefined;
+interface LibauthTemplateTokenDetails {
+    amount: string;
+    category: string;
+    nft?: {
+        capability: 'none' | 'mutable' | 'minting';
+        commitment: string;
+    };
+}
+export declare const lockingBytecodeIsSetToSlot: (lockingBytecode?: WalletTemplateScenarioBytecode | ["slot"]) => boolean;
+export declare const getSignatureAndPubkeyFromP2PKHInput: (libauthInput: Input) => {
+    signature: Uint8Array;
+    publicKey: Uint8Array;
+};
+export {};

package/dist/libauth-template/utils.js

@@ -0,0 +1,89 @@
+import { bytecodeToScript, formatBitAuthScript } from '@cashscript/utils';
+import { HashType, SignatureAlgorithm } 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 getLockScriptName = (contract) => {
+    const result = decodeCashAddress(contract.address);
+    if (typeof result === 'string')
+        throw new Error(result);
+    return `${contract.artifact.contractName}_${binToHex(result.payload)}_lock`;
+};
+export const getUnlockScriptName = (contract, abiFunction, inputIndex) => {
+    return `${contract.artifact.contractName}_${abiFunction.name}_input${inputIndex}_unlock`;
+};
+export const getSignatureAlgorithmName = (signatureAlgorithm) => {
+    const signatureAlgorithmNames = {
+        [SignatureAlgorithm.SCHNORR]: 'schnorr_signature',
+        [SignatureAlgorithm.ECDSA]: 'ecdsa_signature',
+    };
+    return signatureAlgorithmNames[signatureAlgorithm];
+};
+export const getHashTypeName = (hashType) => {
+    const hashtypeNames = {
+        [HashType.SIGHASH_ALL]: 'all_outputs',
+        [HashType.SIGHASH_ALL | HashType.SIGHASH_ANYONECANPAY]: 'all_outputs_single_input',
+        [HashType.SIGHASH_ALL | HashType.SIGHASH_UTXOS]: 'all_outputs_all_utxos',
+        [HashType.SIGHASH_ALL | HashType.SIGHASH_ANYONECANPAY | HashType.SIGHASH_UTXOS]: 'all_outputs_single_input_INVALID_all_utxos',
+        [HashType.SIGHASH_SINGLE]: 'corresponding_output',
+        [HashType.SIGHASH_SINGLE | HashType.SIGHASH_ANYONECANPAY]: 'corresponding_output_single_input',
+        [HashType.SIGHASH_SINGLE | HashType.SIGHASH_UTXOS]: 'corresponding_output_all_utxos',
+        [HashType.SIGHASH_SINGLE | HashType.SIGHASH_ANYONECANPAY | HashType.SIGHASH_UTXOS]: 'corresponding_output_single_input_INVALID_all_utxos',
+        [HashType.SIGHASH_NONE]: 'no_outputs',
+        [HashType.SIGHASH_NONE | HashType.SIGHASH_ANYONECANPAY]: 'no_outputs_single_input',
+        [HashType.SIGHASH_NONE | HashType.SIGHASH_UTXOS]: 'no_outputs_all_utxos',
+        [HashType.SIGHASH_NONE | HashType.SIGHASH_ANYONECANPAY | HashType.SIGHASH_UTXOS]: 'no_outputs_single_input_INVALID_all_utxos',
+    };
+    return hashtypeNames[hashType];
+};
+export const addHexPrefixExceptEmpty = (value) => {
+    return value.length > 0 ? `0x${value}` : '';
+};
+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
+    const typesAndArguments = zip(types, args).reverse();
+    return typesAndArguments.map(([input, arg]) => {
+        if (arg instanceof SignatureTemplate) {
+            const signatureAlgorithmName = getSignatureAlgorithmName(arg.getSignatureAlgorithm());
+            const hashtypeName = getHashTypeName(arg.getHashType(false));
+            return `<${input.name}.${signatureAlgorithmName}.${hashtypeName}> // ${input.type}`;
+        }
+        const typeStr = input.type === 'bytes' ? `bytes${arg.length}` : input.type;
+        // we output these values as pushdata, comment will contain the type and the value of the variable
+        // e.g. <timeout> // int = <0xa08601>
+        return `<${input.name}> // ${typeStr} = <${`0x${binToHex(arg)}`}>`;
+    }).join('\n');
+};
+export const formatBytecodeForDebugging = (artifact) => {
+    if (!artifact.debug) {
+        return artifact.bytecode
+            .split(' ')
+            .map((asmElement) => (isHex(asmElement) ? `<0x${asmElement}>` : asmElement))
+            .join('\n');
+    }
+    return formatBitAuthScript(bytecodeToScript(hexToBin(artifact.debug.bytecode)), artifact.debug.sourceMap, artifact.source);
+};
+export const serialiseTokenDetails = (token) => {
+    if (!token)
+        return undefined;
+    return {
+        amount: token.amount.toString(),
+        category: token.category instanceof Uint8Array ? binToHex(token.category) : token.category,
+        nft: token.nft ? {
+            capability: token.nft.capability,
+            commitment: token.nft.commitment instanceof Uint8Array ? binToHex(token.nft.commitment) : token.nft.commitment,
+        } : undefined,
+    };
+};
+export const lockingBytecodeIsSetToSlot = (lockingBytecode) => {
+    return Array.isArray(lockingBytecode) && lockingBytecode.length === 1 && lockingBytecode[0] === 'slot';
+};
+export const getSignatureAndPubkeyFromP2PKHInput = (libauthInput) => {
+    const inputData = (assertSuccess(decodeAuthenticationInstructions(libauthInput.unlockingBytecode)));
+    const signature = inputData[0].data;
+    const publicKey = inputData[1].data;
+    return { signature, publicKey };
+};
+//# sourceMappingURL=utils.js.map

package/dist/network/MockNetworkProvider.d.ts

@@ -1,7 +1,8 @@
-import { Utxo, Network } from '../interfaces.js';
+import { Utxo, Network, VmTarget } from '../interfaces.js';
 import NetworkProvider from './NetworkProvider.js';
-interface MockNetworkProviderOptions {
+export interface MockNetworkProviderOptions {
     updateUtxoSet: boolean;
+    vmTarget?: VmTarget;
 }
 export default class MockNetworkProvider implements NetworkProvider {
     private utxoSet;
@@ -9,6 +10,7 @@ export default class MockNetworkProvider implements NetworkProvider {
     network: Network;
     blockHeight: number;
     options: MockNetworkProviderOptions;
+    vmTarget: VmTarget;
     constructor(options?: Partial<MockNetworkProviderOptions>);
     getUtxos(address: string): Promise<Utxo[]>;
     setBlockHeight(newBlockHeight: number): void;
@@ -18,4 +20,3 @@ export default class MockNetworkProvider implements NetworkProvider {
     addUtxo(addressOrLockingBytecode: string, utxo: Utxo): void;
     reset(): void;
 }
-export {};

package/dist/network/MockNetworkProvider.js

@@ -1,13 +1,7 @@
 import { binToHex, decodeTransactionUnsafe, hexToBin, isHex } from '@bitauth/libauth';
 import { sha256 } from '@cashscript/utils';
-import { Network } from '../interfaces.js';
-import { addressToLockScript, libauthTokenDetailsToCashScriptTokenDetails, randomUtxo } from '../utils.js';
-// redeclare the addresses from vars.ts instead of importing them
-const aliceAddress = 'bchtest:qpgjmwev3spwlwkgmyjrr2s2cvlkkzlewq62mzgjnp';
-const bobAddress = 'bchtest:qz6q5gqnxdldkr07xpls5474mmzmlesd6qnux4skuc';
-const carolAddress = 'bchtest:qqsr7nqwe6rq5crj63gy5gdqchpnwmguusmr7tfmsj';
-// We are setting the default updateUtxoSet to 'false' so that it doesn't break the current behaviour
-// TODO: in a future breaking release we want to set this to 'true' by default
+import { Network, VmTarget } from '../interfaces.js';
+import { addressToLockScript, libauthTokenDetailsToCashScriptTokenDetails } from '../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
@@ -15,12 +9,8 @@ export default class MockNetworkProvider {
         this.transactionMap = {};
         this.network = Network.MOCKNET;
         this.blockHeight = 133700;
-        this.options = { updateUtxoSet: false, ...options };
-        for (let i = 0; i < 3; i += 1) {
-            this.addUtxo(aliceAddress, randomUtxo());
-            this.addUtxo(bobAddress, randomUtxo());
-            this.addUtxo(carolAddress, randomUtxo());
-        }
+        this.options = { updateUtxoSet: true, ...options };
+        this.vmTarget = this.options.vmTarget ?? VmTarget.BCH_2025_05;
     }
     async getUtxos(address) {
         const addressLockingBytecode = binToHex(addressToLockScript(address));