cashscript 0.13.0-next.8 → 0.13.0

package/dist/Contract.js

@@ -92,10 +92,10 @@ class ContractInternal extends ContractBase {
             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}`);
             }
-            const bytecode = hexToBin(this.bytecode);
             const encodedArgs = args
                 .map((arg, i) => encodeFunctionArgument(arg, abiFunction.inputs[i].type));
             const generateUnlockingBytecode = ({ transaction, sourceOutputs, inputIndex }) => {
+                const bytecode = hexToBin(this.bytecode);
                 const completeArgs = encodedArgs.map((arg) => {
                     if (!(arg instanceof SignatureTemplate))
                         return arg;
@@ -104,10 +104,10 @@ class ContractInternal extends ContractBase {
                     const sighash = hash256(preimage);
                     return arg.generateSignature(sighash);
                 });
-                const unlockingBytecode = createUnlockingBytecode(this.contractType, hexToBin(this.bytecode), completeArgs, selector);
+                const unlockingBytecode = createUnlockingBytecode(this.contractType, bytecode, completeArgs, selector);
                 return unlockingBytecode;
             };
-            const generateLockingBytecode = () => addressToLockScript(this.address);
+            const generateLockingBytecode = () => hexToBin(this.lockingBytecode);
             return { generateUnlockingBytecode, generateLockingBytecode, contract: this, params: args, abiFunction };
         };
     }

package/dist/Errors.js

@@ -82,7 +82,10 @@ export class FailedRequireError extends FailedTransactionError {
         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}`;
+        const headline = `${requireStatement.message ? baseMessageWithRequireMessage : baseMessage}.`;
+        // Compiler-injected guards (e.g. the tx.locktime guard) have no user-written source, so the
+        // extracted statement is empty — the require message fully describes the failure on its own.
+        const fullMessage = statement.trim() ? `${headline}\nFailing statement: ${statement}` : headline;
         super(fullMessage, bitauthUri);
         this.artifact = artifact;
         this.failingInstructionPointer = failingInstructionPointer;

package/dist/TransactionBuilder.js

@@ -360,14 +360,15 @@ export class TransactionBuilder {
         }
         catch (e) {
             const reason = e.error ?? e.message;
-            try {
-                const bitauthUri = getBitauthUri(this.getLibauthTemplate());
-                throw new FailedTransactionError(reason, bitauthUri);
-            }
-            catch {
-                // Preserve the original broadcast failure reason if URI generation fails
-                throw new FailedTransactionError(reason, 'Bitauth URI generation failed');
-            }
+            const getBitauthUriWithFallback = () => {
+                try {
+                    return getBitauthUri(this.getLibauthTemplate());
+                }
+                catch {
+                    return 'Bitauth URI generation failed';
+                }
+            };
+            throw new FailedTransactionError(reason, getBitauthUriWithFallback());
         }
     }
     async getTxDetails(txid, raw) {

package/dist/libauth-template/LibauthTemplate.js

@@ -73,8 +73,7 @@ const generateLockingBytecodeParamsMapping = (transactionBuilder) => {
         if (isContractUnlocker(input.unlocker)) {
             const lockScriptName = getLockScriptName(input.unlocker.contract);
             const lockingScriptParams = generateLockingScriptParams(input.unlocker.contract, input, lockScriptName);
-            const lockingBytecode = binToHex(addressToLockScript(input.unlocker.contract.address));
-            mapping[lockingBytecode] = lockingScriptParams;
+            mapping[input.unlocker.contract.lockingBytecode] = lockingScriptParams;
         }
     }
     return mapping;
@@ -394,7 +393,7 @@ const generateTemplateScenarioTransactionOutputLockingBytecode = (csOutput, liba
         return lockingBytecodeParams;
     if (csOutput.to instanceof Uint8Array)
         return binToHex(csOutput.to);
-    if (contract && [contract.address, contract.tokenAddress].includes(csOutput.to))
+    if (contract && contract.contractType !== 'p2s' && [contract.address, contract.tokenAddress].includes(csOutput.to))
         return {};
     return binToHex(addressToLockScript(csOutput.to));
 };

package/dist/libauth-template/utils.js

@@ -1,10 +1,13 @@
-import { bytecodeToScript, formatBitAuthScript } from '@cashscript/utils';
+import { bytecodeToScript, formatBitAuthScript, sha256 } from '@cashscript/utils';
 import { HashType, SignatureAlgorithm, VmTarget } from '../interfaces.js';
 import { hexToBin, binToHex, isHex, decodeCashAddress, assertSuccess, decodeAuthenticationInstructions } from '@bitauth/libauth';
 import { zip } from '../utils.js';
 import SignatureTemplate from '../SignatureTemplate.js';
 export const DEFAULT_VM_TARGET = VmTarget.BCH_2026_05;
 export const getLockScriptName = (contract) => {
+    if (contract.contractType === 'p2s') {
+        return `${contract.artifact.contractName}_${binToHex(sha256(hexToBin(contract.lockingBytecode)))}_lock`;
+    }
     const result = decodeCashAddress(contract.address);
     if (typeof result === 'string')
         throw new Error(result);

package/dist/network/MockNetworkProvider.d.ts

@@ -56,3 +56,6 @@ export default class MockNetworkProvider implements NetworkProvider {
      */
     reset(): void;
 }
+export declare class FailingMockNetworkProvider extends MockNetworkProvider {
+    sendRawTransaction(_txHex: string): Promise<string>;
+}

package/dist/network/MockNetworkProvider.js

@@ -98,4 +98,9 @@ export default class MockNetworkProvider {
         this.transactionMap = {};
     }
 }
+export class FailingMockNetworkProvider extends MockNetworkProvider {
+    async sendRawTransaction(_txHex) {
+        throw new Error('broadcast failed');
+    }
+}
 //# sourceMappingURL=MockNetworkProvider.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cashscript",
-  "version": "0.13.0-next.8",
+  "version": "0.13.0",
   "description": "Easily write and interact with Bitcoin Cash contracts",
   "keywords": [
     "bitcoin cash",
@@ -42,7 +42,7 @@
   },
   "dependencies": {
     "@bitauth/libauth": "^3.1.0-next.8",
-    "@cashscript/utils": "^0.13.0-next.8",
+    "@cashscript/utils": "^0.13.0",
     "@electrum-cash/network": "^4.1.3",
     "fflate": "^0.8.2",
     "semver": "^7.7.2"
@@ -56,5 +56,5 @@
     "typescript": "^5.9.2",
     "vitest": "^4.0.15"
   },
-  "gitHead": "579998062f2f9c52393568b09b580407228cb79f"
+  "gitHead": "a3461662016a2f3dad36431ba5a2b148bcc4dc75"
 }