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

package/dist/{main/artifact.d.ts → artifact.d.ts}

@@ -1,3 +1,5 @@
+/// <reference types="node" />
+import { PathLike } from 'fs';
 export interface AbiInput {
     name: string;
     type: string;
@@ -19,5 +21,5 @@ export interface Artifact {
     };
     updatedAt: string;
 }
-export declare function importArtifact(artifactFile: string): Artifact;
+export declare function importArtifact(artifactFile: PathLike): Artifact;
 export declare function exportArtifact(artifact: Artifact, targetFile: string): void;

package/dist/{main/data.d.ts → data.d.ts}

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

package/dist/{module/data.js → data.js}

@@ -1,6 +1,6 @@
-import { bigIntToScriptNumber, parseBytesAsScriptNumber, isScriptNumberError, utf8ToBin, binToUtf8, } from '@bitauth/libauth';
+import { bigIntToVmNumber, utf8ToBin, binToUtf8, vmNumberToBigInt, isVmNumberError, } from '@bitauth/libauth';
 export function encodeBool(bool) {
-    return bool ? encodeInt(1) : encodeInt(0);
+    return bool ? encodeInt(1n) : encodeInt(0n);
 }
 export function decodeBool(encodedBool) {
     // Any encoding of 0 is false, else true
@@ -15,15 +15,15 @@ export function decodeBool(encodedBool) {
     return false;
 }
 export function encodeInt(int) {
-    return bigIntToScriptNumber(BigInt(int));
+    return bigIntToVmNumber(int);
 }
 export function decodeInt(encodedInt, maxLength = 8) {
-    const options = { maximumScriptNumberByteLength: maxLength };
-    const result = parseBytesAsScriptNumber(encodedInt, options);
-    if (isScriptNumberError(result)) {
+    const options = { maximumVmNumberByteLength: maxLength };
+    const result = vmNumberToBigInt(encodedInt, options);
+    if (isVmNumberError(result)) {
         throw new Error(result);
     }
-    return Number(result);
+    return result;
 }
 export function encodeString(str) {
     return utf8ToBin(str);

package/dist/{module/hash.js → hash.js}

@@ -1,3 +1,4 @@
+// TODO: Replace with libauth
 import hash from 'hash.js';
 export function sha512(payload) {
     return Uint8Array.from(hash.sha512().update(payload).digest());

package/dist/{main/script.d.ts → script.d.ts}

@@ -1,32 +1,7 @@
-import { OpcodesBCH } from '@bitauth/libauth';
-export declare const Op: typeof OpcodesBCH;
+export declare const Op: typeof import("@bitauth/libauth").OpcodesBCH2023;
 export declare type Op = number;
 export declare type OpOrData = Op | Uint8Array;
 export declare type Script = OpOrData[];
-export declare enum IntrospectionOp {
-    OP_INPUTINDEX = 192,
-    OP_ACTIVEBYTECODE = 193,
-    OP_TXVERSION = 194,
-    OP_TXINPUTCOUNT = 195,
-    OP_TXOUTPUTCOUNT = 196,
-    OP_TXLOCKTIME = 197,
-    OP_UTXOVALUE = 198,
-    OP_UTXOBYTECODE = 199,
-    OP_OUTPOINTTXHASH = 200,
-    OP_OUTPOINTINDEX = 201,
-    OP_INPUTBYTECODE = 202,
-    OP_INPUTSEQUENCENUMBER = 203,
-    OP_OUTPUTVALUE = 204,
-    OP_OUTPUTBYTECODE = 205,
-    OP_UTXOTOKENCATEGORY = 206,
-    OP_UTXOTOKENCOMMITMENT = 207,
-    OP_UTXOTOKENAMOUNT = 208,
-    OP_OUTPUTTOKENCATEGORY = 209,
-    OP_OUTPUTTOKENCOMMITMENT = 210,
-    OP_OUTPUTTOKENAMOUNT = 211
-}
-export declare const introspectionOpMapping: any;
-export declare const reverseIntrospectionOpMapping: any;
 export declare function scriptToAsm(script: Script): string;
 export declare function asmToScript(asm: string): Script;
 export declare function scriptToBytecode(script: Script): Uint8Array;

package/dist/{module/script.js → script.js}

@@ -1,54 +1,7 @@
-import { OpcodesBCH, encodeDataPush, parseBytecode, serializeAuthenticationInstructions, hexToBin, disassembleBytecodeBCH, flattenBinArray, } from '@bitauth/libauth';
+import { OpcodesBCH, encodeDataPush, hexToBin, disassembleBytecodeBCH, flattenBinArray, encodeAuthenticationInstructions, decodeAuthenticationInstructions, } from '@bitauth/libauth';
 import { decodeInt, encodeInt } from './data.js';
 import OptimisationsEquivFile from './cashproof-optimisations.js';
 export const Op = OpcodesBCH;
-// TODO: Replace this when these opcodes are in Libauth
-export var IntrospectionOp;
-(function (IntrospectionOp) {
-    IntrospectionOp[IntrospectionOp["OP_INPUTINDEX"] = 192] = "OP_INPUTINDEX";
-    IntrospectionOp[IntrospectionOp["OP_ACTIVEBYTECODE"] = 193] = "OP_ACTIVEBYTECODE";
-    IntrospectionOp[IntrospectionOp["OP_TXVERSION"] = 194] = "OP_TXVERSION";
-    IntrospectionOp[IntrospectionOp["OP_TXINPUTCOUNT"] = 195] = "OP_TXINPUTCOUNT";
-    IntrospectionOp[IntrospectionOp["OP_TXOUTPUTCOUNT"] = 196] = "OP_TXOUTPUTCOUNT";
-    IntrospectionOp[IntrospectionOp["OP_TXLOCKTIME"] = 197] = "OP_TXLOCKTIME";
-    IntrospectionOp[IntrospectionOp["OP_UTXOVALUE"] = 198] = "OP_UTXOVALUE";
-    IntrospectionOp[IntrospectionOp["OP_UTXOBYTECODE"] = 199] = "OP_UTXOBYTECODE";
-    IntrospectionOp[IntrospectionOp["OP_OUTPOINTTXHASH"] = 200] = "OP_OUTPOINTTXHASH";
-    IntrospectionOp[IntrospectionOp["OP_OUTPOINTINDEX"] = 201] = "OP_OUTPOINTINDEX";
-    IntrospectionOp[IntrospectionOp["OP_INPUTBYTECODE"] = 202] = "OP_INPUTBYTECODE";
-    IntrospectionOp[IntrospectionOp["OP_INPUTSEQUENCENUMBER"] = 203] = "OP_INPUTSEQUENCENUMBER";
-    IntrospectionOp[IntrospectionOp["OP_OUTPUTVALUE"] = 204] = "OP_OUTPUTVALUE";
-    IntrospectionOp[IntrospectionOp["OP_OUTPUTBYTECODE"] = 205] = "OP_OUTPUTBYTECODE";
-    IntrospectionOp[IntrospectionOp["OP_UTXOTOKENCATEGORY"] = 206] = "OP_UTXOTOKENCATEGORY";
-    IntrospectionOp[IntrospectionOp["OP_UTXOTOKENCOMMITMENT"] = 207] = "OP_UTXOTOKENCOMMITMENT";
-    IntrospectionOp[IntrospectionOp["OP_UTXOTOKENAMOUNT"] = 208] = "OP_UTXOTOKENAMOUNT";
-    IntrospectionOp[IntrospectionOp["OP_OUTPUTTOKENCATEGORY"] = 209] = "OP_OUTPUTTOKENCATEGORY";
-    IntrospectionOp[IntrospectionOp["OP_OUTPUTTOKENCOMMITMENT"] = 210] = "OP_OUTPUTTOKENCOMMITMENT";
-    IntrospectionOp[IntrospectionOp["OP_OUTPUTTOKENAMOUNT"] = 211] = "OP_OUTPUTTOKENAMOUNT";
-})(IntrospectionOp || (IntrospectionOp = {}));
-export const introspectionOpMapping = {
-    OP_INPUTINDEX: 'OP_UNKNOWN192',
-    OP_ACTIVEBYTECODE: 'OP_UNKNOWN193',
-    OP_TXVERSION: 'OP_UNKNOWN194',
-    OP_TXINPUTCOUNT: 'OP_UNKNOWN195',
-    OP_TXOUTPUTCOUNT: 'OP_UNKNOWN196',
-    OP_TXLOCKTIME: 'OP_UNKNOWN197',
-    OP_UTXOVALUE: 'OP_UNKNOWN198',
-    OP_UTXOBYTECODE: 'OP_UNKNOWN199',
-    OP_OUTPOINTTXHASH: 'OP_UNKNOWN200',
-    OP_OUTPOINTINDEX: 'OP_UNKNOWN201',
-    OP_INPUTBYTECODE: 'OP_UNKNOWN202',
-    OP_INPUTSEQUENCENUMBER: 'OP_UNKNOWN203',
-    OP_OUTPUTVALUE: 'OP_UNKNOWN204',
-    OP_OUTPUTBYTECODE: 'OP_UNKNOWN205',
-    OP_UTXOTOKENCATEGORY: 'OP_UNKNOWN206',
-    OP_UTXOTOKENCOMMITMENT: 'OP_UNKNOWN207',
-    OP_UTXOTOKENAMOUNT: 'OP_UNKNOWN208',
-    OP_OUTPUTTOKENCATEGORY: 'OP_UNKNOWN209',
-    OP_OUTPUTTOKENCOMMITMENT: 'OP_UNKNOWN210',
-    OP_OUTPUTTOKENAMOUNT: 'OP_UNKNOWN211',
-};
-export const reverseIntrospectionOpMapping = Object.fromEntries(Object.entries(introspectionOpMapping).map(([k, v]) => ([v, k])));
 export function scriptToAsm(script) {
     return bytecodeToAsm(scriptToBytecode(script));
 }
@@ -61,14 +14,14 @@ export function scriptToBytecode(script) {
         if (typeof opOrData === 'number') {
             return { opcode: opOrData };
         }
-        return parseBytecode(encodeDataPush(opOrData))[0];
+        return decodeAuthenticationInstructions(encodeDataPush(opOrData))[0];
     });
     // Convert the AuthenticationInstructions to bytecode
-    return serializeAuthenticationInstructions(instructions);
+    return encodeAuthenticationInstructions(instructions);
 }
 export function bytecodeToScript(bytecode) {
     // Convert the bytecode to AuthenticationInstructions
-    const instructions = parseBytecode(bytecode);
+    const instructions = decodeAuthenticationInstructions(bytecode);
     // Convert the AuthenticationInstructions to script elements
     const script = instructions.map((instruction) => ('data' in instruction ? instruction.data : instruction.opcode));
     return script;
@@ -76,17 +29,15 @@ export function bytecodeToScript(bytecode) {
 export function asmToBytecode(asm) {
     // Remove any duplicate whitespace
     asm = asm.replace(/\s+/g, ' ').trim();
-    // Replace introspection ops with OP_UNKNOWN... so Libauth gets it
-    asm = asm.split(' ').map((token) => { var _a; return (_a = introspectionOpMapping[token]) !== null && _a !== void 0 ? _a : token; }).join(' ');
     // Convert the ASM tokens to AuthenticationInstructions
     const instructions = asm.split(' ').map((token) => {
         if (token.startsWith('OP_')) {
             return { opcode: Op[token] };
         }
-        return parseBytecode(encodeDataPush(hexToBin(token)))[0];
+        return decodeAuthenticationInstructions(encodeDataPush(hexToBin(token)))[0];
     });
     // Convert the AuthenticationInstructions to bytecode
-    return serializeAuthenticationInstructions(instructions);
+    return encodeAuthenticationInstructions(instructions);
 }
 export function bytecodeToAsm(bytecode) {
     // Convert the bytecode to libauth's ASM format
@@ -95,8 +46,6 @@ export function bytecodeToAsm(bytecode) {
     asm = asm.replace(/OP_PUSHBYTES_[^\s]+/g, '');
     asm = asm.replace(/OP_PUSHDATA[^\s]+ [^\s]+/g, '');
     asm = asm.replace(/(^|\s)0x/g, ' ');
-    // Replace OP_UNKNOWN... with the correct ops
-    asm = asm.split(' ').map((token) => { var _a; return (_a = reverseIntrospectionOpMapping[token]) !== null && _a !== void 0 ? _a : token; }).join(' ');
     // Remove any duplicate whitespace
     asm = asm.replace(/\s+/g, ' ').trim();
     return asm;
@@ -150,7 +99,7 @@ export function replaceBytecodeNop(script) {
     // Retrieve size of current OP_SPLIT
     let oldCut = script[index];
     if (oldCut instanceof Uint8Array) {
-        oldCut = decodeInt(oldCut);
+        oldCut = Number(decodeInt(oldCut));
     }
     else if (oldCut === Op.OP_0) {
         oldCut = 0;
@@ -162,10 +111,10 @@ export function replaceBytecodeNop(script) {
         return script;
     }
     // Update the old OP_SPLIT by adding either 1 or 3 to it
-    script[index] = encodeInt(oldCut + 1);
+    script[index] = encodeInt(BigInt(oldCut + 1));
     const bytecodeSize = calculateBytesize(script);
     if (bytecodeSize > 252) {
-        script[index] = encodeInt(oldCut + 3);
+        script[index] = encodeInt(BigInt(oldCut + 3));
     }
     // Minimally encode
     return asmToScript(scriptToAsm(script));

package/dist/{module/types.js → types.js}

@@ -4,8 +4,7 @@ export class ArrayType {
         this.bound = bound;
     }
     toString() {
-        var _a;
-        return `${this.elementType}[${(_a = this.bound) !== null && _a !== void 0 ? _a : ''}]`;
+        return `${this.elementType}[${this.bound ?? ''}]`;
     }
 }
 export class BytesType {
@@ -17,8 +16,7 @@ export class BytesType {
         return new BytesType(bound);
     }
     toString() {
-        var _a;
-        return `bytes${(_a = this.bound) !== null && _a !== void 0 ? _a : ''}`;
+        return `bytes${this.bound ?? ''}`;
     }
 }
 export class TupleType {
@@ -41,9 +39,7 @@ export var PrimitiveType;
     PrimitiveType["ANY"] = "any";
 })(PrimitiveType || (PrimitiveType = {}));
 const ExplicitlyCastableTo = {
-    [PrimitiveType.INT]: [
-        PrimitiveType.INT, PrimitiveType.BOOL,
-    ],
+    [PrimitiveType.INT]: [PrimitiveType.INT, PrimitiveType.BOOL],
     [PrimitiveType.BOOL]: [PrimitiveType.BOOL, PrimitiveType.INT],
     [PrimitiveType.STRING]: [PrimitiveType.STRING],
     [PrimitiveType.PUBKEY]: [PrimitiveType.PUBKEY],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cashscript/utils",
-  "version": "0.8.0-next.0",
+  "version": "0.8.0-next.2",
   "description": "CashScript utilities and types",
   "keywords": [
     "bitcoin cash",
@@ -18,34 +18,36 @@
   },
   "license": "MIT",
   "author": "Rosco Kalis <roscokalis@gmail.com>",
-  "main": "dist/main/index",
-  "module": "dist/module/index",
-  "types": "dist/module/index",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
   "sideEffects": false,
   "directories": {
     "lib": "src",
     "test": "test"
   },
   "scripts": {
-    "build": "npm run clean && npm run compile",
+    "build": "yarn clean && yarn compile",
+    "build:test": "yarn clean:test && yarn compile:test",
     "clean": "rm -rf ./dist",
-    "compile": "npm run compile:main && npm run compile:module",
-    "compile:main": "tsc -p tsconfig.build.main.json",
-    "compile:module": "tsc -p tsconfig.build.module.json",
+    "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": "npm run build",
-    "prepublishOnly": "npm test && npm run lint",
-    "test": "jest --config=../../jest.config.js packages/utils"
+    "prepare": "yarn build",
+    "prepublishOnly": "yarn test && yarn lint",
+    "pretest": "yarn build:test",
+    "test": "NODE_OPTIONS='--experimental-vm-modules --no-warnings' jest"
   },
   "dependencies": {
-    "@bitauth/libauth": "^1.18.1",
+    "@bitauth/libauth": "^2.0.0-alpha.8",
     "hash.js": "^1.1.7"
   },
   "devDependencies": {
+    "@jest/globals": "^29.4.1",
     "eslint": "^7.20.0",
-    "jest": "^26.6.3",
-    "ts-jest": "^26.5.1",
+    "jest": "^29.4.1",
     "typescript": "^4.1.5"
   },
-  "gitHead": "18d793bbb5aa4aef1a07587cd1565ae2a63b0728"
+  "gitHead": "37bcb8e924fc56ef8da2cb2a2640eb5478de39b2"
 }

package/dist/main/artifact.js

@@ -1,17 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.exportArtifact = exports.importArtifact = void 0;
-const fs_1 = __importDefault(require("fs"));
-function importArtifact(artifactFile) {
-    return JSON.parse(fs_1.default.readFileSync(artifactFile, { encoding: 'utf-8' }));
-}
-exports.importArtifact = importArtifact;
-function exportArtifact(artifact, targetFile) {
-    const jsonString = JSON.stringify(artifact, null, 2);
-    fs_1.default.writeFileSync(targetFile, jsonString);
-}
-exports.exportArtifact = exportArtifact;
-//# sourceMappingURL=artifact.js.map

package/dist/main/cashproof-optimisations.js

@@ -1,127 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = `
-# This file can be run with CashProof to prove that the optimisations preserve exact functionality
-# This includes most of CashScript's bytecode optimisations, although some are incompatible with CashProof
-
-# Hardcoded arithmetic
-# OP_NOT OP_IF                         <=> OP_NOTIF;
-OP_1 OP_ADD                            <=> OP_1ADD;
-OP_1 OP_SUB                            <=> OP_1SUB;
-OP_1 OP_NEGATE                         <=> OP_1NEGATE;
-OP_0 OP_EQUAL 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_CHECKMULTISIG OP_VERIFY           <=> OP_CHECKMULTISIGVERIFY;
-OP_CHECKDATASIG OP_VERIFY              <=> OP_CHECKDATASIGVERIFY;
-
-# Remove/replace extraneous OP_SWAP
-# OP_SWAP OP_AND                         <=> OP_AND;
-# OP_SWAP OP_OR                          <=> OP_OR;
-# OP_SWAP OP_XOR                         <=> OP_XOR;
-OP_SWAP OP_ADD                         <=> OP_ADD;
-OP_SWAP OP_EQUAL                       <=> OP_EQUAL;
-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_AND                         <=> ;
-# OP_DUP OP_OR                          <=> ;
-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_15 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;
-`;
-//# sourceMappingURL=cashproof-optimisations.js.map

package/dist/main/data.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.placeholder = exports.decodeString = exports.encodeString = exports.decodeInt = exports.encodeInt = exports.decodeBool = exports.encodeBool = void 0;
-const libauth_1 = require("@bitauth/libauth");
-function encodeBool(bool) {
-    return bool ? encodeInt(1) : encodeInt(0);
-}
-exports.encodeBool = encodeBool;
-function decodeBool(encodedBool) {
-    // Any encoding of 0 is false, else true
-    for (let i = 0; i < encodedBool.byteLength; i += 1) {
-        if (encodedBool[i] !== 0) {
-            // Can be negative zero
-            if (i === encodedBool.byteLength - 1 && encodedBool[i] === 0x80)
-                return false;
-            return true;
-        }
-    }
-    return false;
-}
-exports.decodeBool = decodeBool;
-function encodeInt(int) {
-    return (0, libauth_1.bigIntToScriptNumber)(BigInt(int));
-}
-exports.encodeInt = encodeInt;
-function decodeInt(encodedInt, maxLength = 8) {
-    const options = { maximumScriptNumberByteLength: maxLength };
-    const result = (0, libauth_1.parseBytesAsScriptNumber)(encodedInt, options);
-    if ((0, libauth_1.isScriptNumberError)(result)) {
-        throw new Error(result);
-    }
-    return Number(result);
-}
-exports.decodeInt = decodeInt;
-function encodeString(str) {
-    return (0, libauth_1.utf8ToBin)(str);
-}
-exports.encodeString = encodeString;
-function decodeString(encodedString) {
-    return (0, libauth_1.binToUtf8)(encodedString);
-}
-exports.decodeString = decodeString;
-function placeholder(size) {
-    return new Uint8Array(size).fill(0);
-}
-exports.placeholder = placeholder;
-//# sourceMappingURL=data.js.map

package/dist/main/hash.js

@@ -1,28 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hash256 = exports.hash160 = exports.ripemd160 = exports.sha256 = exports.sha512 = void 0;
-const hash_js_1 = __importDefault(require("hash.js"));
-function sha512(payload) {
-    return Uint8Array.from(hash_js_1.default.sha512().update(payload).digest());
-}
-exports.sha512 = sha512;
-function sha256(payload) {
-    return Uint8Array.from(hash_js_1.default.sha256().update(payload).digest());
-}
-exports.sha256 = sha256;
-function ripemd160(payload) {
-    return Uint8Array.from(hash_js_1.default.ripemd160().update(payload).digest());
-}
-exports.ripemd160 = ripemd160;
-function hash160(payload) {
-    return ripemd160(sha256(payload));
-}
-exports.hash160 = hash160;
-function hash256(payload) {
-    return sha256(sha256(payload));
-}
-exports.hash256 = hash256;
-//# sourceMappingURL=hash.js.map

package/dist/main/index.js

@@ -1,22 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./artifact.js"), exports);
-__exportStar(require("./data.js"), exports);
-__exportStar(require("./hash.js"), exports);
-__exportStar(require("./script.js"), exports);
-__exportStar(require("./types.js"), exports);
-//# sourceMappingURL=index.js.map

package/dist/main/script.js

@@ -1,237 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.optimiseBytecode = exports.generateRedeemScript = exports.replaceBytecodeNop = exports.encodeNullDataScript = exports.calculateBytesize = exports.countOpcodes = exports.bytecodeToAsm = exports.asmToBytecode = exports.bytecodeToScript = exports.scriptToBytecode = exports.asmToScript = exports.scriptToAsm = exports.reverseIntrospectionOpMapping = exports.introspectionOpMapping = exports.IntrospectionOp = exports.Op = void 0;
-const libauth_1 = require("@bitauth/libauth");
-const data_js_1 = require("./data.js");
-const cashproof_optimisations_js_1 = __importDefault(require("./cashproof-optimisations.js"));
-exports.Op = libauth_1.OpcodesBCH;
-// TODO: Replace this when these opcodes are in Libauth
-var IntrospectionOp;
-(function (IntrospectionOp) {
-    IntrospectionOp[IntrospectionOp["OP_INPUTINDEX"] = 192] = "OP_INPUTINDEX";
-    IntrospectionOp[IntrospectionOp["OP_ACTIVEBYTECODE"] = 193] = "OP_ACTIVEBYTECODE";
-    IntrospectionOp[IntrospectionOp["OP_TXVERSION"] = 194] = "OP_TXVERSION";
-    IntrospectionOp[IntrospectionOp["OP_TXINPUTCOUNT"] = 195] = "OP_TXINPUTCOUNT";
-    IntrospectionOp[IntrospectionOp["OP_TXOUTPUTCOUNT"] = 196] = "OP_TXOUTPUTCOUNT";
-    IntrospectionOp[IntrospectionOp["OP_TXLOCKTIME"] = 197] = "OP_TXLOCKTIME";
-    IntrospectionOp[IntrospectionOp["OP_UTXOVALUE"] = 198] = "OP_UTXOVALUE";
-    IntrospectionOp[IntrospectionOp["OP_UTXOBYTECODE"] = 199] = "OP_UTXOBYTECODE";
-    IntrospectionOp[IntrospectionOp["OP_OUTPOINTTXHASH"] = 200] = "OP_OUTPOINTTXHASH";
-    IntrospectionOp[IntrospectionOp["OP_OUTPOINTINDEX"] = 201] = "OP_OUTPOINTINDEX";
-    IntrospectionOp[IntrospectionOp["OP_INPUTBYTECODE"] = 202] = "OP_INPUTBYTECODE";
-    IntrospectionOp[IntrospectionOp["OP_INPUTSEQUENCENUMBER"] = 203] = "OP_INPUTSEQUENCENUMBER";
-    IntrospectionOp[IntrospectionOp["OP_OUTPUTVALUE"] = 204] = "OP_OUTPUTVALUE";
-    IntrospectionOp[IntrospectionOp["OP_OUTPUTBYTECODE"] = 205] = "OP_OUTPUTBYTECODE";
-    IntrospectionOp[IntrospectionOp["OP_UTXOTOKENCATEGORY"] = 206] = "OP_UTXOTOKENCATEGORY";
-    IntrospectionOp[IntrospectionOp["OP_UTXOTOKENCOMMITMENT"] = 207] = "OP_UTXOTOKENCOMMITMENT";
-    IntrospectionOp[IntrospectionOp["OP_UTXOTOKENAMOUNT"] = 208] = "OP_UTXOTOKENAMOUNT";
-    IntrospectionOp[IntrospectionOp["OP_OUTPUTTOKENCATEGORY"] = 209] = "OP_OUTPUTTOKENCATEGORY";
-    IntrospectionOp[IntrospectionOp["OP_OUTPUTTOKENCOMMITMENT"] = 210] = "OP_OUTPUTTOKENCOMMITMENT";
-    IntrospectionOp[IntrospectionOp["OP_OUTPUTTOKENAMOUNT"] = 211] = "OP_OUTPUTTOKENAMOUNT";
-})(IntrospectionOp = exports.IntrospectionOp || (exports.IntrospectionOp = {}));
-exports.introspectionOpMapping = {
-    OP_INPUTINDEX: 'OP_UNKNOWN192',
-    OP_ACTIVEBYTECODE: 'OP_UNKNOWN193',
-    OP_TXVERSION: 'OP_UNKNOWN194',
-    OP_TXINPUTCOUNT: 'OP_UNKNOWN195',
-    OP_TXOUTPUTCOUNT: 'OP_UNKNOWN196',
-    OP_TXLOCKTIME: 'OP_UNKNOWN197',
-    OP_UTXOVALUE: 'OP_UNKNOWN198',
-    OP_UTXOBYTECODE: 'OP_UNKNOWN199',
-    OP_OUTPOINTTXHASH: 'OP_UNKNOWN200',
-    OP_OUTPOINTINDEX: 'OP_UNKNOWN201',
-    OP_INPUTBYTECODE: 'OP_UNKNOWN202',
-    OP_INPUTSEQUENCENUMBER: 'OP_UNKNOWN203',
-    OP_OUTPUTVALUE: 'OP_UNKNOWN204',
-    OP_OUTPUTBYTECODE: 'OP_UNKNOWN205',
-    OP_UTXOTOKENCATEGORY: 'OP_UNKNOWN206',
-    OP_UTXOTOKENCOMMITMENT: 'OP_UNKNOWN207',
-    OP_UTXOTOKENAMOUNT: 'OP_UNKNOWN208',
-    OP_OUTPUTTOKENCATEGORY: 'OP_UNKNOWN209',
-    OP_OUTPUTTOKENCOMMITMENT: 'OP_UNKNOWN210',
-    OP_OUTPUTTOKENAMOUNT: 'OP_UNKNOWN211',
-};
-exports.reverseIntrospectionOpMapping = Object.fromEntries(Object.entries(exports.introspectionOpMapping).map(([k, v]) => ([v, k])));
-function scriptToAsm(script) {
-    return bytecodeToAsm(scriptToBytecode(script));
-}
-exports.scriptToAsm = scriptToAsm;
-function asmToScript(asm) {
-    return bytecodeToScript(asmToBytecode(asm));
-}
-exports.asmToScript = asmToScript;
-function scriptToBytecode(script) {
-    // Convert the script elements to AuthenticationInstructions
-    const instructions = script.map((opOrData) => {
-        if (typeof opOrData === 'number') {
-            return { opcode: opOrData };
-        }
-        return (0, libauth_1.parseBytecode)((0, libauth_1.encodeDataPush)(opOrData))[0];
-    });
-    // Convert the AuthenticationInstructions to bytecode
-    return (0, libauth_1.serializeAuthenticationInstructions)(instructions);
-}
-exports.scriptToBytecode = scriptToBytecode;
-function bytecodeToScript(bytecode) {
-    // Convert the bytecode to AuthenticationInstructions
-    const instructions = (0, libauth_1.parseBytecode)(bytecode);
-    // Convert the AuthenticationInstructions to script elements
-    const script = instructions.map((instruction) => ('data' in instruction ? instruction.data : instruction.opcode));
-    return script;
-}
-exports.bytecodeToScript = bytecodeToScript;
-function asmToBytecode(asm) {
-    // Remove any duplicate whitespace
-    asm = asm.replace(/\s+/g, ' ').trim();
-    // Replace introspection ops with OP_UNKNOWN... so Libauth gets it
-    asm = asm.split(' ').map((token) => { var _a; return (_a = exports.introspectionOpMapping[token]) !== null && _a !== void 0 ? _a : token; }).join(' ');
-    // Convert the ASM tokens to AuthenticationInstructions
-    const instructions = asm.split(' ').map((token) => {
-        if (token.startsWith('OP_')) {
-            return { opcode: exports.Op[token] };
-        }
-        return (0, libauth_1.parseBytecode)((0, libauth_1.encodeDataPush)((0, libauth_1.hexToBin)(token)))[0];
-    });
-    // Convert the AuthenticationInstructions to bytecode
-    return (0, libauth_1.serializeAuthenticationInstructions)(instructions);
-}
-exports.asmToBytecode = asmToBytecode;
-function bytecodeToAsm(bytecode) {
-    // Convert the bytecode to libauth's ASM format
-    let asm = (0, libauth_1.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/g, ' ');
-    // Replace OP_UNKNOWN... with the correct ops
-    asm = asm.split(' ').map((token) => { var _a; return (_a = exports.reverseIntrospectionOpMapping[token]) !== null && _a !== void 0 ? _a : token; }).join(' ');
-    // Remove any duplicate whitespace
-    asm = asm.replace(/\s+/g, ' ').trim();
-    return asm;
-}
-exports.bytecodeToAsm = bytecodeToAsm;
-function countOpcodes(script) {
-    return script
-        .filter((opOrData) => typeof opOrData === 'number')
-        .filter((op) => op > exports.Op.OP_16)
-        .length;
-}
-exports.countOpcodes = countOpcodes;
-function calculateBytesize(script) {
-    return scriptToBytecode(script).byteLength;
-}
-exports.calculateBytesize = calculateBytesize;
-// For encoding OP_RETURN data (doesn't require BIP62.3 / MINIMALDATA)
-function encodeNullDataScript(chunks) {
-    return (0, libauth_1.flattenBinArray)(chunks.map((chunk) => {
-        if (typeof chunk === 'number') {
-            return new Uint8Array([chunk]);
-        }
-        const pushdataOpcode = getPushDataOpcode(chunk);
-        return new Uint8Array([...pushdataOpcode, ...chunk]);
-    }));
-}
-exports.encodeNullDataScript = encodeNullDataScript;
-function getPushDataOpcode(data) {
-    const { byteLength } = data;
-    if (byteLength === 0)
-        return Uint8Array.from([0x4c, 0x00]);
-    if (byteLength < 76)
-        return Uint8Array.from([byteLength]);
-    if (byteLength < 256)
-        return Uint8Array.from([0x4c, byteLength]);
-    throw Error('Pushdata too large');
-}
-/**
- * When cutting out the tx.bytecode preimage variable, the compiler does not know
- * the size of the final redeem scrip yet, because the constructor parameters still
- * need to get added. Because of this it does not know whether the VarInt is 1 or 3
- * bytes. During compilation, an OP_NOP is added at the spot where the bytecode is
- * cut out. This function replaces that OP_NOP and adds either 1 or 3 to the cut to
- * additionally cut off the VarInt.
- *
- * @param script incomplete redeem script
- * @returns completed redeem script
- */
-function replaceBytecodeNop(script) {
-    const index = script.findIndex((op) => op === exports.Op.OP_NOP);
-    if (index < 0)
-        return script;
-    // Remove the OP_NOP
-    script.splice(index, 1);
-    // Retrieve size of current OP_SPLIT
-    let oldCut = script[index];
-    if (oldCut instanceof Uint8Array) {
-        oldCut = (0, data_js_1.decodeInt)(oldCut);
-    }
-    else if (oldCut === exports.Op.OP_0) {
-        oldCut = 0;
-    }
-    else if (oldCut >= exports.Op.OP_1 && oldCut <= exports.Op.OP_16) {
-        oldCut -= 80;
-    }
-    else {
-        return script;
-    }
-    // Update the old OP_SPLIT by adding either 1 or 3 to it
-    script[index] = (0, data_js_1.encodeInt)(oldCut + 1);
-    const bytecodeSize = calculateBytesize(script);
-    if (bytecodeSize > 252) {
-        script[index] = (0, data_js_1.encodeInt)(oldCut + 3);
-    }
-    // Minimally encode
-    return asmToScript(scriptToAsm(script));
-}
-exports.replaceBytecodeNop = replaceBytecodeNop;
-function generateRedeemScript(baseScript, encodedArgs) {
-    return replaceBytecodeNop([...encodedArgs, ...baseScript]);
-}
-exports.generateRedeemScript = generateRedeemScript;
-function optimiseBytecode(script, runs = 1000) {
-    const optimisations = cashproof_optimisations_js_1.default
-        // Split by line and filter all line comments (#)
-        .split('\n')
-        .map((equiv) => equiv.trim())
-        .filter((equiv) => !equiv.startsWith('#'))
-        // Join back the lines, and split on semicolon
-        .join('')
-        .split(';')
-        // Parse all optimisations in .equiv file
-        .map((equiv) => equiv.trim())
-        .map((equiv) => equiv.split('<=>').map((part) => part.trim()))
-        .filter((equiv) => equiv.length === 2);
-    for (let i = 0; i < runs; i += 1) {
-        const oldScript = script;
-        script = replaceOps(script, optimisations);
-        // Break on fixed point
-        if (scriptToAsm(oldScript) === scriptToAsm(script))
-            break;
-    }
-    return script;
-}
-exports.optimiseBytecode = optimiseBytecode;
-function replaceOps(script, optimisations) {
-    let asm = scriptToAsm(script);
-    // Apply all optimisations in the cashproof file
-    optimisations.forEach(([pattern, replacement]) => {
-        asm = asm.replace(new RegExp(pattern, 'g'), replacement);
-    });
-    // Add optimisations that are not compatible with CashProof
-    // CashProof can't prove OP_IF without parameters
-    asm = asm.replace(/OP_NOT OP_IF/g, 'OP_NOTIF');
-    // CashProof can't prove OP_CHECKMULTISIG without specifying N
-    asm = asm.replace(/OP_CHECKMULTISIG OP_VERIFY/g, 'OP_CHECKMULTISIGVERIFY');
-    // CashProof can't prove bitwise operators
-    asm = asm.replace(/OP_SWAP OP_AND/g, 'OP_AND');
-    asm = asm.replace(/OP_SWAP OP_OR/g, 'OP_OR');
-    asm = asm.replace(/OP_SWAP OP_XOR/g, 'OP_XOR');
-    asm = asm.replace(/OP_DUP OP_AND/g, '');
-    asm = asm.replace(/OP_DUP OP_OR/g, '');
-    // Remove any double spaces as a result of opcode removal
-    asm = asm.replace(/\s+/g, ' ').trim();
-    return asmToScript(asm);
-}
-//# sourceMappingURL=script.js.map

package/dist/main/types.js

@@ -1,192 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isPrimitive = exports.parseType = exports.implicitlyCastableSignature = exports.arrayType = exports.resultingType = exports.implicitlyCastable = exports.explicitlyCastable = exports.PrimitiveType = exports.TupleType = exports.BytesType = exports.ArrayType = void 0;
-class ArrayType {
-    constructor(elementType, bound) {
-        this.elementType = elementType;
-        this.bound = bound;
-    }
-    toString() {
-        var _a;
-        return `${this.elementType}[${(_a = this.bound) !== null && _a !== void 0 ? _a : ''}]`;
-    }
-}
-exports.ArrayType = ArrayType;
-class BytesType {
-    constructor(bound) {
-        this.bound = bound;
-    }
-    static fromString(str) {
-        const bound = str === 'byte' ? 1 : Number.parseInt(str.substring(5), 10) || undefined;
-        return new BytesType(bound);
-    }
-    toString() {
-        var _a;
-        return `bytes${(_a = this.bound) !== null && _a !== void 0 ? _a : ''}`;
-    }
-}
-exports.BytesType = BytesType;
-class TupleType {
-    constructor(elementType) {
-        this.elementType = elementType;
-    }
-    toString() {
-        return `(${this.elementType}, ${this.elementType})`;
-    }
-}
-exports.TupleType = TupleType;
-var PrimitiveType;
-(function (PrimitiveType) {
-    PrimitiveType["INT"] = "int";
-    PrimitiveType["BOOL"] = "bool";
-    PrimitiveType["STRING"] = "string";
-    // ADDRESS = 'address',
-    PrimitiveType["PUBKEY"] = "pubkey";
-    PrimitiveType["SIG"] = "sig";
-    PrimitiveType["DATASIG"] = "datasig";
-    PrimitiveType["ANY"] = "any";
-})(PrimitiveType = exports.PrimitiveType || (exports.PrimitiveType = {}));
-const ExplicitlyCastableTo = {
-    [PrimitiveType.INT]: [
-        PrimitiveType.INT, PrimitiveType.BOOL,
-    ],
-    [PrimitiveType.BOOL]: [PrimitiveType.BOOL, PrimitiveType.INT],
-    [PrimitiveType.STRING]: [PrimitiveType.STRING],
-    [PrimitiveType.PUBKEY]: [PrimitiveType.PUBKEY],
-    [PrimitiveType.SIG]: [PrimitiveType.SIG],
-    [PrimitiveType.DATASIG]: [PrimitiveType.DATASIG],
-    [PrimitiveType.ANY]: [],
-};
-function explicitlyCastable(from, to) {
-    if (!from || !to)
-        return false;
-    // Tuples can't be cast
-    if (from instanceof TupleType || to instanceof TupleType)
-        return false;
-    // Arrays can be cast if their elements can be cast (don't think this is actually used ever)
-    if (from instanceof ArrayType && to instanceof ArrayType) {
-        return explicitlyCastable(from.elementType, to.elementType);
-    }
-    // Can't cast between Array and non-Array
-    if (from instanceof ArrayType || to instanceof ArrayType)
-        return false;
-    if (to instanceof BytesType) {
-        // Can't cast bool to bytes
-        if (from === PrimitiveType.BOOL)
-            return false;
-        // Can cast int to any size bytes
-        if (from === PrimitiveType.INT)
-            return true;
-        // Can freely cast to unbounded bytes
-        if (!to.bound)
-            return true;
-        if (from instanceof BytesType) {
-            // Can freely cast from unbounded bytes
-            if (!from.bound)
-                return true;
-            // Can only cast bounded bytes to bounded bytes if bounds are equal
-            return from.bound === to.bound;
-        }
-        // Cannot cast other primitive types directly to bounded bytes types
-        return false;
-    }
-    if (from instanceof BytesType) {
-        // Can cast unbounded bytes or <=4 bytes to int
-        if (to === PrimitiveType.INT)
-            return !from.bound || from.bound <= 8;
-        // Can't cast bytes to bool or string
-        if (to === PrimitiveType.BOOL)
-            return false;
-        if (to === PrimitiveType.STRING)
-            return false;
-        // Can cast any bytes to pubkey, sig, datasig
-        if (to === PrimitiveType.PUBKEY)
-            return true;
-        if (to === PrimitiveType.SIG)
-            return true;
-        if (to === PrimitiveType.DATASIG)
-            return true;
-        return true;
-    }
-    return ExplicitlyCastableTo[from].includes(to);
-}
-exports.explicitlyCastable = explicitlyCastable;
-function implicitlyCastable(actual, expected) {
-    if (!actual || !expected)
-        return false;
-    // Tuples can't be cast
-    if (actual instanceof TupleType || expected instanceof TupleType)
-        return false;
-    // Arrays can be cast if their elements can be cast (don't think this is actually used ever)
-    if (actual instanceof ArrayType && expected instanceof ArrayType) {
-        return implicitlyCastable(actual.elementType, expected.elementType);
-    }
-    // Can't cast between Array and non-Array
-    if (actual instanceof ArrayType || expected instanceof ArrayType)
-        return false;
-    // Anything can be implicitly cast to ANY
-    if (expected === PrimitiveType.ANY)
-        return true;
-    if (expected instanceof BytesType) {
-        // Can't implicitly cast bool, int, string to bytes
-        if (actual === PrimitiveType.BOOL)
-            return false;
-        if (actual === PrimitiveType.INT)
-            return false;
-        if (actual === PrimitiveType.STRING)
-            return false;
-        // Can freely cast to unbounded bytes
-        if (!expected.bound)
-            return true;
-        if (actual instanceof BytesType) {
-            // Cannot implicitly cast from unbounded bytes
-            if (!actual.bound)
-                return false;
-            // Can only cast bounded bytes to bounded bytes if bounds are equal
-            return actual.bound === expected.bound;
-        }
-        // Cannot cast other primitive types directly to bounded bytes types
-        return false;
-    }
-    // Other primitive types can only be implicitly cast to themselves
-    return actual === expected;
-}
-exports.implicitlyCastable = implicitlyCastable;
-function resultingType(left, right) {
-    if (implicitlyCastable(left, right))
-        return right;
-    if (implicitlyCastable(right, left))
-        return left;
-    if (left instanceof BytesType && right instanceof BytesType) {
-        return new BytesType();
-    }
-    return undefined;
-}
-exports.resultingType = resultingType;
-function arrayType(types) {
-    if (types.length === 0)
-        return undefined;
-    let resType = types[0];
-    types.forEach((t) => {
-        resType = resultingType(resType, t);
-    });
-    return resType;
-}
-exports.arrayType = arrayType;
-function implicitlyCastableSignature(actual, expected) {
-    if (actual.length !== expected.length)
-        return false;
-    return expected.every((t, i) => implicitlyCastable(actual[i], t));
-}
-exports.implicitlyCastableSignature = implicitlyCastableSignature;
-function parseType(str) {
-    if (str.startsWith('byte'))
-        return BytesType.fromString(str);
-    return PrimitiveType[str.toUpperCase()];
-}
-exports.parseType = parseType;
-function isPrimitive(type) {
-    return !!PrimitiveType[type.toString().toUpperCase()];
-}
-exports.isPrimitive = isPrimitive;
-//# sourceMappingURL=types.js.map

package/dist/module/artifact.d.ts

@@ -1,23 +0,0 @@
-export interface AbiInput {
-    name: string;
-    type: string;
-}
-export interface AbiFunction {
-    name: string;
-    covenant?: boolean;
-    inputs: AbiInput[];
-}
-export interface Artifact {
-    contractName: string;
-    constructorInputs: AbiInput[];
-    abi: AbiFunction[];
-    bytecode: string;
-    source: string;
-    compiler: {
-        name: string;
-        version: string;
-    };
-    updatedAt: string;
-}
-export declare function importArtifact(artifactFile: string): Artifact;
-export declare function exportArtifact(artifact: Artifact, targetFile: string): void;

package/dist/module/cashproof-optimisations.d.ts

@@ -1,2 +0,0 @@
-declare const _default: "\n# This file can be run with CashProof to prove that the optimisations preserve exact functionality\n# This includes most of CashScript's bytecode optimisations, although some are incompatible with CashProof\n\n# Hardcoded arithmetic\n# OP_NOT OP_IF                         <=> OP_NOTIF;\nOP_1 OP_ADD                            <=> OP_1ADD;\nOP_1 OP_SUB                            <=> OP_1SUB;\nOP_1 OP_NEGATE                         <=> OP_1NEGATE;\nOP_0 OP_EQUAL OP_NOT                   <=> OP_0NOTEQUAL;\nOP_NUMEQUAL OP_NOT                     <=> OP_NUMNOTEQUAL;\nOP_SHA256 OP_SHA256                    <=> OP_HASH256;\nOP_SHA256 OP_RIPEMD160                 <=> OP_HASH160;\n\n# Hardcoded stack ops\nOP_2 OP_PICK OP_1 OP_PICK OP_3 OP_PICK <=> OP_3DUP OP_SWAP;\nOP_2 OP_PICK OP_2 OP_PICK OP_2 OP_PICK <=> OP_3DUP;\n\nOP_0 OP_PICK OP_2 OP_PICK              <=> OP_2DUP OP_SWAP;\nOP_2 OP_PICK OP_4 OP_PICK              <=> OP_2OVER OP_SWAP;\nOP_3 OP_PICK OP_3 OP_PICK              <=> OP_2OVER;\n\nOP_2 OP_ROLL OP_3 OP_ROLL              <=> OP_2SWAP OP_SWAP;\nOP_3 OP_ROLL OP_3 OP_ROLL              <=> OP_2SWAP;\nOP_4 OP_ROLL OP_5 OP_ROLL              <=> OP_2ROT OP_SWAP;\nOP_5 OP_ROLL OP_5 OP_ROLL              <=> OP_2ROT;\n\nOP_0 OP_PICK                           <=> OP_DUP;\nOP_1 OP_PICK                           <=> OP_OVER;\nOP_0 OP_ROLL                           <=> ;\nOP_1 OP_ROLL                           <=> OP_SWAP;\nOP_2 OP_ROLL                           <=> OP_ROT;\nOP_DROP OP_DROP                        <=> OP_2DROP;\n\n# Secondary effects\nOP_DUP OP_SWAP                         <=> OP_DUP;\nOP_SWAP OP_SWAP                        <=> ;\nOP_2SWAP OP_2SWAP                      <=> ;\nOP_ROT OP_ROT OP_ROT                   <=> ;\nOP_2ROT OP_2ROT OP_2ROT                <=> ;\nOP_OVER OP_OVER                        <=> OP_2DUP;\nOP_DUP OP_DROP                         <=> ;\nOP_DUP OP_NIP                          <=> ;\n\n# Enabling secondary effects\nOP_DUP OP_OVER                         <=> OP_DUP OP_DUP;\n\n# Merge OP_VERIFY\nOP_EQUAL OP_VERIFY                     <=> OP_EQUALVERIFY;\nOP_NUMEQUAL OP_VERIFY                  <=> OP_NUMEQUALVERIFY;\nOP_CHECKSIG OP_VERIFY                  <=> OP_CHECKSIGVERIFY;\n# OP_CHECKMULTISIG OP_VERIFY           <=> OP_CHECKMULTISIGVERIFY;\nOP_CHECKDATASIG OP_VERIFY              <=> OP_CHECKDATASIGVERIFY;\n\n# Remove/replace extraneous OP_SWAP\n# OP_SWAP OP_AND                         <=> OP_AND;\n# OP_SWAP OP_OR                          <=> OP_OR;\n# OP_SWAP OP_XOR                         <=> OP_XOR;\nOP_SWAP OP_ADD                         <=> OP_ADD;\nOP_SWAP OP_EQUAL                       <=> OP_EQUAL;\nOP_SWAP OP_NUMEQUAL                    <=> OP_NUMEQUAL;\nOP_SWAP OP_NUMNOTEQUAL                 <=> OP_NUMNOTEQUAL;\nOP_SWAP OP_GREATERTHANOREQUAL          <=> OP_LESSTHANOREQUAL;\nOP_SWAP OP_LESSTHANOREQUAL             <=> OP_GREATERTHANOREQUAL;\nOP_SWAP OP_GREATERTHAN                 <=> OP_LESSTHAN;\nOP_SWAP OP_LESSTHAN                    <=> OP_GREATERTHAN;\nOP_SWAP OP_DROP                        <=> OP_NIP;\nOP_SWAP OP_NIP                         <=> OP_DROP;\n\n# Remove/replace extraneous OP_DUP\n# OP_DUP OP_AND                         <=> ;\n# OP_DUP OP_OR                          <=> ;\nOP_DUP OP_DROP                        <=> ;\nOP_DUP OP_NIP                         <=> ;\n\n# Random optimisations (don't know what I'm targeting with this)\nOP_2DUP OP_DROP                        <=> OP_OVER;\nOP_2DUP OP_NIP                         <=> OP_DUP;\nOP_CAT OP_DROP                         <=> OP_2DROP;\nOP_NIP OP_DROP                         <=> OP_2DROP;\n\n# Far-fetched stuff\nOP_DUP OP_ROT OP_SWAP OP_DROP          <=> OP_SWAP;\nOP_OVER OP_ROT OP_SWAP OP_DROP         <=> OP_SWAP;\nOP_2 OP_PICK OP_ROT OP_SWAP OP_DROP    <=> OP_SWAP;\nOP_3 OP_PICK OP_ROT OP_SWAP OP_DROP    <=> OP_SWAP;\nOP_4 OP_PICK OP_ROT OP_SWAP OP_DROP    <=> OP_SWAP;\nOP_5 OP_PICK OP_ROT OP_SWAP OP_DROP    <=> OP_SWAP;\nOP_6 OP_PICK OP_ROT OP_SWAP OP_DROP    <=> OP_SWAP;\nOP_7 OP_PICK OP_ROT OP_SWAP OP_DROP    <=> OP_SWAP;\nOP_8 OP_PICK OP_ROT OP_SWAP OP_DROP    <=> OP_SWAP;\nOP_9 OP_PICK OP_ROT OP_SWAP OP_DROP    <=> OP_SWAP;\nOP_10 OP_PICK OP_ROT OP_SWAP OP_DROP   <=> OP_SWAP;\nOP_11 OP_PICK OP_ROT OP_SWAP OP_DROP   <=> OP_SWAP;\nOP_12 OP_PICK OP_ROT OP_SWAP OP_DROP   <=> OP_SWAP;\nOP_13 OP_PICK OP_ROT OP_SWAP OP_DROP   <=> OP_SWAP;\nOP_14 OP_PICK OP_ROT OP_SWAP OP_DROP   <=> OP_SWAP;\nOP_15 OP_PICK OP_ROT OP_SWAP OP_DROP   <=> OP_SWAP;\nOP_16 OP_PICK OP_ROT OP_SWAP OP_DROP   <=> OP_SWAP;\n\nOP_DUP OP_ROT OP_DROP                  <=> OP_NIP OP_DUP;\nOP_OVER OP_ROT OP_DROP                 <=> OP_SWAP;\nOP_2 OP_PICK OP_ROT OP_DROP            <=> OP_NIP OP_OVER;\n\nOP_0 OP_NIP                            <=> OP_DROP OP_0;\nOP_1 OP_NIP                            <=> OP_DROP OP_1;\nOP_2 OP_NIP                            <=> OP_DROP OP_2;\nOP_3 OP_NIP                            <=> OP_DROP OP_3;\nOP_4 OP_NIP                            <=> OP_DROP OP_4;\nOP_5 OP_NIP                            <=> OP_DROP OP_5;\nOP_6 OP_NIP                            <=> OP_DROP OP_6;\nOP_7 OP_NIP                            <=> OP_DROP OP_7;\nOP_8 OP_NIP                            <=> OP_DROP OP_8;\nOP_9 OP_NIP                            <=> OP_DROP OP_9;\nOP_10 OP_NIP                           <=> OP_DROP OP_10;\nOP_11 OP_NIP                           <=> OP_DROP OP_11;\nOP_12 OP_NIP                           <=> OP_DROP OP_12;\nOP_13 OP_NIP                           <=> OP_DROP OP_13;\nOP_14 OP_NIP                           <=> OP_DROP OP_14;\nOP_15 OP_NIP                           <=> OP_DROP OP_15;\nOP_16 OP_NIP                           <=> OP_DROP OP_16;\n\nOP_2 OP_PICK OP_SWAP OP_2 OP_PICK OP_NIP <=> OP_DROP OP_2DUP;\n";
-export default _default;

package/dist/module/data.d.ts

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

package/dist/module/hash.d.ts

@@ -1,5 +0,0 @@
-export declare function sha512(payload: Uint8Array): Uint8Array;
-export declare function sha256(payload: Uint8Array): Uint8Array;
-export declare function ripemd160(payload: Uint8Array): Uint8Array;
-export declare function hash160(payload: Uint8Array): Uint8Array;
-export declare function hash256(payload: Uint8Array): Uint8Array;

package/dist/module/index.d.ts

@@ -1,5 +0,0 @@
-export * from './artifact.js';
-export * from './data.js';
-export * from './hash.js';
-export * from './script.js';
-export * from './types.js';

package/dist/module/script.d.ts

@@ -1,52 +0,0 @@
-import { OpcodesBCH } from '@bitauth/libauth';
-export declare const Op: typeof OpcodesBCH;
-export declare type Op = number;
-export declare type OpOrData = Op | Uint8Array;
-export declare type Script = OpOrData[];
-export declare enum IntrospectionOp {
-    OP_INPUTINDEX = 192,
-    OP_ACTIVEBYTECODE = 193,
-    OP_TXVERSION = 194,
-    OP_TXINPUTCOUNT = 195,
-    OP_TXOUTPUTCOUNT = 196,
-    OP_TXLOCKTIME = 197,
-    OP_UTXOVALUE = 198,
-    OP_UTXOBYTECODE = 199,
-    OP_OUTPOINTTXHASH = 200,
-    OP_OUTPOINTINDEX = 201,
-    OP_INPUTBYTECODE = 202,
-    OP_INPUTSEQUENCENUMBER = 203,
-    OP_OUTPUTVALUE = 204,
-    OP_OUTPUTBYTECODE = 205,
-    OP_UTXOTOKENCATEGORY = 206,
-    OP_UTXOTOKENCOMMITMENT = 207,
-    OP_UTXOTOKENAMOUNT = 208,
-    OP_OUTPUTTOKENCATEGORY = 209,
-    OP_OUTPUTTOKENCOMMITMENT = 210,
-    OP_OUTPUTTOKENAMOUNT = 211
-}
-export declare const introspectionOpMapping: any;
-export declare const reverseIntrospectionOpMapping: any;
-export declare function scriptToAsm(script: Script): string;
-export declare function asmToScript(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 countOpcodes(script: Script): number;
-export declare function calculateBytesize(script: Script): number;
-export declare function encodeNullDataScript(chunks: OpOrData[]): Uint8Array;
-/**
- * When cutting out the tx.bytecode preimage variable, the compiler does not know
- * the size of the final redeem scrip yet, because the constructor parameters still
- * need to get added. Because of this it does not know whether the VarInt is 1 or 3
- * bytes. During compilation, an OP_NOP is added at the spot where the bytecode is
- * cut out. This function replaces that OP_NOP and adds either 1 or 3 to the cut to
- * additionally cut off the VarInt.
- *
- * @param script incomplete redeem script
- * @returns completed redeem script
- */
-export declare function replaceBytecodeNop(script: Script): Script;
-export declare function generateRedeemScript(baseScript: Script, encodedArgs: Script): Script;
-export declare function optimiseBytecode(script: Script, runs?: number): Script;

package/dist/module/types.d.ts

@@ -1,34 +0,0 @@
-export declare type Type = PrimitiveType | ArrayType | TupleType | BytesType;
-export declare class ArrayType {
-    elementType: Type;
-    bound?: number | undefined;
-    constructor(elementType: Type, bound?: number | undefined);
-    toString(): string;
-}
-export declare class BytesType {
-    bound?: number | undefined;
-    constructor(bound?: number | undefined);
-    static fromString(str: string): BytesType;
-    toString(): string;
-}
-export declare class TupleType {
-    elementType?: Type | undefined;
-    constructor(elementType?: Type | undefined);
-    toString(): string;
-}
-export declare enum PrimitiveType {
-    INT = "int",
-    BOOL = "bool",
-    STRING = "string",
-    PUBKEY = "pubkey",
-    SIG = "sig",
-    DATASIG = "datasig",
-    ANY = "any"
-}
-export declare function explicitlyCastable(from?: Type, to?: Type): boolean;
-export declare function implicitlyCastable(actual?: Type, expected?: Type): boolean;
-export declare function resultingType(left?: Type, right?: Type): Type | undefined;
-export declare function arrayType(types: Type[]): Type | undefined;
-export declare function implicitlyCastableSignature(actual: Type[], expected: Type[]): boolean;
-export declare function parseType(str: string): Type;
-export declare function isPrimitive(type: Type): type is PrimitiveType;