@cashscript/utils 0.10.0-next.0 → 0.10.0-next.2

package/dist/bitauth-script.d.ts

@@ -0,0 +1,6 @@
+import { Script } from './script.js';
+export declare type LineToOpcodesMap = Record<string, Script>;
+export declare type LineToAsmMap = Record<string, string>;
+export declare function buildLineToOpcodesMap(bytecode: Script, souceMap: string): LineToOpcodesMap;
+export declare function buildLineToAsmMap(bytecode: Script, souceMap: string): LineToAsmMap;
+export declare function formatBitAuthScript(bytecode: Script, souceMap: string, sourceCode: string): string;

package/dist/bitauth-script.js

@@ -0,0 +1,31 @@
+import { scriptToBitAuthAsm } from './script.js';
+import { sourceMapToLocationData } from './source-map.js';
+export function buildLineToOpcodesMap(bytecode, souceMap) {
+    const locationData = sourceMapToLocationData(souceMap);
+    return locationData.reduce((lineToOpcodeMap, [location, positionHint], index) => {
+        const opcode = bytecode[index];
+        const line = positionHint ? location?.end.line : location?.start.line;
+        return {
+            ...lineToOpcodeMap,
+            [line]: [...(lineToOpcodeMap[line] || []), opcode],
+        };
+    }, {});
+}
+export function buildLineToAsmMap(bytecode, souceMap) {
+    const lineToOpcodesMap = buildLineToOpcodesMap(bytecode, souceMap);
+    return Object.fromEntries(Object.entries(lineToOpcodesMap).map(([lineNumber, opcodeList]) => [lineNumber, scriptToBitAuthAsm(opcodeList)]));
+}
+export function formatBitAuthScript(bytecode, souceMap, sourceCode) {
+    const lineToAsmMap = buildLineToAsmMap(bytecode, souceMap);
+    const sourceCodeLines = sourceCode.split('\n');
+    const sourceCodeLineLengths = sourceCodeLines.map((line) => line.length);
+    const bytecodeLineLengths = Object.values(lineToAsmMap).map((line) => line.length);
+    const maxSourceCodeLength = Math.max(...sourceCodeLineLengths);
+    const maxBytecodeLength = Math.max(...bytecodeLineLengths);
+    const annotatedAsmLines = sourceCodeLines.map((line, index) => {
+        const lineAsm = lineToAsmMap[index + 1];
+        return `${(lineAsm || '').padEnd(maxBytecodeLength)} /* ${line.padEnd(maxSourceCodeLength)} */`;
+    });
+    return annotatedAsmLines.join('\n');
+}
+//# sourceMappingURL=bitauth-script.js.map

package/dist/index.d.ts

@@ -3,5 +3,5 @@ export * from './data.js';
 export * from './hash.js';
 export * from './script.js';
 export * from './types.js';
-export * from './sourceMap.js';
-export * from './libauth.js';
+export * from './source-map.js';
+export * from './bitauth-script.js';

package/dist/index.js

@@ -3,6 +3,6 @@ export * from './data.js';
 export * from './hash.js';
 export * from './script.js';
 export * from './types.js';
-export * from './sourceMap.js';
-export * from './libauth.js';
+export * from './source-map.js';
+export * from './bitauth-script.js';
 //# sourceMappingURL=index.js.map

package/dist/script.d.ts

@@ -3,11 +3,14 @@ export declare type Op = number;
 export declare type OpOrData = Op | Uint8Array;
 export declare type Script = OpOrData[];
 export declare function scriptToAsm(script: Script): string;
+export declare function scriptToBitAuthAsm(script: Script): string;
 export declare function asmToScript(asm: string): Script;
+export declare function bitAuthAsmToScript(asm: string): Script;
 export declare function scriptToBytecode(script: Script): Uint8Array;
 export declare function bytecodeToScript(bytecode: Uint8Array): Script;
 export declare function asmToBytecode(asm: string): Uint8Array;
 export declare function bytecodeToAsm(bytecode: Uint8Array): string;
+export declare function bytecodeToBitAuthAsm(bytecode: Uint8Array): string;
 export declare function countOpcodes(script: Script): number;
 export declare function calculateBytesize(script: Script): number;
 export declare function encodeNullDataScript(chunks: OpOrData[]): Uint8Array;

package/dist/script.js

@@ -5,9 +5,18 @@ export const Op = OpcodesBCH;
 export function scriptToAsm(script) {
     return bytecodeToAsm(scriptToBytecode(script));
 }
+// TODO: See note at bytecodeToAsm
+export function scriptToBitAuthAsm(script) {
+    return bytecodeToBitAuthAsm(scriptToBytecode(script));
+}
+// TODO: Figure out why OP_0 is decoded to an empty Uint8Array (while e.g. OP_3 is just OP_3)
 export function asmToScript(asm) {
     return bytecodeToScript(asmToBytecode(asm));
 }
+// asmToBytecode also works for BitAuth ASM
+export function bitAuthAsmToScript(asm) {
+    return asmToScript(asm);
+}
 export function scriptToBytecode(script) {
     // Convert the script elements to AuthenticationInstructions
     const instructions = script.map((opOrData) => {
@@ -34,7 +43,8 @@ export function asmToBytecode(asm) {
         if (token.startsWith('OP_')) {
             return { opcode: Op[token] };
         }
-        return decodeAuthenticationInstructions(encodeDataPush(hexToBin(token)))[0];
+        const data = token.replace(/<|>/g, '').replace(/^0x/, '');
+        return decodeAuthenticationInstructions(encodeDataPush(hexToBin(data)))[0];
     });
     // Convert the AuthenticationInstructions to bytecode
     return encodeAuthenticationInstructions(instructions);
@@ -50,6 +60,19 @@ export function bytecodeToAsm(bytecode) {
     asm = asm.replace(/\s+/g, ' ').trim();
     return asm;
 }
+// TODO: If we decide to change the ASM / artifact format, we can remove this function and merge it
+// with bytecodeToAsm
+export function bytecodeToBitAuthAsm(bytecode) {
+    // Convert the bytecode to libauth's ASM format
+    let asm = disassembleBytecodeBCH(bytecode);
+    // COnvert libauth's ASM format to BITBOX's
+    asm = asm.replace(/OP_PUSHBYTES_[^\s]+/g, '');
+    asm = asm.replace(/OP_PUSHDATA[^\s]+ [^\s]+/g, '');
+    asm = asm.replace(/(^|\s)(0x\w*)/g, ' \<$2\>');
+    // Remove any duplicate whitespace
+    asm = asm.replace(/\s+/g, ' ').trim();
+    return asm;
+}
 export function countOpcodes(script) {
     return script
         .filter((opOrData) => typeof opOrData === 'number')

package/dist/{sourceMap.js → source-map.js}

@@ -92,4 +92,4 @@ export const sourceMapToLocationData = (sourceMap) => {
         ];
     });
 };
-//# sourceMappingURL=sourceMap.js.map
+//# sourceMappingURL=source-map.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cashscript/utils",
-  "version": "0.10.0-next.0",
+  "version": "0.10.0-next.2",
   "description": "CashScript utilities and types",
   "keywords": [
     "bitcoin cash",
@@ -35,7 +35,7 @@
     "compile:test": "tsc -p tsconfig.test.json",
     "lint": "eslint . --ext .ts --ignore-path ../../.eslintignore",
     "prepare": "yarn build",
-    "prepublishOnly": "yarn test",
+    "prepublishOnly": "yarn test && yarn lint",
     "pretest": "yarn build:test",
     "test": "NODE_OPTIONS='--experimental-vm-modules --no-warnings' jest"
   },
@@ -49,5 +49,5 @@
     "jest": "^29.4.1",
     "typescript": "^4.1.5"
   },
-  "gitHead": "3514c438fa3c8069c36f45cc80730293ac85dbdf"
+  "gitHead": "23f2f6fc78f6a911dfe559404be7741aa824e791"
 }

package/dist/libauth.d.ts

@@ -1,5 +0,0 @@
-import { Script } from './script.js';
-export declare function buildOpCodeMap(bytecode: Script, souceMap: string): {
-    [key: string]: string;
-};
-export declare function formatLibauthScript(bytecode: Script, souceMap: string, sourceCode: string): string;

package/dist/libauth.js

@@ -1,50 +0,0 @@
-import { binToHex } from '@bitauth/libauth';
-import { Op } from './script.js';
-import { sourceMapToLocationData } from './sourceMap.js';
-function buildLineMap(bytecode, souceMap) {
-    const lineMap = {};
-    const locationData = sourceMapToLocationData(souceMap);
-    const map = locationData.map(([location, positionHint], index) => {
-        const op = bytecode[index];
-        return [
-            op,
-            Object.keys(Op)[Object.values(Op).indexOf(op)],
-            positionHint ? location?.end.line : location?.start.line,
-        ];
-    });
-    map.forEach(([op, , line]) => {
-        if (!lineMap[line]) {
-            lineMap[line] = [];
-        }
-        lineMap[line].push(op);
-    });
-    return lineMap;
-}
-export function buildOpCodeMap(bytecode, souceMap) {
-    const lineMap = buildLineMap(bytecode, souceMap);
-    const opCodeMap = {};
-    for (const [key, value] of Object.entries(lineMap)) {
-        opCodeMap[key] = value.map((asmElement) => {
-            if (asmElement instanceof Uint8Array) {
-                if (asmElement.length === 0) {
-                    return 'OP_0';
-                }
-                return `<0x${binToHex(asmElement)}>`;
-            }
-            return Object.keys(Op)[Object.values(Op).indexOf(asmElement)];
-        }).join(' ');
-    }
-    return opCodeMap;
-}
-export function formatLibauthScript(bytecode, souceMap, sourceCode) {
-    const opCodeMap = buildOpCodeMap(bytecode, souceMap);
-    const split = sourceCode.split('\n');
-    const maxCodeLength = Math.max(...split.map((val) => val.length));
-    const maxBytecodeLength = Math.max(...Object.values(opCodeMap).map((val) => val.length));
-    const result = split.map((line, index) => {
-        const opCodes = opCodeMap[index + 1];
-        return `${(opCodes || '').padEnd(maxBytecodeLength)} /* ${line.padEnd(maxCodeLength)} */`;
-    }).join('\n');
-    return result;
-}
-//# sourceMappingURL=libauth.js.map