cashscript 0.11.0-next.4 → 0.11.1

package/dist/Contract.d.ts

@@ -34,4 +34,3 @@ export declare class Contract<TArtifact extends Artifact = Artifact, TResolved e
     private createUnlocker;
 }
 export type ContractFunction = (...args: FunctionArgument[]) => Transaction;
-export type ContractUnlocker = (...args: FunctionArgument[]) => Unlocker;

package/dist/Errors.js

@@ -31,7 +31,8 @@ export class NoDebugInformationInArtifactError extends Error {
 }
 export class FailedTransactionError extends Error {
     constructor(reason, bitauthUri) {
-        super(`${reason}${bitauthUri ? `\n\nBitauth URI: ${bitauthUri}` : ''}`);
+        const warning = 'WARNING: it is unsafe to use this Bitauth URI when using real private keys as they are included in the transaction template';
+        super(`${reason}${bitauthUri ? `\n\n${warning}\n\nBitauth URI: ${bitauthUri}` : ''}`);
         this.reason = reason;
         this.bitauthUri = bitauthUri;
     }
@@ -53,14 +54,7 @@ export class FailedTransactionEvaluationError extends FailedTransactionError {
 }
 export class FailedRequireError extends FailedTransactionError {
     constructor(artifact, failingInstructionPointer, requireStatement, inputIndex, bitauthUri, libauthErrorMessage) {
-        let { statement, lineNumber } = getLocationDataForInstructionPointer(artifact, failingInstructionPointer);
-        if (!statement.includes('require')) {
-            statement = requireStatement.message
-                ? `require(${statement}, "${requireStatement.message}")`
-                : `require(${statement})`;
-            // Sometimes in reconstructed multiline require statements, we get double commas
-            statement = statement.replace(/,,/g, ',');
-        }
+        const { statement, lineNumber } = getLocationDataForInstructionPointer(artifact, failingInstructionPointer);
         const baseMessage = `${artifact.contractName}.cash:${lineNumber} Require statement failed at input ${inputIndex} in contract ${artifact.contractName}.cash at line ${lineNumber}`;
         const baseMessageWithRequireMessage = `${baseMessage} with the following message: ${requireStatement.message}`;
         const fullMessage = `${requireStatement.message ? baseMessageWithRequireMessage : baseMessage}.\nFailing statement: ${statement}`;

package/dist/LibauthTemplate.js

@@ -1,7 +1,7 @@
 import { bytecodeToScript, formatBitAuthScript, } from '@cashscript/utils';
 import { hexToBin, decodeTransaction, binToHex, binToBase64, utf8ToBin, isHex, } from '@bitauth/libauth';
 import { deflate } from 'pako';
-import { isUtxoP2PKH, SignatureAlgorithm, HashType, isUnlockableUtxo, } from './interfaces.js';
+import { isUtxoP2PKH, SignatureAlgorithm, HashType, isUnlockableUtxo, isStandardUnlockableUtxo, } from './interfaces.js';
 import SignatureTemplate from './SignatureTemplate.js';
 import { addressToLockScript, extendedStringify, zip } from './utils.js';
 import { generateUnlockingScriptParams } from './advanced/LibauthTemplate.js';
@@ -195,21 +195,6 @@ export const generateTemplateScenarioTransactionOutputLockingBytecode = (csOutpu
         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.
- */
-// TODO: This looks like it needs some refactor to work with the new stuff
 const generateTemplateScenarioSourceOutputs = (csTransaction) => {
     const slotIndex = csTransaction.inputs.findIndex((input) => !isUtxoP2PKH(input));
     return csTransaction.inputs.map((input, inputIndex) => {
@@ -239,7 +224,7 @@ export const generateTemplateScenarioBytecode = (input, inputIndex, p2pkhScriptN
             },
         };
     }
-    if (isUnlockableUtxo(input)) {
+    if (isUnlockableUtxo(input) && isStandardUnlockableUtxo(input)) {
         return generateUnlockingScriptParams(input, p2pkhScriptNameTemplate, inputIndex);
     }
     // 'slot' means that we are currently evaluating this specific input,

package/dist/SignatureTemplate.d.ts

@@ -1,4 +1,4 @@
-import { Unlocker, HashType, SignatureAlgorithm } from './interfaces.js';
+import { HashType, SignatureAlgorithm, P2PKHUnlocker } from './interfaces.js';
 export default class SignatureTemplate {
     private hashtype;
     private signatureAlgorithm;
@@ -8,7 +8,7 @@ export default class SignatureTemplate {
     getHashType(bchForkId?: boolean): number;
     getSignatureAlgorithm(): SignatureAlgorithm;
     getPublicKey(): Uint8Array;
-    unlockP2PKH(): Unlocker;
+    unlockP2PKH(): P2PKHUnlocker;
 }
 interface Keypair {
     toWIF(): string;

package/dist/Transaction.js

@@ -10,6 +10,7 @@ import { TransactionBuilder } from './TransactionBuilder.js';
 import { buildTemplate, getBitauthUri } from './LibauthTemplate.js';
 import { debugTemplate } from './debugging.js';
 import { FailedTransactionError } from './Errors.js';
+import semver from 'semver';
 export class Transaction {
     constructor(contract, unlocker, abiFunction, encodedFunctionArgs, selector) {
         this.contract = contract;
@@ -113,13 +114,14 @@ export class Transaction {
     }
     // method to debug the transaction with libauth VM, throws upon evaluation error
     async debug() {
-        if (!this.contract.artifact.debug) {
-            console.warn('No debug information found in artifact. Recompile with cashc version 0.10.0 or newer to get better debugging information.');
+        if (!semver.satisfies(this.contract.artifact.compiler.version, '>=0.11.0')) {
+            console.warn('For the best debugging experience, please recompile your contract with cashc version 0.11.0 or newer.');
         }
         const template = await this.getLibauthTemplate();
         return debugTemplate(template, [this.contract.artifact]);
     }
     async bitauthUri() {
+        console.warn('WARNING: it is unsafe to use this Bitauth URI when using real private keys as they are included in the transaction template');
         const template = await this.getLibauthTemplate();
         return getBitauthUri(template);
     }

package/dist/TransactionBuilder.d.ts

@@ -2,6 +2,8 @@ import { Transaction as LibauthTransaction, WalletTemplate } from '@bitauth/liba
 import { Unlocker, Output, TransactionDetails, UnlockableUtxo, Utxo, InputOptions } 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;
 }
@@ -23,10 +25,11 @@ export declare class TransactionBuilder {
     private checkMaxFee;
     buildLibauthTransaction(): LibauthTransaction;
     build(): string;
-    debug(): Promise<DebugResults>;
+    debug(): DebugResults;
     bitauthUri(): string;
     getLibauthTemplate(): WalletTemplate;
     send(): Promise<TransactionDetails>;
     send(raw: true): Promise<string>;
     private getTxDetails;
+    generateWcTransactionObject(options?: WcTransactionOptions): WcTransactionObject;
 }

package/dist/TransactionBuilder.js

@@ -1,10 +1,12 @@
-import { binToHex, decodeTransaction, encodeTransaction, hexToBin, } from '@bitauth/libauth';
+import { binToHex, decodeTransaction, decodeTransactionUnsafe, encodeTransaction, hexToBin, } from '@bitauth/libauth';
 import delay from 'delay';
-import { isUnlockableUtxo, } from './interfaces.js';
-import { cashScriptOutputToLibauthOutput, createOpReturnOutput, validateInput, validateOutput, } from './utils.js';
+import { isUnlockableUtxo, isStandardUnlockableUtxo, } from './interfaces.js';
+import { cashScriptOutputToLibauthOutput, createOpReturnOutput, generateLibauthSourceOutputs, validateInput, validateOutput, } from './utils.js';
 import { FailedTransactionError } from './Errors.js';
 import { getBitauthUri } from './LibauthTemplate.js';
 import { debugLibauthTemplate, getLibauthTemplates } from './advanced/LibauthTemplate.js';
+import { getWcContractInfo } from './walletconnect-utils.js';
+import semver from 'semver';
 const DEFAULT_SEQUENCE = 0xfffffffe;
 export class TransactionBuilder {
     constructor(options) {
@@ -76,14 +78,7 @@ export class TransactionBuilder {
             version: 2,
         };
         // Generate source outputs from inputs (for signing with SIGHASH_UTXOS)
-        const sourceOutputs = this.inputs.map((input) => {
-            const sourceOutput = {
-                amount: input.satoshis,
-                to: input.unlocker.generateLockingBytecode(),
-                token: input.token,
-            };
-            return cashScriptOutputToLibauthOutput(sourceOutput);
-        });
+        const sourceOutputs = generateLibauthSourceOutputs(this.inputs);
         const inputScripts = this.inputs.map((input, inputIndex) => (input.unlocker.generateUnlockingBytecode({ transaction, sourceOutputs, inputIndex })));
         inputScripts.forEach((script, i) => {
             transaction.inputs[i].unlockingBytecode = script;
@@ -94,12 +89,21 @@ export class TransactionBuilder {
         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() {
+    debug() {
+        if (this.inputs.some((input) => !isStandardUnlockableUtxo(input))) {
+            throw new Error('Cannot debug a transaction with custom unlocker');
+        }
+        // We can typecast this because we check that all inputs are standard unlockable in the check above
+        const contractVersions = this.inputs
+            .map((input) => 'contract' in input.unlocker ? input.unlocker.contract.artifact.compiler.version : null)
+            .filter((version) => version !== null);
+        if (!contractVersions.every((version) => semver.satisfies(version, '>=0.11.0'))) {
+            console.warn('For the best debugging experience, please recompile your contract with cashc version 0.11.0 or newer.');
+        }
         return debugLibauthTemplate(this.getLibauthTemplate(), this);
     }
     bitauthUri() {
+        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() {
@@ -107,8 +111,11 @@ export class TransactionBuilder {
     }
     async send(raw) {
         const tx = this.build();
-        // Debug the transaction locally before sending so any errors are caught early
-        await this.debug();
+        // If all inputs are standard unlockable, we can debug the transaction locally
+        // before sending so any errors are caught early
+        if (this.inputs.every((input) => isStandardUnlockableUtxo(input))) {
+            this.debug();
+        }
         try {
             const txid = await this.provider.sendRawTransaction(tx);
             return raw ? await this.getTxDetails(txid, raw) : await this.getTxDetails(txid);
@@ -135,5 +142,22 @@ export class TransactionBuilder {
         // Should not happen
         throw new Error('Could not retrieve transaction details for over 10 minutes');
     }
+    generateWcTransactionObject(options) {
+        const inputs = this.inputs;
+        if (!inputs.every(input => isStandardUnlockableUtxo(input))) {
+            throw new Error('All inputs must be StandardUnlockableUtxos to generate the wcSourceOutputs');
+        }
+        const encodedTransaction = this.build();
+        const transaction = decodeTransactionUnsafe(hexToBin(encodedTransaction));
+        const libauthSourceOutputs = generateLibauthSourceOutputs(inputs);
+        const sourceOutputs = libauthSourceOutputs.map((sourceOutput, index) => {
+            return {
+                ...sourceOutput,
+                ...transaction.inputs[index],
+                ...getWcContractInfo(inputs[index]),
+            };
+        });
+        return { ...options, transaction, sourceOutputs };
+    }
 }
 //# sourceMappingURL=TransactionBuilder.js.map

package/dist/advanced/LibauthTemplate.d.ts

@@ -1,9 +1,9 @@
 import { TransactionBch, WalletTemplate, WalletTemplateScenarioBytecode } from '@bitauth/libauth';
-import { AbiFunction, Artifact } from '@cashscript/utils';
+import { AbiFunction } from '@cashscript/utils';
 import { EncodedConstructorArgument, EncodedFunctionArgument } from '../Argument.js';
 import { Contract } from '../Contract.js';
 import { DebugResults } from '../debugging.js';
-import { AddressType, UnlockableUtxo } from '../interfaces.js';
+import { StandardUnlockableUtxo } from '../interfaces.js';
 import SignatureTemplate from '../SignatureTemplate.js';
 import { Transaction } from '../Transaction.js';
 import { TransactionBuilder } from '../TransactionBuilder.js';
@@ -22,7 +22,7 @@ export declare const generateTemplateEntitiesP2PKH: (inputIndex: number) => Wall
  * https://ide.bitauth.com/authentication-template-v0.schema.json
  *
  */
-export declare const generateTemplateEntitiesP2SH: (artifact: Artifact, abiFunction: AbiFunction, encodedFunctionArgs: EncodedFunctionArgument[], inputIndex: number) => WalletTemplate["entities"];
+export declare const generateTemplateEntitiesP2SH: (contract: Contract, abiFunction: AbiFunction, encodedFunctionArgs: EncodedFunctionArgument[], inputIndex: number) => WalletTemplate["entities"];
 /**
  * Generates template scripts for P2PKH (Pay to Public Key Hash) placeholder scripts.
  *
@@ -38,8 +38,8 @@ export declare const generateTemplateScriptsP2PKH: (template: SignatureTemplate,
  * https://ide.bitauth.com/authentication-template-v0.schema.json
  *
  */
-export declare const generateTemplateScriptsP2SH: (artifact: Artifact, addressType: AddressType, abiFunction: AbiFunction, encodedFunctionArgs: EncodedFunctionArgument[], encodedConstructorArgs: EncodedConstructorArgument[], inputIndex: number) => WalletTemplate["scripts"];
+export declare const generateTemplateScriptsP2SH: (contract: Contract, abiFunction: AbiFunction, encodedFunctionArgs: EncodedFunctionArgument[], encodedConstructorArgs: EncodedConstructorArgument[], inputIndex: number) => WalletTemplate["scripts"];
 export declare const generateTemplateScenarios: (contract: Contract, libauthTransaction: TransactionBch, csTransaction: Transaction, abiFunction: AbiFunction, encodedFunctionArgs: EncodedFunctionArgument[], inputIndex: number) => WalletTemplate["scenarios"];
 export declare const getLibauthTemplates: (txn: TransactionBuilder) => WalletTemplate;
 export declare const debugLibauthTemplate: (template: WalletTemplate, transaction: TransactionBuilder) => DebugResults;
-export declare const generateUnlockingScriptParams: (csInput: UnlockableUtxo, p2pkhScriptNameTemplate: string, inputIndex: number) => WalletTemplateScenarioBytecode;
+export declare const generateUnlockingScriptParams: (csInput: StandardUnlockableUtxo, p2pkhScriptNameTemplate: string, inputIndex: number) => WalletTemplateScenarioBytecode;

package/dist/advanced/LibauthTemplate.js

@@ -1,6 +1,7 @@
-import { binToHex, } from '@bitauth/libauth';
+import { binToHex, decodeCashAddress, } from '@bitauth/libauth';
 import { encodeFunctionArguments } from '../Argument.js';
 import { debugTemplate } from '../debugging.js';
+import { isP2PKHUnlocker, isStandardUnlockableUtxo, } from '../interfaces.js';
 import { addHexPrefixExceptEmpty, formatBytecodeForDebugging, formatParametersForDebugging, generateTemplateScenarioBytecode, generateTemplateScenarioKeys, generateTemplateScenarioParametersFunctionIndex, generateTemplateScenarioParametersValues, generateTemplateScenarioTransactionOutputLockingBytecode, getHashTypeName, getSignatureAlgorithmName, serialiseTokenDetails, } from '../LibauthTemplate.js';
 import SignatureTemplate from '../SignatureTemplate.js';
 import { addressToLockScript } from '../utils.js';
@@ -36,21 +37,21 @@ export const generateTemplateEntitiesP2PKH = (inputIndex) => {
  * https://ide.bitauth.com/authentication-template-v0.schema.json
  *
  */
-export const generateTemplateEntitiesP2SH = (artifact, abiFunction, encodedFunctionArgs, inputIndex) => {
+export const generateTemplateEntitiesP2SH = (contract, abiFunction, encodedFunctionArgs, inputIndex) => {
     const entities = {
-        [artifact.contractName + '_input' + inputIndex + '_parameters']: {
+        [contract.artifact.contractName + '_input' + inputIndex + '_parameters']: {
             description: 'Contract creation and function parameters',
-            name: `${artifact.contractName} (input #${inputIndex})`,
+            name: `${contract.artifact.contractName} (input #${inputIndex})`,
             scripts: [
-                artifact.contractName + '_lock',
-                artifact.contractName + '_' + abiFunction.name + '_input' + inputIndex + '_unlock',
+                getLockScriptName(contract),
+                getUnlockScriptName(contract, abiFunction, inputIndex),
             ],
-            variables: createWalletTemplateVariables(artifact, abiFunction, encodedFunctionArgs),
+            variables: createWalletTemplateVariables(contract.artifact, abiFunction, encodedFunctionArgs),
         },
     };
     // function_index is a special variable that indicates the function to execute
-    if (artifact.abi.length > 1) {
-        entities[artifact.contractName + '_input' + inputIndex + '_parameters'].variables.function_index = {
+    if (contract.artifact.abi.length > 1) {
+        entities[contract.artifact.contractName + '_input' + inputIndex + '_parameters'].variables.function_index = {
             description: 'Script function index to execute',
             name: 'function_index',
             type: 'WalletData',
@@ -113,13 +114,13 @@ export const generateTemplateScriptsP2PKH = (template, inputIndex) => {
  * https://ide.bitauth.com/authentication-template-v0.schema.json
  *
  */
-export const generateTemplateScriptsP2SH = (artifact, addressType, abiFunction, encodedFunctionArgs, encodedConstructorArgs, inputIndex) => {
+export const generateTemplateScriptsP2SH = (contract, abiFunction, encodedFunctionArgs, encodedConstructorArgs, inputIndex) => {
     // definition of locking scripts and unlocking scripts with their respective bytecode
-    const unlockingScriptName = artifact.contractName + '_' + abiFunction.name + '_input' + inputIndex + '_unlock';
-    const lockingScriptName = artifact.contractName + '_lock';
+    const unlockingScriptName = getUnlockScriptName(contract, abiFunction, inputIndex);
+    const lockingScriptName = getLockScriptName(contract);
     return {
-        [unlockingScriptName]: generateTemplateUnlockScript(artifact, abiFunction, encodedFunctionArgs, inputIndex),
-        [lockingScriptName]: generateTemplateLockScript(artifact, addressType, encodedConstructorArgs),
+        [unlockingScriptName]: generateTemplateUnlockScript(contract, abiFunction, encodedFunctionArgs, inputIndex),
+        [lockingScriptName]: generateTemplateLockScript(contract, encodedConstructorArgs),
     };
 };
 /**
@@ -129,16 +130,16 @@ export const generateTemplateScriptsP2SH = (artifact, addressType, abiFunction,
  * https://ide.bitauth.com/authentication-template-v0.schema.json
  *
  */
-const generateTemplateLockScript = (artifact, addressType, constructorArguments) => {
+const generateTemplateLockScript = (contract, constructorArguments) => {
     return {
-        lockingType: addressType,
-        name: artifact.contractName,
+        lockingType: contract.addressType,
+        name: contract.artifact.contractName,
         script: [
-            `// "${artifact.contractName}" contract constructor parameters`,
-            formatParametersForDebugging(artifact.constructorInputs, constructorArguments),
+            `// "${contract.artifact.contractName}" contract constructor parameters`,
+            formatParametersForDebugging(contract.artifact.constructorInputs, constructorArguments),
             '',
             '// bytecode',
-            formatBytecodeForDebugging(artifact),
+            formatBytecodeForDebugging(contract.artifact),
         ].join('\n'),
     };
 };
@@ -149,10 +150,10 @@ const generateTemplateLockScript = (artifact, addressType, constructorArguments)
  * https://ide.bitauth.com/authentication-template-v0.schema.json
  *
  */
-const generateTemplateUnlockScript = (artifact, abiFunction, encodedFunctionArgs, inputIndex) => {
-    const scenarioIdentifier = `${artifact.contractName}_${abiFunction.name}_input${inputIndex}_evaluate`;
-    const functionIndex = artifact.abi.findIndex((func) => func.name === abiFunction.name);
-    const functionIndexString = artifact.abi.length > 1
+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 {
@@ -165,7 +166,7 @@ const generateTemplateUnlockScript = (artifact, abiFunction, encodedFunctionArgs
             '',
             ...functionIndexString,
         ].join('\n'),
-        unlocks: artifact.contractName + '_lock',
+        unlocks: getLockScriptName(contract),
     };
 };
 export const generateTemplateScenarios = (contract, libauthTransaction, csTransaction, abiFunction, encodedFunctionArgs, inputIndex) => {
@@ -247,6 +248,9 @@ const createCSTransaction = (txn) => {
     return csTransaction;
 };
 export const getLibauthTemplates = (txn) => {
+    if (txn.inputs.some((input) => !isStandardUnlockableUtxo(input))) {
+        throw new Error('Cannot use debugging functionality with a transaction that contains custom unlockers');
+    }
     const libauthTransaction = txn.buildLibauthTransaction();
     const csTransaction = createCSTransaction(txn);
     const baseTemplate = {
@@ -269,10 +273,11 @@ export const getLibauthTemplates = (txn) => {
     // 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 txn.inputs.entries()) {
         // If template exists on the input, it indicates this is a P2PKH (Pay to Public Key Hash) input
         if ('template' in input.unlocker) {
-            // @ts-ignore TODO: Remove UtxoP2PKH type and only use UnlockableUtxo in Libaith Template generation
+            // @ts-ignore TODO: Remove UtxoP2PKH type and only use UnlockableUtxo in Libauth Template generation
             input.template = input.unlocker?.template; // Added to support P2PKH inputs in buildTemplate
             Object.assign(p2pkhEntities, generateTemplateEntitiesP2PKH(inputIndex));
             Object.assign(p2pkhScripts, generateTemplateScriptsP2PKH(input.unlocker.template, inputIndex));
@@ -290,9 +295,9 @@ export const getLibauthTemplates = (txn) => {
             // Generate a scenario object for this contract input
             Object.assign(scenarios, generateTemplateScenarios(contract, libauthTransaction, csTransaction, abiFunction, encodedArgs, inputIndex));
             // Generate entities for this contract input
-            const entity = generateTemplateEntitiesP2SH(contract.artifact, abiFunction, encodedArgs, inputIndex);
+            const entity = generateTemplateEntitiesP2SH(contract, abiFunction, encodedArgs, inputIndex);
             // Generate scripts for this contract input
-            const script = generateTemplateScriptsP2SH(contract.artifact, contract.addressType, abiFunction, encodedArgs, contract.encodedConstructorArgs, inputIndex);
+            const script = generateTemplateScriptsP2SH(contract, abiFunction, encodedArgs, contract.encodedConstructorArgs, inputIndex);
             // Find the lock script name for this contract input
             const lockScriptName = Object.keys(script).find(scriptName => scriptName.includes('_lock'));
             if (lockScriptName) {
@@ -359,8 +364,8 @@ export const debugLibauthTemplate = (template, transaction) => {
         .map(contract => contract.artifact);
     return debugTemplate(template, allArtifacts);
 };
-const generateLockingScriptParams = (contract, csInput, lockScriptName) => {
-    if (('template' in csInput.unlocker)) {
+const generateLockingScriptParams = (contract, { unlocker }, lockScriptName) => {
+    if (isP2PKHUnlocker(unlocker)) {
         return {
             script: lockScriptName,
         };
@@ -368,8 +373,7 @@ const generateLockingScriptParams = (contract, csInput, lockScriptName) => {
     const constructorParamsEntries = contract.artifact.constructorInputs
         .map(({ name }, index) => [
         name,
-        // TODO: For some reason, typescript forgets that the unlocker is a ContractUnlocker
-        addHexPrefixExceptEmpty(binToHex(csInput.unlocker.contract.encodedConstructorArgs[index])),
+        addHexPrefixExceptEmpty(binToHex(unlocker.contract.encodedConstructorArgs[index])),
     ]);
     const constructorParams = Object.fromEntries(constructorParamsEntries);
     return {
@@ -380,7 +384,7 @@ const generateLockingScriptParams = (contract, csInput, lockScriptName) => {
     };
 };
 export const generateUnlockingScriptParams = (csInput, p2pkhScriptNameTemplate, inputIndex) => {
-    if (('template' in csInput.unlocker)) {
+    if (isP2PKHUnlocker(csInput.unlocker)) {
         return {
             script: `${p2pkhScriptNameTemplate}_${inputIndex}`,
             overrides: {
@@ -396,7 +400,7 @@ export const generateUnlockingScriptParams = (csInput, p2pkhScriptNameTemplate,
     const contract = csInput.unlocker.contract;
     const encodedFunctionArgs = encodeFunctionArguments(abiFunction, csInput.unlocker.params);
     return {
-        script: `${csInput.unlocker.contract.name}_${abiFunction.name}_input${inputIndex}_unlock`,
+        script: getUnlockScriptName(contract, abiFunction, inputIndex),
         overrides: {
             // encode values for the variables defined above in `entities` property
             bytecode: {
@@ -410,4 +414,13 @@ export const generateUnlockingScriptParams = (csInput, p2pkhScriptNameTemplate,
         },
     };
 };
+const getLockScriptName = (contract) => {
+    const result = decodeCashAddress(contract.address);
+    if (typeof result === 'string')
+        throw new Error(result);
+    return `${contract.artifact.contractName}_${binToHex(result.payload)}_lock`;
+};
+const getUnlockScriptName = (contract, abiFunction, inputIndex) => {
+    return `${contract.artifact.contractName}_${abiFunction.name}_input${inputIndex}_unlock`;
+};
 //# sourceMappingURL=LibauthTemplate.js.map

package/dist/debugging.js

@@ -5,6 +5,11 @@ import { FailedRequireError, FailedTransactionError, FailedTransactionEvaluation
 import { getBitauthUri } from './LibauthTemplate.js';
 // 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
+    const hasArtifactNameCollision = artifacts.some((artifact) => (artifacts.some((other) => other.contractName === artifact.contractName && other.bytecode !== artifact.bytecode)));
+    if (hasArtifactNameCollision) {
+        throw new Error('There are multiple artifacts with the same contractName. Please make sure that all artifacts have unique names.');
+    }
     const results = {};
     const unlockingScriptIds = Object.keys(template.scripts).filter((key) => 'unlocks' in template.scripts[key]);
     for (const unlockingScriptId of unlockingScriptIds) {
@@ -173,7 +178,10 @@ const calculateCleanupSize = (instructions) => {
     // OP_NIP (or OP_DROP/OP_2DROP in optimised bytecode) is used for cleanup at the end of a function,
     // OP_ENDIF and OP_ELSE are the end of branches. We need to remove all of these to get to the actual last
     // executed instruction of a function
-    // TODO: What about OP_1??
+    // Note that in the case where we re-add OP_1 because we cannot optimise the final explicit VERIFY into an implicit one
+    // (like when dealing with if-statements, or with CHECKLOCKTIMEVERIFY), it is impossible to run into an implicit final
+    // verify failure. That is why OP_1 does not need to be included in the cleanup opcodes.
+    // TODO: Perhaps we also do not need to add OP_DROP/OP_2DROP either, because they only occur together with OP_1
     const cleanupOpcodes = [Op.OP_ENDIF, Op.OP_NIP, Op.OP_ELSE, Op.OP_DROP, Op.OP_2DROP];
     let cleanupSize = 0;
     for (const instruction of [...instructions].reverse()) {

package/dist/index.d.ts

@@ -9,3 +9,4 @@ export * from './interfaces.js';
 export * from './Errors.js';
 export { type NetworkProvider, BitcoinRpcNetworkProvider, ElectrumNetworkProvider, FullStackNetworkProvider, MockNetworkProvider, } from './network/index.js';
 export { randomUtxo, randomToken, randomNFT } from './utils.js';
+export * from './walletconnect-utils.js';

package/dist/index.js

@@ -8,4 +8,5 @@ export * from './interfaces.js';
 export * from './Errors.js';
 export { BitcoinRpcNetworkProvider, ElectrumNetworkProvider, FullStackNetworkProvider, MockNetworkProvider, } from './network/index.js';
 export { randomUtxo, randomToken, randomNFT } from './utils.js';
+export * from './walletconnect-utils.js';
 //# sourceMappingURL=index.js.map

package/dist/interfaces.d.ts

@@ -14,7 +14,11 @@ export interface UnlockableUtxo extends Utxo {
     unlocker: Unlocker;
     options?: InputOptions;
 }
+export interface StandardUnlockableUtxo extends UnlockableUtxo {
+    unlocker: StandardUnlocker;
+}
 export declare function isUnlockableUtxo(utxo: Utxo): utxo is UnlockableUtxo;
+export declare function isStandardUnlockableUtxo(utxo: UnlockableUtxo): utxo is StandardUnlockableUtxo;
 export interface InputOptions {
     sequence?: number;
 }
@@ -23,19 +27,22 @@ export interface GenerateUnlockingBytecodeOptions {
     sourceOutputs: LibauthOutput[];
     inputIndex: number;
 }
-export interface BaseUnlocker {
+export interface Unlocker {
     generateLockingBytecode: () => Uint8Array;
     generateUnlockingBytecode: (options: GenerateUnlockingBytecodeOptions) => Uint8Array;
 }
-export interface ContractUnlocker extends BaseUnlocker {
+export interface ContractUnlocker extends Unlocker {
     contract: Contract;
     params: FunctionArgument[];
     abiFunction: AbiFunction;
 }
-export interface P2PKHUnlocker extends BaseUnlocker {
+export interface P2PKHUnlocker extends Unlocker {
     template: SignatureTemplate;
 }
-export type Unlocker = ContractUnlocker | P2PKHUnlocker;
+export type StandardUnlocker = ContractUnlocker | P2PKHUnlocker;
+export declare function isContractUnlocker(unlocker: Unlocker): unlocker is ContractUnlocker;
+export declare function isP2PKHUnlocker(unlocker: Unlocker): unlocker is P2PKHUnlocker;
+export declare function isStandardUnlocker(unlocker: Unlocker): unlocker is StandardUnlocker;
 export interface UtxoP2PKH extends Utxo {
     template: SignatureTemplate;
 }

package/dist/interfaces.js

@@ -1,6 +1,18 @@
 export function isUnlockableUtxo(utxo) {
     return 'unlocker' in utxo;
 }
+export function isStandardUnlockableUtxo(utxo) {
+    return isStandardUnlocker(utxo.unlocker);
+}
+export function isContractUnlocker(unlocker) {
+    return 'contract' in unlocker;
+}
+export function isP2PKHUnlocker(unlocker) {
+    return 'template' in unlocker;
+}
+export function isStandardUnlocker(unlocker) {
+    return isContractUnlocker(unlocker) || isP2PKHUnlocker(unlocker);
+}
 export function isUtxoP2PKH(utxo) {
     return 'template' in utxo;
 }

package/dist/network/MockNetworkProvider.d.ts

@@ -4,8 +4,10 @@ export default class MockNetworkProvider implements NetworkProvider {
     private utxoMap;
     private transactionMap;
     network: Network;
+    blockHeight: number;
     constructor();
     getUtxos(address: string): Promise<Utxo[]>;
+    setBlockHeight(newBlockHeight: number): void;
     getBlockHeight(): Promise<number>;
     getRawTransaction(txid: string): Promise<string>;
     sendRawTransaction(txHex: string): Promise<string>;

package/dist/network/MockNetworkProvider.js

@@ -11,6 +11,7 @@ export default class MockNetworkProvider {
         this.utxoMap = {};
         this.transactionMap = {};
         this.network = Network.MOCKNET;
+        this.blockHeight = 133700;
         for (let i = 0; i < 3; i += 1) {
             this.addUtxo(aliceAddress, randomUtxo());
             this.addUtxo(bobAddress, randomUtxo());
@@ -21,8 +22,11 @@ export default class MockNetworkProvider {
         const lockingBytecode = binToHex(addressToLockScript(address));
         return this.utxoMap[lockingBytecode] ?? [];
     }
+    setBlockHeight(newBlockHeight) {
+        this.blockHeight = newBlockHeight;
+    }
     async getBlockHeight() {
-        return 133700;
+        return this.blockHeight;
     }
     async getRawTransaction(txid) {
         return this.transactionMap[txid];

package/dist/test/JestExtensions.js

@@ -1,14 +1,17 @@
 expect.extend({
-    async toLog(transaction, match) {
+    toLog(transaction, match) {
         const loggerSpy = jest.spyOn(console, 'log');
         // Clear any previous calls (if spy reused accidentally)
         loggerSpy.mockClear();
         // silence actual stdout output
         loggerSpy.mockImplementation(() => { });
         try {
-            await transaction.debug();
+            executeDebug(transaction);
+        }
+        catch (error) {
+            if (error instanceof OldTransactionBuilderError)
+                throw error;
         }
-        catch { }
         // We concatenate all the logs into a single string - if no logs are present, we set received to undefined
         const receivedBase = loggerSpy.mock.calls.reduce((acc, [log]) => `${acc}\n${log}`, '').trim();
         const received = receivedBase === '' ? undefined : receivedBase;
@@ -17,25 +20,37 @@ expect.extend({
         const receivedText = `Received: ${this.utils.printReceived(received)}`;
         const message = () => `${matcherHint}\n\n${expectedText}\n${receivedText}`;
         try {
-            expect(loggerSpy).toBeCalledWith(match ? expect.stringMatching(match) : expect.anything());
+            // We first check if the expected string is present in any of the individual console.log calls
+            expect(loggerSpy).toHaveBeenCalledWith(match ? expect.stringMatching(match) : expect.anything());
         }
-        catch (e) {
-            return { message, pass: false };
+        catch {
+            try {
+                // We add this extra check to allow expect().toLog() to check multiple console.log calls in a single test
+                // (e.g. for log ordering), which would fail the first check because that compares the individual console.log calls
+                expect(receivedBase).toMatch(match ? match : expect.anything());
+            }
+            catch {
+                return { message, pass: false };
+            }
+        }
+        finally {
+            // Restore the original console.log implementation
+            loggerSpy.mockRestore();
         }
-        // Restore the original console.log implementation
-        loggerSpy.mockRestore();
         return { message, pass: true };
     },
 });
 expect.extend({
-    async toFailRequireWith(transaction, match) {
+    toFailRequireWith(transaction, match) {
         try {
-            await transaction.debug();
+            executeDebug(transaction);
             const matcherHint = this.utils.matcherHint('.toFailRequireWith', undefined, match.toString(), { isNot: this.isNot });
             const message = () => `${matcherHint}\n\nContract function did not fail a require statement.`;
             return { message, pass: false };
         }
         catch (transactionError) {
+            if (transactionError instanceof OldTransactionBuilderError)
+                throw transactionError;
             const matcherHint = this.utils.matcherHint('toFailRequireWith', 'received', 'expected', { isNot: this.isNot });
             const expectedText = `Expected pattern: ${this.isNot ? 'not ' : ''}${this.utils.printExpected(match)}`;
             const receivedText = `Received string: ${this.utils.printReceived(transactionError?.message ?? '')}`;
@@ -49,18 +64,35 @@ expect.extend({
             }
         }
     },
-    async toFailRequire(transaction) {
+    toFailRequire(transaction) {
         try {
-            await transaction.debug();
+            executeDebug(transaction);
             const message = () => 'Contract function did not fail a require statement.';
             return { message, pass: false };
         }
         catch (transactionError) {
+            if (transactionError instanceof OldTransactionBuilderError)
+                throw transactionError;
             const receivedText = `Received string: ${this.utils.printReceived(transactionError?.message ?? '')}`;
             const message = () => `Contract function failed a require statement.\n${receivedText}`;
             return { message, pass: true };
         }
     },
 });
+// Wrapper function with custom error in case people use it with the old transaction builder
+// This is a temporary solution until we fully remove the old transaction builder from the SDK
+const executeDebug = (transaction) => {
+    const debugResults = transaction.debug();
+    if (debugResults instanceof Promise) {
+        debugResults.catch(() => { });
+        throw new OldTransactionBuilderError();
+    }
+};
+class OldTransactionBuilderError extends Error {
+    constructor() {
+        super('The CashScript JestExtensions do not support the old transaction builder since v0.11.0. Please use the new TransactionBuilder class.');
+        this.name = 'OldTransactionBuilderError';
+    }
+}
 export {};
 //# sourceMappingURL=JestExtensions.js.map

package/dist/utils.d.ts

@@ -1,6 +1,6 @@
 import { Transaction } from '@bitauth/libauth';
 import { Script } from '@cashscript/utils';
-import { Utxo, Output, LibauthOutput, TokenDetails, AddressType } from './interfaces.js';
+import { Utxo, Output, LibauthOutput, TokenDetails, AddressType, UnlockableUtxo } from './interfaces.js';
 export declare function validateInput(utxo: Utxo): void;
 export declare function validateOutput(output: Output): void;
 export declare function calculateDust(output: Output): number;
@@ -8,6 +8,7 @@ export declare function getOutputSize(output: Output): number;
 export declare function encodeOutput(output: Output): Uint8Array;
 export declare function cashScriptOutputToLibauthOutput(output: Output): LibauthOutput;
 export declare function libauthOutputToCashScriptOutput(output: LibauthOutput): Output;
+export declare function generateLibauthSourceOutputs(inputs: UnlockableUtxo[]): LibauthOutput[];
 export declare function getInputSize(inputScript: Uint8Array): number;
 export declare function getTxSizeWithoutInputs(outputs: Output[]): number;
 export declare function createInputScript(redeemScript: Script, encodedArgs: Uint8Array[], selector?: number): Uint8Array;

package/dist/utils.js

@@ -74,6 +74,17 @@ export function libauthOutputToCashScriptOutput(output) {
         },
     };
 }
+export function generateLibauthSourceOutputs(inputs) {
+    const sourceOutputs = inputs.map((input) => {
+        const sourceOutput = {
+            amount: input.satoshis,
+            to: input.unlocker.generateLockingBytecode(),
+            token: input.token,
+        };
+        return cashScriptOutputToLibauthOutput(sourceOutput);
+    });
+    return sourceOutputs;
+}
 function isTokenAddress(address) {
     const result = decodeCashAddress(address);
     if (typeof result === 'string')

package/dist/walletconnect-utils.d.ts

@@ -0,0 +1,25 @@
+import type { StandardUnlockableUtxo, LibauthOutput, Unlocker } from './interfaces.js';
+import { type AbiFunction, type Artifact } from '@cashscript/utils';
+import { type Input, type TransactionCommon } from '@bitauth/libauth';
+export interface WcTransactionOptions {
+    broadcast?: boolean;
+    userPrompt?: string;
+}
+export interface WcTransactionObject {
+    transaction: TransactionCommon | string;
+    sourceOutputs: WcSourceOutput[];
+    broadcast?: boolean;
+    userPrompt?: string;
+}
+export type WcSourceOutput = Input & LibauthOutput & WcContractInfo;
+export interface WcContractInfo {
+    contract?: {
+        abiFunction: AbiFunction;
+        redeemScript: Uint8Array;
+        artifact: Partial<Artifact>;
+    };
+}
+export declare function getWcContractInfo(input: StandardUnlockableUtxo): WcContractInfo | {};
+export declare const placeholderSignature: () => Uint8Array;
+export declare const placeholderPublicKey: () => Uint8Array;
+export declare const placeholderP2PKHUnlocker: (userAddress: string) => Unlocker;

package/dist/walletconnect-utils.js

@@ -0,0 +1,35 @@
+import { scriptToBytecode } from '@cashscript/utils';
+import { cashAddressToLockingBytecode } from '@bitauth/libauth';
+export function getWcContractInfo(input) {
+    // If the input does not have a contract unlocker, return an empty object
+    if (!('contract' in input.unlocker))
+        return {};
+    const contract = input.unlocker.contract;
+    const abiFunctionName = input.unlocker.abiFunction?.name;
+    const abiFunction = contract.artifact.abi.find(abi => abi.name === abiFunctionName);
+    if (!abiFunction) {
+        throw new Error(`ABI function ${abiFunctionName} not found in contract artifact`);
+    }
+    const wcContractObj = {
+        contract: {
+            abiFunction: abiFunction,
+            redeemScript: scriptToBytecode(contract.redeemScript),
+            artifact: contract.artifact,
+        },
+    };
+    return wcContractObj;
+}
+export const placeholderSignature = () => Uint8Array.from(Array(65));
+export const placeholderPublicKey = () => Uint8Array.from(Array(33));
+export const placeholderP2PKHUnlocker = (userAddress) => {
+    const decodeAddressResult = cashAddressToLockingBytecode(userAddress);
+    if (typeof decodeAddressResult === 'string') {
+        throw new Error(`Invalid address: ${decodeAddressResult}`);
+    }
+    const lockingBytecode = decodeAddressResult.bytecode;
+    return {
+        generateLockingBytecode: () => lockingBytecode,
+        generateUnlockingBytecode: () => Uint8Array.from(Array(0)),
+    };
+};
+//# sourceMappingURL=walletconnect-utils.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cashscript",
-  "version": "0.11.0-next.4",
+  "version": "0.11.1",
   "description": "Easily write and interact with Bitcoin Cash contracts",
   "keywords": [
     "bitcoin cash",
@@ -46,7 +46,7 @@
   },
   "dependencies": {
     "@bitauth/libauth": "^3.1.0-next.2",
-    "@cashscript/utils": "^0.11.0-next.4",
+    "@cashscript/utils": "^0.11.1",
     "@electrum-cash/network": "^4.1.1",
     "@mr-zwets/bchn-api-wrapper": "^1.0.1",
     "delay": "^6.0.0",
@@ -63,5 +63,5 @@
     "jest": "^29.7.0",
     "typescript": "^5.7.3"
   },
-  "gitHead": "68cdf30db455e3eef448a4feacfff0f5f26a36a7"
+  "gitHead": "ecd880401ed92fa7740ccd23d405f10b2fb61a29"
 }