@cashscript/utils 0.11.0-next.2 → 0.11.0-next.4

package/dist/artifact.d.ts

@@ -1,4 +1,3 @@
-import { PathLike } from 'fs';
 export interface AbiInput {
     name: string;
     type: string;
@@ -22,6 +21,7 @@ export interface StackItem {
     type: string;
     stackIndex: number;
     ip: number;
+    transformations?: string;
 }
 export type LogData = StackItem | string;
 export interface RequireStatement {
@@ -42,6 +42,4 @@ export interface Artifact {
     };
     updatedAt: string;
 }
-export declare function importArtifact(artifactFile: PathLike): Artifact;
-export declare function exportArtifact(artifact: Artifact, targetFile: string, format: 'json' | 'ts'): void;
 export declare function formatArtifact(artifact: Artifact, format: 'json' | 'ts'): string;

package/dist/artifact.js

@@ -1,11 +1,3 @@
-import fs from 'fs';
-export function importArtifact(artifactFile) {
-    return JSON.parse(fs.readFileSync(artifactFile, { encoding: 'utf-8' }));
-}
-export function exportArtifact(artifact, targetFile, format) {
-    const jsonString = formatArtifact(artifact, format);
-    fs.writeFileSync(targetFile, jsonString);
-}
 export function formatArtifact(artifact, format) {
     if (format === 'ts') {
         // We remove any undefined values to make the artifact serializable using stringifyAsTs

package/dist/optimisations.d.ts

@@ -0,0 +1 @@
+export declare const optimisationReplacements: [string, string][];

package/dist/optimisations.js

@@ -0,0 +1,124 @@
+const provableOptimisations = [
+    // Hardcoded arithmetic
+    ['OP_1 OP_ADD', 'OP_1ADD'],
+    ['OP_1 OP_SUB', 'OP_1SUB'],
+    ['OP_1 OP_NEGATE', 'OP_1NEGATE'],
+    ['OP_0 OP_NUMEQUAL OP_NOT', 'OP_0NOTEQUAL'],
+    ['OP_NUMEQUAL OP_NOT', 'OP_NUMNOTEQUAL'],
+    ['OP_SHA256 OP_SHA256', 'OP_HASH256'],
+    ['OP_SHA256 OP_RIPEMD160', 'OP_HASH160'],
+    // Hardcoded stack ops
+    ['OP_2 OP_PICK OP_1 OP_PICK OP_3 OP_PICK', 'OP_3DUP OP_SWAP'],
+    ['OP_2 OP_PICK OP_2 OP_PICK OP_2 OP_PICK', 'OP_3DUP'],
+    ['OP_0 OP_PICK OP_2 OP_PICK', 'OP_2DUP OP_SWAP'],
+    ['OP_2 OP_PICK OP_4 OP_PICK', 'OP_2OVER OP_SWAP'],
+    ['OP_3 OP_PICK OP_3 OP_PICK', 'OP_2OVER'],
+    ['OP_2 OP_ROLL OP_3 OP_ROLL', 'OP_2SWAP OP_SWAP'],
+    ['OP_3 OP_ROLL OP_3 OP_ROLL', 'OP_2SWAP'],
+    ['OP_4 OP_ROLL OP_5 OP_ROLL', 'OP_2ROT OP_SWAP'],
+    ['OP_5 OP_ROLL OP_5 OP_ROLL', 'OP_2ROT'],
+    ['OP_0 OP_PICK', 'OP_DUP'],
+    ['OP_1 OP_PICK', 'OP_OVER'],
+    ['OP_0 OP_ROLL', ''],
+    ['OP_1 OP_ROLL', 'OP_SWAP'],
+    ['OP_2 OP_ROLL', 'OP_ROT'],
+    ['OP_DROP OP_DROP', 'OP_2DROP'],
+    // Secondary effects
+    ['OP_DUP OP_SWAP', 'OP_DUP'],
+    ['OP_SWAP OP_SWAP', ''],
+    ['OP_2SWAP OP_2SWAP', ''],
+    ['OP_ROT OP_ROT OP_ROT', ''],
+    ['OP_2ROT OP_2ROT OP_2ROT', ''],
+    ['OP_OVER OP_OVER', 'OP_2DUP'],
+    ['OP_DUP OP_DROP', ''],
+    ['OP_DUP OP_NIP', ''],
+    // Enabling secondary effects
+    ['OP_DUP OP_OVER', 'OP_DUP OP_DUP'],
+    // Merge OP_VERIFY
+    ['OP_EQUAL OP_VERIFY', 'OP_EQUALVERIFY'],
+    ['OP_NUMEQUAL OP_VERIFY', 'OP_NUMEQUALVERIFY'],
+    ['OP_CHECKSIG OP_VERIFY', 'OP_CHECKSIGVERIFY'],
+    ['OP_CHECKDATASIG OP_VERIFY', 'OP_CHECKDATASIGVERIFY'],
+    // Remove/replace extraneous OP_SWAP
+    ['OP_SWAP OP_ADD', 'OP_ADD'],
+    // This was added to keep the old behaviour while explicitly disallowing partial matches in the optimisation regex
+    ['OP_SWAP OP_EQUALVERIFY', 'OP_EQUALVERIFY'],
+    ['OP_SWAP OP_EQUAL', 'OP_EQUAL'],
+    // This was added to keep the old behaviour while explicitly disallowing partial matches in the optimisation regex
+    ['OP_SWAP OP_NUMEQUALVERIFY', 'OP_NUMEQUALVERIFY'],
+    ['OP_SWAP OP_NUMEQUAL', 'OP_NUMEQUAL'],
+    ['OP_SWAP OP_NUMNOTEQUAL', 'OP_NUMNOTEQUAL'],
+    ['OP_SWAP OP_GREATERTHANOREQUAL', 'OP_LESSTHANOREQUAL'],
+    ['OP_SWAP OP_LESSTHANOREQUAL', 'OP_GREATERTHANOREQUAL'],
+    ['OP_SWAP OP_GREATERTHAN', 'OP_LESSTHAN'],
+    ['OP_SWAP OP_LESSTHAN', 'OP_GREATERTHAN'],
+    ['OP_SWAP OP_DROP', 'OP_NIP'],
+    ['OP_SWAP OP_NIP', 'OP_DROP'],
+    // Remove/replace extraneous OP_DUP
+    ['OP_DUP OP_DROP', ''],
+    ['OP_DUP OP_NIP', ''],
+    // Random optimisations (don't know what I'm targeting with this)
+    ['OP_2DUP OP_DROP', 'OP_OVER'],
+    ['OP_2DUP OP_NIP', 'OP_DUP'],
+    ['OP_CAT OP_DROP', 'OP_2DROP'],
+    ['OP_NIP OP_DROP', 'OP_2DROP'],
+    // Far-fetched stuff
+    ['OP_DUP OP_ROT OP_SWAP OP_DROP', 'OP_SWAP'],
+    ['OP_OVER OP_ROT OP_SWAP OP_DROP', 'OP_SWAP'],
+    ['OP_2 OP_PICK OP_ROT OP_SWAP OP_DROP', 'OP_SWAP'],
+    ['OP_3 OP_PICK OP_ROT OP_SWAP OP_DROP', 'OP_SWAP'],
+    ['OP_4 OP_PICK OP_ROT OP_SWAP OP_DROP', 'OP_SWAP'],
+    ['OP_5 OP_PICK OP_ROT OP_SWAP OP_DROP', 'OP_SWAP'],
+    ['OP_6 OP_PICK OP_ROT OP_SWAP OP_DROP', 'OP_SWAP'],
+    ['OP_7 OP_PICK OP_ROT OP_SWAP OP_DROP', 'OP_SWAP'],
+    ['OP_8 OP_PICK OP_ROT OP_SWAP OP_DROP', 'OP_SWAP'],
+    ['OP_9 OP_PICK OP_ROT OP_SWAP OP_DROP', 'OP_SWAP'],
+    ['OP_10 OP_PICK OP_ROT OP_SWAP OP_DROP', 'OP_SWAP'],
+    ['OP_11 OP_PICK OP_ROT OP_SWAP OP_DROP', 'OP_SWAP'],
+    ['OP_12 OP_PICK OP_ROT OP_SWAP OP_DROP', 'OP_SWAP'],
+    ['OP_13 OP_PICK OP_ROT OP_SWAP OP_DROP', 'OP_SWAP'],
+    ['OP_14 OP_PICK OP_ROT OP_SWAP OP_DROP', 'OP_SWAP'],
+    ['OP_16 OP_PICK OP_ROT OP_SWAP OP_DROP', 'OP_SWAP'],
+    ['OP_DUP OP_ROT OP_DROP', 'OP_NIP OP_DUP'],
+    ['OP_OVER OP_ROT OP_DROP', 'OP_SWAP'],
+    ['OP_2 OP_PICK OP_ROT OP_DROP', 'OP_NIP OP_OVER'],
+    ['OP_0 OP_NIP', 'OP_DROP OP_0'],
+    ['OP_1 OP_NIP', 'OP_DROP OP_1'],
+    ['OP_2 OP_NIP', 'OP_DROP OP_2'],
+    ['OP_3 OP_NIP', 'OP_DROP OP_3'],
+    ['OP_4 OP_NIP', 'OP_DROP OP_4'],
+    ['OP_5 OP_NIP', 'OP_DROP OP_5'],
+    ['OP_6 OP_NIP', 'OP_DROP OP_6'],
+    ['OP_7 OP_NIP', 'OP_DROP OP_7'],
+    ['OP_8 OP_NIP', 'OP_DROP OP_8'],
+    ['OP_9 OP_NIP', 'OP_DROP OP_9'],
+    ['OP_10 OP_NIP', 'OP_DROP OP_10'],
+    ['OP_11 OP_NIP', 'OP_DROP OP_11'],
+    ['OP_12 OP_NIP', 'OP_DROP OP_12'],
+    ['OP_13 OP_NIP', 'OP_DROP OP_13'],
+    ['OP_14 OP_NIP', 'OP_DROP OP_14'],
+    ['OP_15 OP_NIP', 'OP_DROP OP_15'],
+    ['OP_16 OP_NIP', 'OP_DROP OP_16'],
+    ['OP_2 OP_PICK OP_SWAP OP_2 OP_PICK OP_NIP', 'OP_DROP OP_2DUP'],
+];
+const unprovableOptimisations = [
+    // Hardcoded arithmetic
+    // CashProof can't prove OP_IF without parameters
+    ['OP_NOT OP_IF', 'OP_NOTIF'],
+    // Merge OP_VERIFY
+    // CashProof can't prove OP_CHECKMULTISIG without specifying N
+    ['OP_CHECKMULTISIG OP_VERIFY', 'OP_CHECKMULTISIGVERIFY'],
+    // Remove/replace extraneous OP_SWAP
+    // CashProof can't prove bitwise operators
+    ['OP_SWAP OP_AND', 'OP_AND'],
+    ['OP_SWAP OP_OR', 'OP_OR'],
+    ['OP_SWAP OP_XOR', 'OP_XOR'],
+    // Remove/replace extraneous OP_DUP
+    // CashProof can't prove bitwise operators
+    ['OP_DUP OP_AND', ''],
+    ['OP_DUP OP_OR', ''],
+];
+// Note: we moved these optimisations into a single file, but kept the exact same order as before,
+// because the order in which oprimisations are applied can impact the output.
+export const optimisationReplacements = [...provableOptimisations, ...unprovableOptimisations];
+//# sourceMappingURL=optimisations.js.map

package/dist/script.d.ts

@@ -1,4 +1,6 @@
 import { OpcodesBch2023 } from '@bitauth/libauth';
+import { FullLocationData } from './types.js';
+import { LogEntry, RequireStatement } from './artifact.js';
 export declare const Op: typeof OpcodesBch2023;
 export type Op = number;
 export type OpOrData = Op | Uint8Array;
@@ -16,4 +18,12 @@ export declare function countOpcodes(script: Script): number;
 export declare function calculateBytesize(script: Script): number;
 export declare function encodeNullDataScript(chunks: OpOrData[]): Uint8Array;
 export declare function generateRedeemScript(baseScript: Script, encodedConstructorArgs: Script): Script;
-export declare function optimiseBytecode(script: Script, runs?: number): Script;
+interface OptimiseBytecodeResult {
+    script: Script;
+    locationData: FullLocationData;
+    logs: LogEntry[];
+    requires: RequireStatement[];
+}
+export declare function optimiseBytecode(script: Script, locationData: FullLocationData, logs: LogEntry[], requires: RequireStatement[], constructorParamLength: number, runs?: number): OptimiseBytecodeResult;
+export declare function optimiseBytecodeOld(script: Script, runs?: number): Script;
+export {};

package/dist/script.js

@@ -1,5 +1,7 @@
 import { OpcodesBch2023, encodeDataPush, hexToBin, disassembleBytecodeBch, flattenBinArray, encodeAuthenticationInstructions, decodeAuthenticationInstructions, } from '@bitauth/libauth';
 import OptimisationsEquivFile from './cashproof-optimisations.js';
+import { optimisationReplacements } from './optimisations.js';
+import { PositionHint } from './types.js';
 export const Op = OpcodesBch2023;
 export function scriptToAsm(script) {
     return bytecodeToAsm(scriptToBytecode(script));
@@ -101,7 +103,21 @@ function getPushDataOpcode(data) {
 export function generateRedeemScript(baseScript, encodedConstructorArgs) {
     return [...encodedConstructorArgs.slice().reverse(), ...baseScript];
 }
-export function optimiseBytecode(script, runs = 1000) {
+export function optimiseBytecode(script, locationData, logs, requires, constructorParamLength, runs = 1000) {
+    for (let i = 0; i < runs; i += 1) {
+        const oldScript = script;
+        const { script: newScript, locationData: newLocationData, logs: newLogs, requires: newRequires, } = replaceOps(script, locationData, logs, requires, constructorParamLength, optimisationReplacements);
+        // Break on fixed point
+        if (scriptToAsm(oldScript) === scriptToAsm(newScript))
+            break;
+        script = newScript;
+        locationData = newLocationData;
+        logs = newLogs;
+        requires = newRequires;
+    }
+    return { script, locationData, logs, requires };
+}
+export function optimiseBytecodeOld(script, runs = 1000) {
     const optimisations = OptimisationsEquivFile
         // Split by line and filter all line comments (#)
         .split('\n')
@@ -116,14 +132,14 @@ export function optimiseBytecode(script, runs = 1000) {
         .filter((equiv) => equiv.length === 2);
     for (let i = 0; i < runs; i += 1) {
         const oldScript = script;
-        script = replaceOps(script, optimisations);
+        script = replaceOpsOld(script, optimisations);
         // Break on fixed point
         if (scriptToAsm(oldScript) === scriptToAsm(script))
             break;
     }
     return script;
 }
-function replaceOps(script, optimisations) {
+function replaceOpsOld(script, optimisations) {
     let asm = scriptToAsm(script);
     // Apply all optimisations in the cashproof file
     optimisations.forEach(([pattern, replacement]) => {
@@ -144,4 +160,139 @@ function replaceOps(script, optimisations) {
     asm = asm.replace(/\s+/g, ' ').trim();
     return asmToScript(asm);
 }
+function replaceOps(script, locationData, logs, requires, constructorParamLength, optimisations) {
+    let asm = scriptToAsm(script);
+    let newLocationData = [...locationData];
+    let newLogs = [...logs];
+    let newRequires = [...requires];
+    optimisations.forEach(([pattern, replacement]) => {
+        let processedAsm = '';
+        let asmToSearch = asm;
+        // We add a space or end of string to the end of the pattern to ensure that we match the whole pattern
+        // (no partial matches)
+        const regex = new RegExp(`${pattern}(\\s|$)`, 'g');
+        let matchIndex = asmToSearch.search(regex);
+        while (matchIndex !== -1) {
+            // We add the part before the match to the processed asm
+            processedAsm = mergeAsm(processedAsm, asmToSearch.slice(0, matchIndex));
+            // We count the number of spaces in the processed asm + 1, which is equal to the script index
+            // We do the same thing to calculate the number of opcodes in the pattern and replacement
+            const scriptIndex = processedAsm === '' ? 0 : [...processedAsm.matchAll(/\s+/g)].length + 1;
+            const patternLength = [...pattern.matchAll(/\s+/g)].length + 1;
+            const replacementLength = replacement === '' ? 0 : [...replacement.matchAll(/\s+/g)].length + 1;
+            // We get the locationdata entries for every opcode in the pattern
+            const patternLocations = newLocationData.slice(scriptIndex, scriptIndex + patternLength);
+            // We get the lowest start location and highest end location of the pattern
+            const lowestStart = getLowestStartLocation(patternLocations);
+            const highestEnd = getHighestEndLocation(patternLocations);
+            // If any of the pattern locations have a position hint of END, we use that as the position hint
+            const positionHint = patternLocations.some((location) => location.positionHint === PositionHint.END)
+                ? PositionHint.END
+                : PositionHint.START;
+            // We merge the lowest start and highest end locations into a single location data entry
+            const mergedLocation = {
+                location: {
+                    start: lowestStart.location.start,
+                    end: highestEnd.location.end,
+                },
+                positionHint,
+            };
+            // We replace the pattern locations with the merged location
+            // (note that every opcode in the replacement has the same location)
+            const replacementLocations = new Array(replacementLength).fill(mergedLocation);
+            newLocationData.splice(scriptIndex, patternLength, ...replacementLocations);
+            const lengthDiff = patternLength - replacementLength; // 2 or 1
+            // The IP of an opcode in the script is its index within the script + the constructor parameters, because
+            // the constructor parameters still have to get added to the front of the script when a new Contract is created.
+            const scriptIp = scriptIndex + constructorParamLength;
+            newRequires = newRequires.map((require) => {
+                // We calculate the new ip of the require by subtracting the length diff between the matched pattern and replacement
+                const newCalculatedRequireIp = require.ip - lengthDiff;
+                return {
+                    ...require,
+                    // If the require is within the pattern, we want to make sure that the new ip is at least the scriptIp
+                    // Note that this is impossible for the current set of optimisations, but future proofs the code
+                    ip: require.ip >= scriptIp ? Math.max(scriptIp, newCalculatedRequireIp) : require.ip,
+                };
+            });
+            newLogs = newLogs.map((log) => {
+                // We calculate the new ip of the log by subtracting the length diff between the matched pattern and replacement
+                const newCalculatedLogIp = log.ip - lengthDiff;
+                return {
+                    // If the log is within the pattern, we want to make sure that the new ip is at least the scriptIp
+                    ip: log.ip >= scriptIp ? Math.max(scriptIp, newCalculatedLogIp) : log.ip,
+                    line: log.line,
+                    data: log.data.map((data) => {
+                        if (typeof data === 'string')
+                            return data;
+                        // If the log is completely before the pattern, we don't need to change anything
+                        if (data.ip <= scriptIp)
+                            return data;
+                        // If the log is completely after the pattern, we just need to offset the ip by the length diff
+                        if (data.ip >= scriptIp + patternLength) {
+                            const newCalculatedDataIp = data.ip - lengthDiff;
+                            return { ...data, ip: newCalculatedDataIp };
+                        }
+                        const addedTransformationsCount = data.ip - scriptIp;
+                        const addedTransformations = [...pattern.split(/\s+/g)].slice(0, addedTransformationsCount).join(' ');
+                        const newTransformations = data.transformations ? `${addedTransformations} ${data.transformations}` : addedTransformations;
+                        return {
+                            ...data,
+                            ip: scriptIp,
+                            transformations: newTransformations,
+                        };
+                    }),
+                };
+            });
+            // We add the replacement to the processed asm
+            processedAsm = mergeAsm(processedAsm, replacement);
+            // We do not add the matched pattern anywhere since it gets replaced
+            // We set the asmToSearch to the part after the match
+            asmToSearch = asmToSearch.slice(matchIndex + pattern.length).trim();
+            // Find the next match
+            matchIndex = asmToSearch.search(regex);
+        }
+        // We add the remaining asm to the processed asm
+        processedAsm = mergeAsm(processedAsm, asmToSearch);
+        // We replace the original asm with the processed asm so that the next optimisation can use the updated asm
+        asm = processedAsm;
+    });
+    return {
+        script: asmToScript(asm),
+        locationData: newLocationData,
+        logs: newLogs,
+        requires: newRequires,
+    };
+}
+const getHighestEndLocation = (locations) => {
+    return locations.reduce((highest, current) => {
+        if (current.location.end.line > highest.location.end.line) {
+            return current;
+        }
+        if (highest.location.end.line === current.location.end.line) {
+            if (current.location.end.column > highest.location.end.column) {
+                return current;
+            }
+        }
+        return highest;
+    }, locations[0]);
+};
+const getLowestStartLocation = (locations) => {
+    return locations.reduce((lowest, current) => {
+        if (current.location.start.line < lowest.location.start.line) {
+            return current;
+        }
+        if (lowest.location.start.line === current.location.start.line) {
+            if (current.location.start.column < lowest.location.start.column) {
+                return current;
+            }
+        }
+        return lowest;
+    }, locations[0]);
+};
+const mergeAsm = (asm1, asm2) => {
+    // We merge two ASM strings by adding a space between them, and removing any duplicate spaces
+    // or trailing/leading spaces, which might have been introduced due to regex matching / replacements / empty asm strings
+    return `${asm1} ${asm2}`.replace(/\s+/g, ' ').trim();
+};
 //# sourceMappingURL=script.js.map

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@cashscript/utils",
-  "version": "0.11.0-next.2",
+  "version": "0.11.0-next.4",
   "description": "CashScript utilities and types",
   "keywords": [
     "bitcoin cash",
     "cashscript",
     "sdk",
-    "smart contracts"
+    "smart contracts",
+    "cashtokens"
   ],
   "homepage": "https://cashscript.org",
   "bugs": {
@@ -18,6 +19,9 @@
   },
   "license": "MIT",
   "author": "Rosco Kalis <roscokalis@gmail.com>",
+  "contributors": [
+    "Mathieu Geukens <mr-zwets@protonmail.com>"
+  ],
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
@@ -48,5 +52,5 @@
     "jest": "^29.7.0",
     "typescript": "^5.7.3"
   },
-  "gitHead": "47d29372460bc397abc174e7404b7620858b6ecc"
+  "gitHead": "68cdf30db455e3eef448a4feacfff0f5f26a36a7"
 }