@cashscript/utils 0.9.3 → 0.10.0-next.1

package/dist/artifact.d.ts

@@ -9,12 +9,31 @@ export interface AbiFunction {
     covenant?: boolean;
     inputs: AbiInput[];
 }
+export interface LogEntry {
+    ip: number;
+    line: number;
+    data: Array<{
+        stackIndex: number;
+        type: string;
+    } | string>;
+}
+export interface RequireMessage {
+    ip: number;
+    line: number;
+    message: string;
+}
 export interface Artifact {
     contractName: string;
     constructorInputs: AbiInput[];
     abi: AbiFunction[];
     bytecode: string;
     source: string;
+    debug?: {
+        bytecode: string;
+        sourceMap: string;
+        logs: LogEntry[];
+        requireMessages: RequireMessage[];
+    };
     compiler: {
         name: string;
         version: string;

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,3 +3,5 @@ export * from './data.js';
 export * from './hash.js';
 export * from './script.js';
 export * from './types.js';
+export * from './source-map.js';
+export * from './bitauth-script.js';

package/dist/index.js

@@ -3,4 +3,6 @@ export * from './data.js';
 export * from './hash.js';
 export * from './script.js';
 export * from './types.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/source-map.d.ts

@@ -0,0 +1,13 @@
+export interface LocationI {
+    start: {
+        line: number;
+        column: number;
+    };
+    end: {
+        line: number;
+        column: number;
+    };
+}
+export declare type LocationData = Array<[location: LocationI, positionHint?: number]>;
+export declare function generateSourceMap(locationData: LocationData): string;
+export declare const sourceMapToLocationData: (sourceMap: string) => LocationData;

package/dist/source-map.js

@@ -0,0 +1,95 @@
+/*
+ * The source mappings for the bytecode use the following notation (similar to Solidity):
+ *
+ * `sl:sc:el:ec:h`
+ *
+ * Where `sl` is the start line, `sc` - start column, `el` - end line, and `ec` - end column
+ * of the range in the source file.
+ * `h` is the position hint denoting where to place the instruction - at the beginning of the parent AST block
+ * or at the end.
+ * `h` is used with AST blocks, instructions of which surround children blocks, like function declarations and
+ * if-then-else blocks.
+ *
+ * Mappings are a list of `sl:sc:el:ec:h` separated by `;`. Each of these elements corresponds to an instruction.
+ *
+ * In order to compress these source mappings, the following rules are used:
+ *
+ * If a field is empty, the value of the preceding element is used.
+ * If a `:` is missing, all the following fields are considered empty.
+ * This means the following source mappings represent the same information:
+ *
+ * 14:20:14:29;14:20:14:29;14:12:14:30;14:34:14:43;14:34:14:43
+ *
+ * 14:20:14:29;;:12::30;:34::43;
+ *
+ */
+export function generateSourceMap(locationData) {
+    let prevStartLine = 0;
+    let prevStartColumn = 0;
+    let prevEndLine = 0;
+    let prevEndColumn = 0;
+    let prevHint = 0;
+    return locationData.map((row) => {
+        const prevStartLineString = prevStartLine === row[0].start.line ? '' : String(row[0].start.line);
+        prevStartLine = row[0].start.line;
+        const prevStartColumnString = prevStartColumn === row[0].start.column ? '' : String(row[0].start.column);
+        prevStartColumn = row[0].start.column;
+        const prevEndLineString = prevEndLine === row[0].end.line ? '' : String(row[0].end.line);
+        prevEndLine = row[0].end.line;
+        const prevEndColumnString = prevEndColumn === row[0].end.column ? '' : String(row[0].end.column);
+        prevEndColumn = row[0].end.column;
+        const hint = row[1] ?? 0;
+        const prevHintString = prevHint === hint ? '' : String(hint);
+        prevHint = hint;
+        let result = '';
+        if (prevStartLineString) {
+            result += prevStartLineString;
+        }
+        result += ':';
+        if (prevStartColumnString) {
+            result += prevStartColumnString;
+        }
+        result += ':';
+        if (prevEndLineString) {
+            result += prevEndLineString;
+        }
+        result += ':';
+        if (prevEndColumnString) {
+            result += prevEndColumnString;
+        }
+        result += ':';
+        if (prevHintString) {
+            result += prevHintString;
+        }
+        result = result.replace(/:*$/, '');
+        return result;
+    }).join(';');
+}
+export const sourceMapToLocationData = (sourceMap) => {
+    let prevStartLine = 0;
+    let prevStartColumn = 0;
+    let prevEndLine = 0;
+    let prevEndColumn = 0;
+    let prevHint;
+    return sourceMap.split(';').map((entry) => {
+        const val = entry.split(':');
+        const startLine = val[0] ? Number(val[0]) : prevStartLine;
+        prevStartLine = startLine;
+        const startColumn = val[1] ? Number(val[1]) : prevStartColumn;
+        prevStartColumn = startColumn;
+        const endLine = val[2] ? Number(val[2]) : prevEndLine;
+        prevEndLine = endLine;
+        const endColumn = val[3] ? Number(val[3]) : prevEndColumn;
+        prevEndColumn = endColumn;
+        const hint = val[4] ? Number(val[4]) : prevHint;
+        prevHint = hint;
+        return [
+            {
+                start: { line: startLine, column: startColumn },
+                end: { line: endLine, column: endColumn },
+            },
+            ...(hint ? [hint] : []),
+        ];
+    });
+};
+//# sourceMappingURL=source-map.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cashscript/utils",
-  "version": "0.9.3",
+  "version": "0.10.0-next.1",
   "description": "CashScript utilities and types",
   "keywords": [
     "bitcoin cash",
@@ -45,9 +45,9 @@
   },
   "devDependencies": {
     "@jest/globals": "^29.4.1",
-    "eslint": "^7.20.0",
+    "eslint": "^8.54.0",
     "jest": "^29.4.1",
     "typescript": "^4.1.5"
   },
-  "gitHead": "01f9b9bb552c3c4d63b0c7c8f065a0e23b536ca6"
+  "gitHead": "1370c6b1b1489b96964b6df4a860709cd73a06cc"
 }