cashscript 0.13.0-next.1 → 0.13.0-next.2

package/dist/libauth-template/LibauthTemplate.js

@@ -4,9 +4,9 @@ import { debugTemplate } from '../debugging.js';
 import { isContractUnlocker, isP2PKHUnlocker, isStandardUnlockableUtxo, isUnlockableUtxo, } from '../interfaces.js';
 import SignatureTemplate from '../SignatureTemplate.js';
 import { addressToLockScript, extendedStringify, zip } from '../utils.js';
-import { deflate } from 'pako';
+import { zlibSync } from 'fflate';
 import MockNetworkProvider from '../network/MockNetworkProvider.js';
-import { addHexPrefixExceptEmpty, DEFAULT_VM_TARGET, formatBytecodeForDebugging, formatParametersForDebugging, getLockScriptName, getSignatureAndPubkeyFromP2PKHInput, getUnlockScriptName, lockingBytecodeIsSetToSlot, serialiseTokenDetails } from './utils.js';
+import { addHexPrefixExceptEmpty, DEFAULT_VM_TARGET, formatBytecodeForDebugging, formatParametersForDebugging, getLockScriptName, getSignatureAndPubkeyFromP2PKHInput, getUnlockScriptName, serialiseTokenDetails } from './utils.js';
 // TODO: Add / improve descriptions throughout the template generation
 export const getLibauthTemplate = (transactionBuilder) => {
     if (transactionBuilder.inputs.some((input) => !isStandardUnlockableUtxo(input))) {
@@ -26,61 +26,6 @@ export const getLibauthTemplate = (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) => {
@@ -92,7 +37,7 @@ export const debugLibauthTemplate = (template, transaction) => {
 };
 export const getBitauthUri = (template) => {
     const base64toBase64Url = (base64) => base64.replace(/\+/g, '-').replace(/\//g, '_');
-    const payload = base64toBase64Url(binToBase64(deflate(utf8ToBin(extendedStringify(template)))));
+    const payload = base64toBase64Url(binToBase64(zlibSync(utf8ToBin(extendedStringify(template)))));
     return `https://ide.bitauth.com/import-template/${payload}`;
 };
 const generateAllTemplateEntities = (transactionBuilder) => {
@@ -121,6 +66,20 @@ const generateAllTemplateScripts = (transactionBuilder) => {
     });
     return scripts.reduce((acc, script) => ({ ...acc, ...script }), {});
 };
+const generateLockingBytecodeParamsMapping = (transactionBuilder) => {
+    // Initialize bytecode mapping, this will be used to map the locking bytecode to the locking bytecode params
+    const mapping = {};
+    // We can typecast this because we check that all inputs are standard unlockable at the top of this function
+    for (const input of transactionBuilder.inputs) {
+        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;
+        }
+    }
+    return mapping;
+};
 const generateAllTemplateScenarios = (libauthTransaction, transactionBuilder) => {
     const scenarios = transactionBuilder.inputs.map((input, inputIndex) => {
         if (isP2PKHUnlocker(input.unlocker)) {
@@ -299,6 +258,7 @@ const generateTemplateScenariosP2PKH = (libauthTransaction, transactionBuilder,
     return scenarios;
 };
 const generateTemplateScenarioTransaction = (contract, libauthTransaction, transactionBuilder, slotIndex) => {
+    const lockingBytecodeParamsMapping = generateLockingBytecodeParamsMapping(transactionBuilder);
     const zippedInputs = zip(transactionBuilder.inputs, libauthTransaction.inputs);
     const inputs = zippedInputs.map(([csInput, libauthInput], inputIndex) => {
         return {
@@ -311,15 +271,8 @@ const generateTemplateScenarioTransaction = (contract, libauthTransaction, trans
     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)}`,
+            lockingBytecode: generateTemplateScenarioTransactionOutputLockingBytecode(csOutput, libauthOutput, contract, lockingBytecodeParamsMapping),
             token: serialiseTokenDetails(libauthOutput.token),
             valueSatoshis: Number(libauthOutput.valueSatoshis),
         };
@@ -331,7 +284,7 @@ const generateTemplateScenarioSourceOutputs = (transactionBuilder, libauthTransa
     const zippedInputs = zip(transactionBuilder.inputs, libauthTransaction.inputs);
     return zippedInputs.map(([csInput, libauthInput], inputIndex) => {
         return {
-            lockingBytecode: generateTemplateScenarioBytecode(csInput, libauthInput, inputIndex, 'p2pkh_placeholder_lock', inputIndex === slotIndex),
+            lockingBytecode: generateTemplateScenarioBytecodeForSourceOutputs(csInput, libauthInput, inputIndex, 'p2pkh_placeholder_lock', inputIndex === slotIndex),
             valueSatoshis: Number(csInput.satoshis),
             token: serialiseTokenDetails(csInput.token),
         };
@@ -417,10 +370,32 @@ const generateTemplateScenarioBytecode = (input, libauthInput, inputIndex, p2pkh
     // {} means that it is the same script type, but not being evaluated
     return {};
 };
-const generateTemplateScenarioTransactionOutputLockingBytecode = (csOutput, contract) => {
+const generateTemplateScenarioBytecodeForSourceOutputs = (input, libauthInput, inputIndex, p2pkhScriptNameTemplate, insertSlot) => {
+    if (insertSlot)
+        return ['slot'];
+    if (isUnlockableUtxo(input) && isStandardUnlockableUtxo(input)) {
+        // If the input is a contract unlocker, we need to generate the locking bytecode params for the source outputs
+        if (isContractUnlocker(input.unlocker)) {
+            const lockScriptName = getLockScriptName(input.unlocker.contract);
+            const lockingBytecodeParams = generateLockingScriptParams(input.unlocker.contract, input, lockScriptName);
+            return lockingBytecodeParams;
+        }
+        // For a P2PKH unlocker, the sourceOutputs "locking bytecode params" are the same as the unlocking bytecode params
+        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, libauthOutput, contract, lockingBytecodeParamsMapping) => {
+    // If lockingBytecodeParams is known from the mapping, return it
+    const lockingBytecode = binToHex(libauthOutput.lockingBytecode);
+    const lockingBytecodeParams = lockingBytecodeParamsMapping[lockingBytecode];
+    if (lockingBytecodeParams)
+        return lockingBytecodeParams;
     if (csOutput.to instanceof Uint8Array)
         return binToHex(csOutput.to);
-    if ([contract.address, contract.tokenAddress].includes(csOutput.to))
+    if (contract && [contract.address, contract.tokenAddress].includes(csOutput.to))
         return {};
     return binToHex(addressToLockScript(csOutput.to));
 };

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

@@ -1,6 +1,6 @@
 import { AbiFunction, AbiInput, Artifact } from '@cashscript/utils';
 import { HashType, LibauthTokenDetails, SignatureAlgorithm, TokenDetails } from '../interfaces.js';
-import { type WalletTemplateScenarioBytecode, Input } from '@bitauth/libauth';
+import { Input } from '@bitauth/libauth';
 import { EncodedFunctionArgument } from '../Argument.js';
 import { Contract } from '../Contract.js';
 export declare const DEFAULT_VM_TARGET: "BCH_2026_05";
@@ -20,7 +20,6 @@ interface LibauthTemplateTokenDetails {
         commitment: string;
     };
 }
-export declare const lockingBytecodeIsSetToSlot: (lockingBytecode?: WalletTemplateScenarioBytecode | ["slot"]) => boolean;
 export declare const getSignatureAndPubkeyFromP2PKHInput: (libauthInput: Input) => {
     signature: Uint8Array;
     publicKey: Uint8Array;

package/dist/libauth-template/utils.js

@@ -78,9 +78,6 @@ export const serialiseTokenDetails = (token) => {
         } : 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;

package/dist/test/{JestExtensions.js → TestExtensions.js}

@@ -1,6 +1,8 @@
+const testFramework = globalThis.vi ?? globalThis.jest;
+// Extend Vitest with the custom matchers, this file needs to be imported in the vitest.setup.ts file or the test file
 expect.extend({
     toLog(transaction, match) {
-        const loggerSpy = jest.spyOn(console, 'log');
+        const loggerSpy = testFramework.spyOn(console, 'log');
         // Clear any previous calls (if spy reused accidentally)
         loggerSpy.mockClear();
         // silence actual stdout output
@@ -37,8 +39,18 @@ expect.extend({
         }
         return { message, pass: true };
     },
-});
-expect.extend({
+    toFailRequire(transaction) {
+        try {
+            transaction.debug();
+            const message = () => 'Contract function did not fail a require statement.';
+            return { message, pass: false };
+        }
+        catch (transactionError) {
+            const receivedText = `Received string: ${this.utils.printReceived(transactionError?.message ?? '')}`;
+            const message = () => `Contract function failed a require statement.\n${receivedText}`;
+            return { message, pass: true };
+        }
+    },
     toFailRequireWith(transaction, match) {
         try {
             transaction.debug();
@@ -60,18 +72,6 @@ expect.extend({
             }
         }
     },
-    toFailRequire(transaction) {
-        try {
-            transaction.debug();
-            const message = () => 'Contract function did not fail a require statement.';
-            return { message, pass: false };
-        }
-        catch (transactionError) {
-            const receivedText = `Received string: ${this.utils.printReceived(transactionError?.message ?? '')}`;
-            const message = () => `Contract function failed a require statement.\n${receivedText}`;
-            return { message, pass: true };
-        }
-    },
 });
 export {};
-//# sourceMappingURL=JestExtensions.js.map
+//# sourceMappingURL=TestExtensions.js.map

package/jest/package.json

@@ -1,5 +1,5 @@
 {
   "type": "module",
-  "types": "../dist/test/JestExtensions.d.ts",
-  "main": "../dist/test/JestExtensions.js"
+  "types": "../dist/test/TestExtensions.d.ts",
+  "main": "../dist/test/TestExtensions.js"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cashscript",
-  "version": "0.13.0-next.1",
+  "version": "0.13.0-next.2",
   "description": "Easily write and interact with Bitcoin Cash contracts",
   "keywords": [
     "bitcoin cash",
@@ -33,33 +33,28 @@
   },
   "scripts": {
     "build": "yarn clean && yarn compile",
-    "build:test": "yarn clean:test && yarn compile:test",
     "clean": "rm -rf ./dist",
-    "clean:test": "rm -rf ./dist-test",
     "compile": "tsc -p tsconfig.build.json",
-    "compile:test": "tsc -p tsconfig.test.json",
     "lint": "eslint . --ext .ts --ignore-path ../../.eslintignore",
     "prepare": "yarn build",
     "prepublishOnly": "yarn test && yarn lint",
-    "pretest": "yarn build:test",
-    "test": "NODE_OPTIONS='--experimental-vm-modules --no-warnings' jest"
+    "test": "vitest run"
   },
   "dependencies": {
     "@bitauth/libauth": "^3.1.0-next.8",
-    "@cashscript/utils": "^0.13.0-next.1",
+    "@cashscript/utils": "^0.13.0-next.2",
     "@electrum-cash/network": "^4.1.3",
     "@mr-zwets/bchn-api-wrapper": "^1.0.1",
-    "pako": "^2.1.0",
+    "fflate": "^0.8.2",
     "semver": "^7.7.2"
   },
   "devDependencies": {
-    "@jest/globals": "^29.7.0",
     "@psf/bch-js": "^6.8.0",
-    "@types/pako": "^2.0.3",
     "@types/semver": "^7.5.8",
+    "@vitest/coverage-v8": "^4.0.15",
     "eslint": "^8.54.0",
-    "jest": "^29.7.0",
-    "typescript": "^5.9.2"
+    "typescript": "^5.9.2",
+    "vitest": "^4.0.15"
   },
-  "gitHead": "f3d3fd75400c93f4457276b56ce094b11c0986d7"
+  "gitHead": "817391f108ce46c826dbab6f11ee4f1bb269c27f"
 }

package/vitest/package.json

@@ -0,0 +1,5 @@
+{
+  "type": "module",
+  "types": "../dist/test/TestExtensions.d.ts",
+  "main": "../dist/test/TestExtensions.js"
+}

package/dist/test/{JestExtensions.d.ts → TestExtensions.d.ts}

@@ -1,4 +1,3 @@
-export {};
 declare global {
     namespace jest {
         interface Matchers<R> {
@@ -8,3 +7,4 @@ declare global {
         }
     }
 }
+export {};