@cashscript/utils 0.13.0-next.6 → 0.13.0-next.8

package/dist/artifact.d.ts

@@ -1,5 +1,6 @@
 export interface CompilerOptions {
     enforceFunctionParameterTypes?: boolean;
+    enforceLocktimeGuard?: boolean;
 }
 export interface AbiInput {
     name: string;
@@ -46,5 +47,6 @@ export interface Artifact {
         options?: CompilerOptions;
     };
     updatedAt: string;
+    fingerprint?: string;
 }
 export declare function formatArtifact(artifact: Artifact, format: 'json' | 'ts'): string;

package/dist/data.d.ts

@@ -1,6 +1,7 @@
 export declare function encodeBool(bool: boolean): Uint8Array;
 export declare function decodeBool(encodedBool: Uint8Array): boolean;
 export declare function encodeInt(int: bigint): Uint8Array;
+export declare function encodeIntAsFixedBytes(int: bigint, byteLength: number): Uint8Array;
 export declare function decodeInt(encodedInt: Uint8Array, maxLength?: number): bigint;
 export declare function encodeString(str: string): Uint8Array;
 export declare function decodeString(encodedString: Uint8Array): string;

package/dist/data.js

@@ -1,4 +1,4 @@
-import { bigIntToVmNumber, utf8ToBin, binToUtf8, vmNumberToBigInt, isVmNumberError, } from '@bitauth/libauth';
+import { bigIntToVmNumber, utf8ToBin, binToUtf8, vmNumberToBigInt, isVmNumberError, padMinimallyEncodedVmNumber, } from '@bitauth/libauth';
 export function encodeBool(bool) {
     return bool ? encodeInt(1n) : encodeInt(0n);
 }
@@ -17,6 +17,12 @@ export function decodeBool(encodedBool) {
 export function encodeInt(int) {
     return bigIntToVmNumber(int);
 }
+export function encodeIntAsFixedBytes(int, byteLength) {
+    const minimal = encodeInt(int);
+    if (minimal.length > byteLength)
+        throw new Error('value exceeds the requested byteLength');
+    return padMinimallyEncodedVmNumber(minimal, byteLength);
+}
 export function decodeInt(encodedInt, maxLength = Infinity) {
     const options = { maximumVmNumberByteLength: maxLength };
     const result = vmNumberToBigInt(encodedInt, options);

package/dist/fingerprint.d.ts

@@ -0,0 +1,5 @@
+import { Op, Script } from './script.js';
+export declare function computeBytecodePattern(bytecode: Uint8Array): Uint8Array;
+export declare function computeBytecodeFingerprint(bytecode: Uint8Array): string;
+export declare function computeBytecodeFingerprintWithConstructorArgs(bytecodeScript: Script, constructorArgsCount: number): string;
+export declare function isPushOpcode(opcode: Op): boolean;

package/dist/fingerprint.js

@@ -0,0 +1,50 @@
+import { binToHex, decodeAuthenticationInstructions, encodeDataPush, flattenBinArray, isPushOperation, } from '@bitauth/libauth';
+import { encodeInt } from './data.js';
+import { sha256 } from './hash.js';
+import { generateContractBytecodeScript, Op, scriptToBytecode } from './script.js';
+// Transform locking bytecode into the normalized "pattern" form: every run of
+// consecutive push instructions is replaced by a single push of the run length.
+// See: https://gitlab.com/0353F40E/smart-contract-fingerprinting/
+export function computeBytecodePattern(bytecode) {
+    const opcodes = decodeAuthenticationInstructions(bytecode).map((instruction) => instruction.opcode);
+    const chunks = groupByPushRun(opcodes).map((run) => (isPushOpcode(run[0]) ? encodePushCount(run.length) : Uint8Array.from(run)));
+    return flattenBinArray(chunks);
+}
+// Split opcodes into consecutive runs that are either all pushes or all non-pushes.
+function groupByPushRun(opcodes) {
+    return opcodes.reduce((opcodeRuns, opcode) => {
+        const lastOpcodeRun = opcodeRuns.at(-1);
+        // If ther are no runs yet, start a new run with the current opcode
+        if (!lastOpcodeRun)
+            return [[opcode]];
+        // If the last run is the same type of opcode as the current opcode, add the current opcode to the last run
+        // Else, start a new run with the current opcode
+        if (isPushOpcode(lastOpcodeRun[0]) === isPushOpcode(opcode)) {
+            lastOpcodeRun.push(opcode);
+        }
+        else {
+            opcodeRuns.push([opcode]);
+        }
+        return opcodeRuns;
+    }, []);
+}
+// Compute the SHA256 fingerprint of the normalized bytecode pattern, returned as hex.
+export function computeBytecodeFingerprint(bytecode) {
+    return binToHex(sha256(computeBytecodePattern(bytecode)));
+}
+// Add placeholder constructor arguments to the bytecode script and compute the fingerprint.
+export function computeBytecodeFingerprintWithConstructorArgs(bytecodeScript, constructorArgsCount) {
+    const placeholderConstructorArgs = new Array(constructorArgsCount).fill(0);
+    const bytecodeWithConstructorArgs = generateContractBytecodeScript(bytecodeScript, placeholderConstructorArgs);
+    return computeBytecodeFingerprint(scriptToBytecode(bytecodeWithConstructorArgs));
+}
+// Note: libauth's isPushOperation also matches OP_RESERVED (0x50) — the spec excludes it.
+export function isPushOpcode(opcode) {
+    return isPushOperation(opcode) && opcode !== Op.OP_RESERVED;
+}
+// Encode a push count using the smallest possible push encoding.
+// libauth's encodeDataPush minimally encodes VM Numbers in the -1..16 range as OP_N.
+function encodePushCount(count) {
+    return encodeDataPush(encodeInt(BigInt(count)));
+}
+//# sourceMappingURL=fingerprint.js.map

package/dist/index.d.ts

@@ -2,6 +2,7 @@ export * from './artifact.js';
 export * from './bip68.js';
 export * from './bitauth-script.js';
 export * from './data.js';
+export * from './fingerprint.js';
 export * from './hash.js';
 export * from './script.js';
 export * from './source-map.js';

package/dist/index.js

@@ -2,6 +2,7 @@ export * from './artifact.js';
 export * from './bip68.js';
 export * from './bitauth-script.js';
 export * from './data.js';
+export * from './fingerprint.js';
 export * from './hash.js';
 export * from './script.js';
 export * from './source-map.js';

package/dist/script.js

@@ -37,6 +37,8 @@ export function bytecodeToScript(bytecode) {
 export function asmToBytecode(asm) {
     // Remove any duplicate whitespace
     asm = asm.replace(/\s+/g, ' ').trim();
+    if (asm === '')
+        return new Uint8Array();
     // Convert the ASM tokens to AuthenticationInstructions
     const instructions = asm.split(' ').map((token) => {
         // Even though the OpcodesBch type allows for { [key: number]: string }, we know that the keys are always the opcodes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cashscript/utils",
-  "version": "0.13.0-next.6",
+  "version": "0.13.0-next.8",
   "description": "CashScript utilities and types",
   "keywords": [
     "bitcoin cash",
@@ -48,5 +48,5 @@
     "typescript": "^5.9.2",
     "vitest": "^4.0.15"
   },
-  "gitHead": "c204d0ccadc16bbce1206cf00c0960c254ce3af0"
+  "gitHead": "579998062f2f9c52393568b09b580407228cb79f"
 }