cashscript 0.9.2 → 0.10.0-next.0

package/dist/{Contract.d.ts → src/Contract.d.ts}

@@ -4,7 +4,8 @@ import { Argument } from './Argument.js';
 import { Unlocker, ContractOptions, Utxo } from './interfaces.js';
 import NetworkProvider from './network/NetworkProvider.js';
 export declare class Contract {
-    private artifact;
+    artifact: Artifact;
+    constructorArgs: Argument[];
     private options?;
     name: string;
     address: string;
@@ -16,7 +17,7 @@ export declare class Contract {
     unlock: Record<string, ContractUnlocker>;
     redeemScript: Script;
     provider: NetworkProvider;
-    private addressType;
+    addressType: 'p2sh20' | 'p2sh32';
     constructor(artifact: Artifact, constructorArgs: Argument[], options?: ContractOptions | undefined);
     getBalance(): Promise<bigint>;
     getUtxos(): Promise<Utxo[]>;

package/dist/{Contract.js → src/Contract.js}

@@ -8,6 +8,7 @@ import { ElectrumNetworkProvider } from './network/index.js';
 export class Contract {
     constructor(artifact, constructorArgs, options) {
         this.artifact = artifact;
+        this.constructorArgs = constructorArgs;
         this.options = options;
         this.provider = this.options?.provider ?? new ElectrumNetworkProvider();
         this.addressType = this.options?.addressType ?? 'p2sh32';

package/dist/{Errors.d.ts → src/Errors.d.ts}

@@ -10,8 +10,8 @@ export declare class TokensToNonTokenAddressError extends Error {
 }
 export declare class FailedTransactionError extends Error {
     reason: string;
-    meep?: string | undefined;
-    constructor(reason: string, meep?: string | undefined);
+    debugStr?: string | undefined;
+    constructor(reason: string, debugStr?: string | undefined);
 }
 export declare class FailedRequireError extends FailedTransactionError {
 }

package/dist/{Errors.js → src/Errors.js}

@@ -14,10 +14,10 @@ export class TokensToNonTokenAddressError extends Error {
     }
 }
 export class FailedTransactionError extends Error {
-    constructor(reason, meep) {
-        super(`Transaction failed with reason: ${reason}${meep ? `\n${meep}` : ''}`);
+    constructor(reason, debugStr) {
+        super(`Transaction failed with reason: ${reason}${debugStr ? `\n\n${debugStr}` : ''}`);
         this.reason = reason;
-        this.meep = meep;
+        this.debugStr = debugStr;
     }
 }
 export class FailedRequireError extends FailedTransactionError {

package/dist/src/LibauthTemplate.d.ts

@@ -0,0 +1,12 @@
+import { Artifact } from '@cashscript/utils';
+import { AuthenticationTemplate, AuthenticationProgramStateBCHCHIPs } from '@bitauth/libauth';
+import { Transaction } from './Transaction.js';
+export declare const stringify: (any: any, spaces?: number | undefined) => string;
+export declare const buildTemplate: ({ transaction, transactionHex, }: {
+    transaction: Transaction;
+    transactionHex?: string | undefined;
+}) => Promise<AuthenticationTemplate>;
+export declare const getBitauthUri: (template: AuthenticationTemplate) => string;
+export declare const evaluateTemplate: (template: AuthenticationTemplate) => boolean;
+export declare type DebugResult = AuthenticationProgramStateBCHCHIPs[];
+export declare const debugTemplate: (template: AuthenticationTemplate, artifact: Artifact) => DebugResult;

package/dist/src/LibauthTemplate.js

@@ -0,0 +1,472 @@
+import { Op, PrimitiveType, bytecodeToScript, decodeBool, decodeInt, decodeString, formatLibauthScript, } from '@cashscript/utils';
+import { hash160, hexToBin, decodeTransaction, binToHex, authenticationTemplateToCompilerConfiguration, createCompiler, createVirtualMachineBCHCHIPs, binToBase64, utf8ToBin, isHex, AuthenticationErrorCommon, } from '@bitauth/libauth';
+import { deflate } from 'pako';
+import { isUtxoP2PKH, } from '../src/interfaces.js';
+import { encodeArgument as csEncodeArgument } from './Argument.js';
+import { toRegExp } from './utils.js';
+// all bitauth variables must be in snake case
+const snakeCase = (str) => (str
+    && str
+        .match(/[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g)
+        .map((s) => s.toLowerCase())
+        .join('_'));
+const merge = (array) => array.reduce((prev, cur) => ({
+    ...prev,
+    ...{ [Object.keys(cur)[0]]: cur[Object.keys(cur)[0]] },
+}), {});
+const encodeArgument = (argument, typeStr) => {
+    if (typeStr === PrimitiveType.INT && argument === 0n) {
+        return Uint8Array.from([0]);
+    }
+    return csEncodeArgument(argument, typeStr);
+};
+// stringify version which can serialize otherwise unsupported types
+export const stringify = (any, spaces) => JSON.stringify(any, (_, v) => {
+    if (typeof v === 'bigint') {
+        return `${v.toString()}`;
+    }
+    if (v instanceof Uint8Array) {
+        return `${binToHex(v)}`;
+    }
+    return v;
+}, spaces);
+const zip = (a, b) => Array.from(Array(Math.max(b.length, a.length)), (_, i) => [a[i], b[i]]);
+const createScenarioTransaction = (libauthTransaction, csTransaction) => {
+    const contract = csTransaction.contract;
+    const result = {};
+    // only one 'slot' is allowed, otherwise {} must be used
+    let inputSlotInserted = false;
+    result.inputs = libauthTransaction.inputs.map((input, index) => {
+        const csInput = csTransaction.inputs[index];
+        const signable = isUtxoP2PKH(csInput);
+        let unlockingBytecode = {};
+        if (signable) {
+            unlockingBytecode = {
+                script: 'p2pkh_placeholder_unlock',
+                overrides: {
+                    keys: {
+                        privateKeys: {
+                            placeholder_key: binToHex(csInput.template.privateKey),
+                        },
+                    },
+                },
+            };
+        }
+        else {
+            // assume it is our contract's input
+            // eslint-disable-next-line
+            if (!inputSlotInserted) {
+                unlockingBytecode = ['slot'];
+                inputSlotInserted = true;
+            }
+        }
+        return {
+            outpointIndex: input.outpointIndex,
+            outpointTransactionHash: input.outpointTransactionHash instanceof Uint8Array
+                ? binToHex(input.outpointTransactionHash)
+                : input.outpointTransactionHash,
+            sequenceNumber: input.sequenceNumber,
+            unlockingBytecode,
+        };
+    });
+    result.locktime = libauthTransaction.locktime;
+    result.outputs = libauthTransaction.outputs.map((output, index) => {
+        const csOutput = csTransaction.outputs[index];
+        let { lockingBytecode } = output;
+        if (typeof csOutput.to === 'string') {
+            if ([
+                contract.address,
+                contract.tokenAddress,
+            ].includes(csOutput.to)) {
+                lockingBytecode = {};
+            }
+            else {
+                for (const csInput of csTransaction.inputs) {
+                    if (isUtxoP2PKH(csInput)) {
+                        const inputPkh = hash160(csInput.template.getPublicKey());
+                        if (binToHex(output.lockingBytecode).slice(6, 46)
+                            === binToHex(inputPkh)) {
+                            lockingBytecode = {
+                                script: 'p2pkh_placeholder_lock',
+                                overrides: {
+                                    keys: {
+                                        privateKeys: {
+                                            placeholder_key: binToHex(csInput.template.privateKey),
+                                        },
+                                    },
+                                },
+                            };
+                        }
+                    }
+                }
+            }
+        }
+        return {
+            lockingBytecode: lockingBytecode instanceof Uint8Array
+                ? binToHex(lockingBytecode)
+                : lockingBytecode,
+            token: output.token,
+            valueSatoshis: Number(output.valueSatoshis),
+        };
+    });
+    result.version = libauthTransaction.version;
+    return result;
+};
+const createScenarioSourceOutputs = (csTransaction) => {
+    // only one 'slot' is allowed, otherwise {} must be used
+    let inputSlotInserted = false;
+    return csTransaction.inputs.map((csInput) => {
+        const signable = isUtxoP2PKH(csInput);
+        let lockingBytecode = {};
+        if (signable) {
+            lockingBytecode = {
+                script: 'p2pkh_placeholder_lock',
+                overrides: {
+                    keys: {
+                        privateKeys: {
+                            placeholder_key: binToHex(csInput.template.privateKey),
+                        },
+                    },
+                },
+            };
+        }
+        else {
+            // assume it is our contract's input
+            // eslint-disable-next-line
+            if (!inputSlotInserted) {
+                lockingBytecode = ['slot'];
+                inputSlotInserted = true;
+            }
+        }
+        const result = {
+            lockingBytecode: lockingBytecode,
+            valueSatoshis: Number(csInput.satoshis),
+        };
+        if (csInput.token) {
+            result.token = {
+                amount: csInput.token.amount.toString(),
+                category: csInput.token.category,
+            };
+            if (csInput.token.nft) {
+                result.token.nft = {
+                    capability: csInput.token.nft.capability,
+                    commitment: csInput.token.nft.commitment
+                };
+            }
+        }
+        return result;
+    });
+};
+export const buildTemplate = async ({ transaction, transactionHex = undefined, // set this argument to prevent unnecessary call `transaction.build()`
+ }) => {
+    const contract = transaction.contract;
+    const txHex = transactionHex ?? await transaction.build();
+    const libauthTransaction = decodeTransaction(hexToBin(txHex));
+    if (typeof libauthTransaction === 'string') {
+        throw Error(libauthTransaction);
+    }
+    const constructorInputs = contract.artifact.constructorInputs
+        .slice()
+        .reverse();
+    const contractParameters = contract.constructorArgs.slice().reverse();
+    const abiFunction = transaction.abiFunction;
+    const funcName = abiFunction.name;
+    const functionIndex = contract.artifact.abi.findIndex((func) => func.name === funcName);
+    const func = contract.artifact.abi[functionIndex];
+    const functionInputs = func.inputs.slice().reverse();
+    const args = transaction.args.slice().reverse();
+    const hasSignatureTemplates = transaction.inputs.filter((input) => isUtxoP2PKH(input)).length;
+    const formattedBytecode = contract.artifact.debug
+        ? formatLibauthScript(bytecodeToScript(hexToBin(contract.artifact.debug.bytecode)), contract.artifact.debug.sourceMap, contract.artifact.source).split('\n')
+        : contract.artifact.bytecode.split(' ').map((asmElement) => {
+            if (isHex(asmElement)) {
+                return `<0x${asmElement}>`;
+            }
+            return asmElement;
+        });
+    const template = {
+        $schema: 'https://ide.bitauth.com/authentication-template-v0.schema.json',
+        description: `Imported from cashscript`,
+        name: contract.artifact.contractName,
+        supported: ['BCH_SPEC'],
+        version: 0,
+    };
+    // declaration of template variables and their types
+    template.entities = {
+        parameters: {
+            description: 'Contract creation and function parameters',
+            name: 'parameters',
+            scripts: [
+                'lock',
+                'unlock_lock',
+            ],
+            variables: merge([
+                ...functionInputs.map((input) => ({
+                    [snakeCase(input.name)]: {
+                        description: `"${input.name}" parameter of function "${func.name}"`,
+                        name: input.name,
+                        type: input.type === PrimitiveType.SIG ? 'Key' : 'WalletData',
+                    },
+                })),
+                {
+                    function_index: {
+                        description: 'Script function index to execute',
+                        name: 'function_index',
+                        type: 'WalletData',
+                    },
+                },
+                ...constructorInputs.map((input) => ({
+                    [snakeCase(input.name)]: {
+                        description: `"${input.name}" parameter of this contract`,
+                        name: input.name,
+                        type: 'WalletData',
+                    },
+                })),
+            ]),
+        }
+    };
+    // add extra variables for the p2pkh utxos spent together with our contract
+    if (hasSignatureTemplates) {
+        template.entities.parameters.scripts.push('p2pkh_placeholder_lock', 'p2pkh_placeholder_unlock');
+        template.entities.parameters.variables = {
+            ...template.entities.parameters.variables,
+            placeholder_key: {
+                description: 'placeholder_key',
+                name: 'placeholder_key',
+                type: 'Key',
+            },
+        };
+    }
+    template.scenarios = {
+        // single scenario to spend out transaction under test given the CashScript parameters provided
+        evaluate_function: {
+            name: 'Evaluate',
+            description: 'An example evaluation where this script execution passes.',
+            data: {
+                // encode values for the variables defined above in `entities` property
+                bytecode: merge([
+                    ...zip(functionInputs, args)
+                        .filter(([input]) => input.type !== PrimitiveType.SIG)
+                        .map(([input, arg]) => {
+                        const hex = binToHex(arg);
+                        const result = hex.length ? `0x${hex}` : hex;
+                        return {
+                            [snakeCase(input.name)]: result,
+                        };
+                    }),
+                    { function_index: functionIndex.toString() },
+                    ...constructorInputs.map((input, index) => {
+                        const hex = binToHex(encodeArgument(contractParameters[index], constructorInputs[index].type));
+                        const result = hex.length ? `0x${hex}` : hex;
+                        return {
+                            [snakeCase(input.name)]: result,
+                        };
+                    }),
+                ]),
+                currentBlockHeight: 2,
+                currentBlockTime: Math.round(+new Date() / 1000),
+                keys: {
+                    privateKeys: merge([
+                        ...zip(functionInputs, args)
+                            .filter(([input]) => input.type === PrimitiveType.SIG)
+                            .map(([input, arg]) => ({
+                            [snakeCase(input.name)]: binToHex(arg.privateKey),
+                        })),
+                        ...(hasSignatureTemplates
+                            ? [
+                                {
+                                    // placeholder will be replaced by a key for each respective P2PKH input spent
+                                    placeholder_key: '<Uint8Array: 0x0000000000000000000000000000000000000000000000000000000000000000>',
+                                },
+                            ]
+                            : []),
+                    ]),
+                },
+            },
+            transaction: createScenarioTransaction(libauthTransaction, transaction),
+            sourceOutputs: createScenarioSourceOutputs(transaction),
+        },
+    };
+    // definition of locking scripts and unlocking scripts with their respective bytecode
+    template.scripts = {
+        unlock_lock: {
+            // this unlocking script must pass our only scenario
+            passes: ['evaluate_function'],
+            name: 'unlock',
+            // unlocking script contains the CashScript function parameters and function selector
+            // we output these values as pushdata, comment will contain the type and the value of the variable
+            // example: '<timeout> // int = <0xa08601>'
+            script: [
+                `// "${func.name}" function parameters`,
+                ...(functionInputs.length
+                    ? zip(functionInputs, args).map(([input, arg]) => (input.type === PrimitiveType.SIG
+                        ? `<${snakeCase(input.name)}.schnorr_signature.all_outputs> // ${input.type}`
+                        : `<${snakeCase(input.name)}> // ${input.type} = <${`0x${binToHex(arg)}`}>`))
+                    : ['// none']),
+                '',
+                ...(contract.artifact.abi.length > 1
+                    ? [
+                        '// function index in contract',
+                        `<function_index> // int = <${functionIndex.toString()}>`,
+                        '',
+                    ]
+                    : []),
+            ].join('\n'),
+            unlocks: 'lock',
+        },
+        lock: {
+            lockingType: "p2sh20",
+            name: 'lock',
+            // locking script contains the CashScript contract parameters followed by the contract opcodes
+            // we output these values as pushdata, comment will contain the type and the value of the variable
+            // example: '<timeout> // int = <0xa08601>'
+            script: [
+                `// "${contract.artifact.contractName}" contract constructor parameters`,
+                ...(constructorInputs.length
+                    ? constructorInputs.map((input, index) => {
+                        const encoded = encodeArgument(contractParameters[index], constructorInputs[index].type);
+                        return `<${snakeCase(input.name)}> // ${input.type === 'bytes' ? `bytes${encoded.length}` : input.type} = <${`0x${binToHex(encoded)}`}>`;
+                    })
+                    : ['// none']),
+                '',
+                '// bytecode',
+                ...formattedBytecode,
+            ].join('\n'),
+        },
+    };
+    // add extra unlocking and locking script for P2PKH inputs spent alongside our contract
+    // this is needed for correct cross-referrences in the template
+    if (hasSignatureTemplates) {
+        template.scripts.p2pkh_placeholder_unlock = {
+            name: 'p2pkh_placeholder_unlock',
+            script: '<placeholder_key.schnorr_signature.all_outputs>\n<placeholder_key.public_key>',
+            unlocks: 'p2pkh_placeholder_lock',
+        };
+        template.scripts.p2pkh_placeholder_lock = {
+            lockingType: 'standard',
+            name: 'p2pkh_placeholder_lock',
+            script: 'OP_DUP\nOP_HASH160 <$(<placeholder_key.public_key> OP_HASH160\n)> OP_EQUALVERIFY\nOP_CHECKSIG',
+        };
+    }
+    return template;
+};
+export const getBitauthUri = (template) => {
+    const base64toBase64Url = (base64) => base64.replace(/\+/g, '-').replace(/\//g, '_');
+    const payload = base64toBase64Url(binToBase64(deflate(utf8ToBin(stringify(template)))));
+    return `https://ide.bitauth.com/import-template/${payload}`;
+};
+// internal util. instantiates the virtual machine and compiles the template into a program
+const createProgram = (template) => {
+    const configuration = authenticationTemplateToCompilerConfiguration(template);
+    const vm = createVirtualMachineBCHCHIPs();
+    const compiler = createCompiler(configuration);
+    const scenarioGeneration = compiler.generateScenario({
+        debug: true,
+        lockingScriptId: undefined,
+        unlockingScriptId: 'unlock_lock',
+        scenarioId: 'evaluate_function',
+    });
+    if (typeof scenarioGeneration === 'string'
+        || typeof scenarioGeneration.scenario === 'string') {
+        // eslint-disable-next-line
+        throw scenarioGeneration;
+    }
+    return { vm, program: scenarioGeneration.scenario.program };
+};
+// evaluates the fully defined template, throws upon error
+export const evaluateTemplate = (template) => {
+    const { vm, program } = createProgram(template);
+    const verifyResult = vm.verify(program);
+    if (typeof verifyResult === 'string') {
+        // eslint-disable-next-line
+        throw verifyResult;
+    }
+    return verifyResult;
+};
+// debugs the template, optionally logging the execution data
+export const debugTemplate = (template, artifact) => {
+    const { vm, program } = createProgram(template);
+    const debugResult = vm.debug(program);
+    for (const log of artifact.debug?.logs ?? []) {
+        // there might be 2 elements with same instruction pointer, first from unllocking script, second from locking
+        const state = debugResult
+            .filter((debugState) => debugState.ip === log.ip)
+            .slice().reverse()[0];
+        if (!state) {
+            throw Error(`Instruction pointer ${log.ip} points to a non-existing state of the program`);
+        }
+        let line = `${artifact.contractName}.cash:${log.line}`;
+        log.data.forEach((element) => {
+            let value;
+            if (typeof element === 'string') {
+                value = element;
+            }
+            else {
+                const stackItem = state.stack.slice().reverse()[element.stackIndex];
+                if (!stackItem) {
+                    throw Error(`Stack item at index ${element.stackIndex} not found at instruction pointer ${log.ip}`);
+                }
+                switch (element.type) {
+                    case PrimitiveType.BOOL:
+                        value = decodeBool(stackItem);
+                        break;
+                    case PrimitiveType.INT:
+                        value = decodeInt(stackItem);
+                        break;
+                    case PrimitiveType.STRING:
+                        value = decodeString(stackItem);
+                        break;
+                    default:
+                        value = `0x${binToHex(stackItem)}`;
+                        break;
+                }
+            }
+            line += ` ${value}`;
+        });
+        // actual log, do not delete :)
+        console.log(line);
+    }
+    const lastState = debugResult[debugResult.length - 1];
+    if (lastState.error) {
+        const requireMessage = (artifact.debug?.requireMessages ?? []).filter((message) => message.ip === lastState.ip)[0];
+        if (requireMessage) {
+            // eslint-disable-next-line
+            throw `${artifact.contractName}.cash:${requireMessage.line} Error in evaluating input index ${lastState.program.inputIndex} with the following message: ${requireMessage.message}.
+${lastState.error}`;
+        }
+        else {
+            // eslint-disable-next-line
+            throw `Error in evaluating input index ${lastState.program.inputIndex}.
+${lastState.error}`;
+        }
+    }
+    else {
+        // one last pass of verifications not covered by the above debugging
+        // checks for removed final verify
+        const evaluationResult = vm.verify(program);
+        if (typeof evaluationResult === 'string' && toRegExp([
+            AuthenticationErrorCommon.requiresCleanStack,
+            AuthenticationErrorCommon.nonEmptyControlStack,
+            AuthenticationErrorCommon.unsuccessfulEvaluation,
+        ]).test(evaluationResult)) {
+            const stackContents = lastState.stack.map(item => `0x${binToHex(item)}`).join(', ');
+            const stackContentsMessage = `\nStack contents after evaluation: ${lastState.stack.length ? stackContents : 'empty'}`;
+            const lastMessage = artifact.debug?.requireMessages.sort((a, b) => b.ip - a.ip)[0];
+            if (!lastMessage) {
+                // eslint-disable-next-line
+                throw evaluationResult + stackContentsMessage;
+            }
+            const instructionsLeft = lastState.instructions.slice(lastMessage.ip);
+            if (instructionsLeft.length === 0
+                || instructionsLeft.every(instruction => [Op.OP_NIP, Op.OP_ENDIF].includes(instruction.opcode))) {
+                // eslint-disable-next-line
+                throw `${artifact.contractName}.cash:${lastMessage.line} Error in evaluating input index ${lastState.program.inputIndex} with the following message: ${lastMessage.message}.
+${evaluationResult.replace(/Error in evaluating input index \d: /, '')}` + stackContentsMessage;
+            }
+            // eslint-disable-next-line
+            throw evaluationResult + stackContentsMessage;
+        }
+    }
+    return debugResult;
+};
+//# sourceMappingURL=LibauthTemplate.js.map

package/dist/{SignatureTemplate.d.ts → src/SignatureTemplate.d.ts}

@@ -2,7 +2,7 @@ import { Unlocker, HashType, SignatureAlgorithm } from './interfaces.js';
 export default class SignatureTemplate {
     private hashtype;
     private signatureAlgorithm;
-    private privateKey;
+    privateKey: Uint8Array;
     constructor(signer: Keypair | Uint8Array | string, hashtype?: HashType, signatureAlgorithm?: SignatureAlgorithm);
     generateSignature(payload: Uint8Array, bchForkId?: boolean): Uint8Array;
     getHashType(bchForkId?: boolean): number;

package/dist/{Transaction.d.ts → src/Transaction.d.ts}

@@ -1,15 +1,16 @@
 import { AbiFunction } from '@cashscript/utils';
-import { Utxo, Recipient, TokenDetails, TransactionDetails, Unlocker } from './interfaces.js';
+import { Utxo, Output, Recipient, TokenDetails, TransactionDetails, Unlocker } from './interfaces.js';
 import SignatureTemplate from './SignatureTemplate.js';
 import { Contract } from './Contract.js';
+import { DebugResult } from './LibauthTemplate.js';
 export declare class Transaction {
-    private contract;
+    contract: Contract;
     private unlocker;
-    private abiFunction;
-    private args;
+    abiFunction: AbiFunction;
+    args: (Uint8Array | SignatureTemplate)[];
     private selector?;
-    private inputs;
-    private outputs;
+    inputs: Utxo[];
+    outputs: Output[];
     private sequence;
     private locktime;
     private feePerByte;
@@ -34,7 +35,8 @@ export declare class Transaction {
     build(): Promise<string>;
     send(): Promise<TransactionDetails>;
     send(raw: true): Promise<string>;
+    debug(): Promise<DebugResult>;
+    bitauthUri(): Promise<string>;
     private getTxDetails;
-    meep(): Promise<string>;
     private setInputsAndOutputs;
 }

package/dist/{Transaction.js → src/Transaction.js}

@@ -4,10 +4,12 @@ import delay from 'delay';
 import { placeholder, scriptToBytecode, } from '@cashscript/utils';
 import deepEqual from 'fast-deep-equal';
 import { isUtxoP2PKH, } from './interfaces.js';
-import { meep, createInputScript, getInputSize, createOpReturnOutput, getTxSizeWithoutInputs, getPreimageSize, buildError, validateOutput, utxoComparator, calculateDust, getOutputSize, utxoTokenComparator, } from './utils.js';
+import { createInputScript, getInputSize, createOpReturnOutput, getTxSizeWithoutInputs, getPreimageSize, buildError, validateOutput, utxoComparator, calculateDust, getOutputSize, utxoTokenComparator, } from './utils.js';
 import SignatureTemplate from './SignatureTemplate.js';
 import { P2PKH_INPUT_SIZE } from './constants.js';
 import { TransactionBuilder } from './TransactionBuilder.js';
+import MockNetworkProvider from './network/MockNetworkProvider.js';
+import { buildTemplate, debugTemplate, evaluateTemplate, getBitauthUri, } from './LibauthTemplate.js';
 export class Transaction {
     constructor(contract, unlocker, abiFunction, args, selector) {
         this.contract = contract;
@@ -98,15 +100,56 @@ export class Transaction {
     }
     async send(raw) {
         const tx = await this.build();
+        let template;
         try {
+            if (this.contract.provider instanceof MockNetworkProvider) {
+                template = await buildTemplate({
+                    transaction: this,
+                    transactionHex: tx,
+                });
+                evaluateTemplate(template);
+            }
             const txid = await this.contract.provider.sendRawTransaction(tx);
             return raw ? await this.getTxDetails(txid, raw) : await this.getTxDetails(txid);
         }
-        catch (e) {
-            const reason = e.error ?? e.message;
-            throw buildError(reason, meep(tx, this.inputs, this.contract.redeemScript));
+        catch (maybeNodeError) {
+            if (!template) {
+                template = await buildTemplate({
+                    transaction: this,
+                    transactionHex: tx,
+                });
+            }
+            const reason = maybeNodeError.error ?? maybeNodeError.message ?? maybeNodeError;
+            const bitauthUri = getBitauthUri(template);
+            try {
+                debugTemplate(template, this.contract.artifact);
+            }
+            catch (libauthError) {
+                if (this.contract.provider instanceof MockNetworkProvider) {
+                    throw buildError(libauthError, bitauthUri);
+                }
+                else {
+                    const message = `${libauthError}\n\nUnderlying node error: ${reason}`;
+                    throw buildError(message, bitauthUri);
+                }
+            }
+            // this must be unreachable
+            throw buildError(reason, bitauthUri);
         }
     }
+    // method to debug the transaction with libauth VM, throws upon evaluation error
+    async debug() {
+        const template = await buildTemplate({
+            transaction: this,
+        });
+        return debugTemplate(template, this.contract.artifact);
+    }
+    async bitauthUri() {
+        const template = await buildTemplate({
+            transaction: this,
+        });
+        return getBitauthUri(template);
+    }
     async getTxDetails(txid, raw) {
         for (let retries = 0; retries < 1200; retries += 1) {
             await delay(500);
@@ -124,10 +167,6 @@ export class Transaction {
         // Should not happen
         throw new Error('Could not retrieve transaction details for over 10 minutes');
     }
-    async meep() {
-        const tx = await this.build();
-        return meep(tx, this.inputs, this.contract.redeemScript);
-    }
     async setInputsAndOutputs() {
         if (this.outputs.length === 0) {
             throw Error('Attempted to build a transaction without outputs');

package/dist/{index.d.ts → src/index.d.ts}

@@ -8,4 +8,5 @@ export { Artifact, AbiFunction, AbiInput } from '@cashscript/utils';
 export * as utils from '@cashscript/utils';
 export * from './interfaces.js';
 export * from './Errors.js';
-export { NetworkProvider, BitcoinRpcNetworkProvider, ElectrumNetworkProvider, FullStackNetworkProvider, } from './network/index.js';
+export { NetworkProvider, BitcoinRpcNetworkProvider, ElectrumNetworkProvider, FullStackNetworkProvider, MockNetworkProvider, } from './network/index.js';
+export { randomUtxo, randomToken, randomNFT } from './utils.js';

package/dist/{index.js → src/index.js}

@@ -7,5 +7,6 @@ export { encodeArgument } from './Argument.js';
 export * as utils from '@cashscript/utils';
 export * from './interfaces.js';
 export * from './Errors.js';
-export { BitcoinRpcNetworkProvider, ElectrumNetworkProvider, FullStackNetworkProvider, } from './network/index.js';
+export { BitcoinRpcNetworkProvider, ElectrumNetworkProvider, FullStackNetworkProvider, MockNetworkProvider, } from './network/index.js';
+export { randomUtxo, randomToken, randomNFT } from './utils.js';
 //# sourceMappingURL=index.js.map

package/dist/{interfaces.d.ts → src/interfaces.d.ts}

@@ -1,4 +1,4 @@
-import type { Transaction } from '@bitauth/libauth';
+import { type Transaction } from '@bitauth/libauth';
 import type { NetworkProvider } from './network/index.js';
 import type SignatureTemplate from './SignatureTemplate.js';
 export interface Utxo {

package/dist/src/network/MockNetworkProvider.d.ts

@@ -0,0 +1,14 @@
+import { Utxo, Network } from '../interfaces.js';
+import NetworkProvider from './NetworkProvider.js';
+export default class MockNetworkProvider implements NetworkProvider {
+    private utxoMap;
+    private transactionMap;
+    network: Network;
+    constructor();
+    getUtxos(address: string): Promise<Utxo[]>;
+    getBlockHeight(): Promise<number>;
+    getRawTransaction(txid: string): Promise<string>;
+    sendRawTransaction(txHex: string): Promise<string>;
+    addUtxo(address: string, utxo: Utxo): void;
+    reset(): void;
+}

package/dist/src/network/MockNetworkProvider.js

@@ -0,0 +1,46 @@
+import { binToHex, hexToBin } from '@bitauth/libauth';
+import { sha256 } from '@cashscript/utils';
+import { Network } from '../interfaces.js';
+import { randomUtxo } from '../utils.js';
+// redeclare the addresses from vars.ts instead of importing them
+const aliceAddress = 'bchtest:qpgjmwev3spwlwkgmyjrr2s2cvlkkzlewq62mzgjnp';
+const bobAddress = 'bchtest:qz6q5gqnxdldkr07xpls5474mmzmlesd6qnux4skuc';
+const carolAddress = 'bchtest:qqsr7nqwe6rq5crj63gy5gdqchpnwmguusmr7tfmsj';
+export default class MockNetworkProvider {
+    constructor() {
+        this.utxoMap = {};
+        this.transactionMap = {};
+        this.network = Network.CHIPNET;
+        for (let i = 0; i < 3; i += 1) {
+            this.addUtxo(aliceAddress, randomUtxo());
+            this.addUtxo(bobAddress, randomUtxo());
+            this.addUtxo(carolAddress, randomUtxo());
+        }
+    }
+    async getUtxos(address) {
+        return this.utxoMap[address];
+    }
+    async getBlockHeight() {
+        return 133700;
+    }
+    async getRawTransaction(txid) {
+        return this.transactionMap[txid];
+    }
+    async sendRawTransaction(txHex) {
+        const transactionBin = hexToBin(txHex);
+        const txid = binToHex(sha256(sha256(transactionBin)).reverse());
+        this.transactionMap[txid] = txHex;
+        return txid;
+    }
+    addUtxo(address, utxo) {
+        if (!this.utxoMap[address]) {
+            this.utxoMap[address] = [];
+        }
+        this.utxoMap[address].push(utxo);
+    }
+    reset() {
+        this.utxoMap = {};
+        this.transactionMap = {};
+    }
+}
+//# sourceMappingURL=MockNetworkProvider.js.map

package/dist/{network → src/network}/index.d.ts

@@ -2,3 +2,4 @@ export { default as NetworkProvider } from './NetworkProvider.js';
 export { default as BitcoinRpcNetworkProvider } from './BitcoinRpcNetworkProvider.js';
 export { default as ElectrumNetworkProvider } from './ElectrumNetworkProvider.js';
 export { default as FullStackNetworkProvider } from './FullStackNetworkProvider.js';
+export { default as MockNetworkProvider } from './MockNetworkProvider.js';

package/dist/{network → src/network}/index.js

@@ -1,4 +1,5 @@
 export { default as BitcoinRpcNetworkProvider } from './BitcoinRpcNetworkProvider.js';
 export { default as ElectrumNetworkProvider } from './ElectrumNetworkProvider.js';
 export { default as FullStackNetworkProvider } from './FullStackNetworkProvider.js';
+export { default as MockNetworkProvider } from './MockNetworkProvider.js';
 //# sourceMappingURL=index.js.map

package/dist/{utils.d.ts → src/utils.d.ts}

@@ -1,6 +1,6 @@
 import { Transaction } from '@bitauth/libauth';
 import { Script } from '@cashscript/utils';
-import { Utxo, Output, LibauthOutput } from './interfaces.js';
+import { Utxo, Output, LibauthOutput, TokenDetails } from './interfaces.js';
 import { FailedTransactionError } from './Errors.js';
 export declare function validateOutput(output: Output): void;
 export declare function calculateDust(output: Output): number;
@@ -14,8 +14,8 @@ export declare function getTxSizeWithoutInputs(outputs: Output[]): number;
 export declare function createInputScript(redeemScript: Script, encodedArgs: Uint8Array[], selector?: number, preimage?: Uint8Array): Uint8Array;
 export declare function createOpReturnOutput(opReturnData: string[]): Output;
 export declare function createSighashPreimage(transaction: Transaction, sourceOutputs: LibauthOutput[], inputIndex: number, coveredBytecode: Uint8Array, hashtype: number): Uint8Array;
-export declare function buildError(reason: string, meepStr?: string): FailedTransactionError;
-export declare function meep(tx: any, utxos: Utxo[], script: Script): string;
+export declare function buildError(reason: string, debugStr?: string): FailedTransactionError;
+export declare function toRegExp(reasons: string[]): RegExp;
 export declare function scriptToAddress(script: Script, network: string, addressType: 'p2sh20' | 'p2sh32', tokenSupport: boolean): string;
 export declare function scriptToLockingBytecode(script: Script, addressType: 'p2sh20' | 'p2sh32'): Uint8Array;
 export declare function publicKeyToP2PKHLockingBytecode(publicKey: Uint8Array): Uint8Array;
@@ -30,3 +30,6 @@ export declare function utxoTokenComparator(a: Utxo, b: Utxo): number;
 */
 export declare function addressToLockScript(address: string): Uint8Array;
 export declare function getNetworkPrefix(network: string): 'bitcoincash' | 'bchtest' | 'bchreg';
+export declare const randomUtxo: (defaults?: Partial<Utxo> | undefined) => Utxo;
+export declare const randomToken: (defaults?: Partial<TokenDetails> | undefined) => TokenDetails;
+export declare const randomNFT: (defaults?: Partial<TokenDetails> | undefined) => TokenDetails;

package/dist/{utils.js → src/utils.js}

@@ -1,5 +1,5 @@
-import { cashAddressToLockingBytecode, decodeCashAddress, addressContentsToLockingBytecode, lockingBytecodeToCashAddress, binToHex, generateSigningSerializationBCH, utf8ToBin, hexToBin, flattenBinArray, LockingBytecodeType, encodeTransactionOutput, isHex, bigIntToCompactSize, } from '@bitauth/libauth';
-import { encodeInt, hash160, hash256, Op, scriptToBytecode, } from '@cashscript/utils';
+import { cashAddressToLockingBytecode, decodeCashAddress, addressContentsToLockingBytecode, lockingBytecodeToCashAddress, binToHex, generateSigningSerializationBCH, utf8ToBin, hexToBin, flattenBinArray, LockingBytecodeType, encodeTransactionOutput, isHex, bigIntToCompactSize, AuthenticationErrorCommon, NonFungibleTokenCapability, bigIntToVmNumber, } from '@bitauth/libauth';
+import { encodeInt, hash160, hash256, sha256, Op, scriptToBytecode, } from '@cashscript/utils';
 import { Network, } from './interfaces.js';
 import { VERSION_SIZE, LOCKTIME_SIZE } from './constants.js';
 import { OutputSatoshisTooSmallError, TokensToNonTokenAddressError, Reason, FailedTransactionError, FailedRequireError, FailedTimeCheckError, FailedSigCheckError, } from './Errors.js';
@@ -135,35 +135,35 @@ export function createSighashPreimage(transaction, sourceOutputs, inputIndex, co
     const sighashPreimage = generateSigningSerializationBCH(context, { coveredBytecode, signingSerializationType });
     return sighashPreimage;
 }
-export function buildError(reason, meepStr) {
+export function buildError(reason, debugStr) {
     const require = [
         Reason.EVAL_FALSE, Reason.VERIFY, Reason.EQUALVERIFY, Reason.CHECKMULTISIGVERIFY,
         Reason.CHECKSIGVERIFY, Reason.CHECKDATASIGVERIFY, Reason.NUMEQUALVERIFY,
+        AuthenticationErrorCommon.failedVerify,
+    ];
+    const timeCheck = [
+        Reason.NEGATIVE_LOCKTIME, Reason.UNSATISFIED_LOCKTIME,
+        AuthenticationErrorCommon.negativeLocktime, AuthenticationErrorCommon.unsatisfiedLocktime,
     ];
-    const timeCheck = [Reason.NEGATIVE_LOCKTIME, Reason.UNSATISFIED_LOCKTIME];
     const sigCheck = [
         Reason.SIG_COUNT, Reason.PUBKEY_COUNT, Reason.SIG_HASHTYPE, Reason.SIG_DER,
         Reason.SIG_HIGH_S, Reason.SIG_NULLFAIL, Reason.SIG_BADLENGTH, Reason.SIG_NONSCHNORR,
+        AuthenticationErrorCommon.nonNullSignatureFailure,
     ];
     if (toRegExp(require).test(reason)) {
-        return new FailedRequireError(reason, meepStr);
+        return new FailedRequireError(reason, debugStr);
     }
     if (toRegExp(timeCheck).test(reason)) {
-        return new FailedTimeCheckError(reason, meepStr);
+        return new FailedTimeCheckError(reason, debugStr);
     }
     if (toRegExp(sigCheck).test(reason)) {
-        return new FailedSigCheckError(reason, meepStr);
+        return new FailedSigCheckError(reason, debugStr);
     }
-    return new FailedTransactionError(reason, meepStr);
+    return new FailedTransactionError(reason, debugStr);
 }
-function toRegExp(reasons) {
+export function toRegExp(reasons) {
     return new RegExp(reasons.join('|').replace(/\(/g, '\\(').replace(/\)/g, '\\)'));
 }
-// ////////// MISC ////////////////////////////////////////////////////////////
-export function meep(tx, utxos, script) {
-    const scriptPubkey = binToHex(scriptToLockingBytecode(script, 'p2sh20'));
-    return `meep debug --tx=${tx} --idx=0 --amt=${utxos[0].satoshis} --pkscript=${scriptPubkey}`;
-}
 export function scriptToAddress(script, network, addressType, tokenSupport) {
     const lockingBytecode = scriptToLockingBytecode(script, addressType);
     const prefix = getNetworkPrefix(network);
@@ -249,4 +249,31 @@ function getPushDataOpcode(data) {
         return Uint8Array.from([0x4c, byteLength]);
     throw Error('Pushdata too large');
 }
+const randomInt = () => BigInt(Math.floor(Math.random() * 10000));
+export const randomUtxo = (defaults) => ({
+    ...{
+        txid: binToHex(sha256(bigIntToVmNumber(randomInt()))),
+        vout: Math.floor(Math.random() * 10),
+        satoshis: 20000n + randomInt(),
+    },
+    ...defaults,
+});
+export const randomToken = (defaults) => ({
+    ...{
+        category: binToHex(sha256(bigIntToVmNumber(randomInt()))),
+        amount: 10000n + randomInt(),
+    },
+    ...defaults,
+});
+export const randomNFT = (defaults) => ({
+    ...{
+        category: binToHex(sha256(bigIntToVmNumber(randomInt()))),
+        amount: 0n,
+        nft: {
+            commitment: binToHex(sha256(bigIntToVmNumber(randomInt()))).slice(0, 8),
+            capability: NonFungibleTokenCapability.none,
+        },
+    },
+    ...defaults,
+});
 //# sourceMappingURL=utils.js.map

package/dist/test/JestExtensions.d.ts

@@ -0,0 +1,9 @@
+export {};
+declare global {
+    namespace jest {
+        interface Matchers<R> {
+            toLog(value: RegExp | string): Promise<void>;
+            toFailRequireWith(value: RegExp | string): Promise<void>;
+        }
+    }
+}

package/dist/test/JestExtensions.js

@@ -0,0 +1,66 @@
+import { printExpected, printReceived, matcherHint } from 'jest-matcher-utils';
+expect.extend({
+    async toLog(transaction, match) {
+        const spyOnLoggerError = jest.spyOn(console, 'log');
+        // silence actual stdout output
+        spyOnLoggerError.mockImplementation(() => { });
+        try {
+            await transaction.debug();
+        }
+        catch { }
+        let message = '';
+        const failMessage = (received, expected) => () => `${matcherHint('.toLog', 'received', 'expected')}
+
+Expected: ${printExpected(expected)}
+Received: ${printReceived(received)}`;
+        try {
+            expect(spyOnLoggerError).toBeCalledWith(expect.stringMatching(match));
+        }
+        catch (error) {
+            message = error;
+        }
+        const received = spyOnLoggerError.mock.calls[0][0];
+        spyOnLoggerError.mockClear();
+        return {
+            message: failMessage(received, match),
+            pass: !message,
+        };
+    },
+});
+expect.extend({
+    async toFailRequireWith(transaction, match) {
+        let message = '';
+        let failMessage = () => { };
+        try {
+            await transaction.debug();
+            failMessage = () => () => `${matcherHint('.toFailRequireWith', undefined, '')}
+
+Contract function did not fail a require statement`;
+        }
+        catch (error) {
+            message = error;
+        }
+        // should not have failed
+        if (this.isNot) {
+            return {
+                message: () => `${matcherHint('.toFailRequireWith', 'received', '', { isNot: true })}`,
+                pass: false,
+            };
+        }
+        if (message) {
+            try {
+                expect(message).toMatch(match);
+                message = '';
+            }
+            catch (error) {
+                message = error.message;
+                failMessage = () => () => message.replace('.toMatch', '.toFailRequireWith');
+            }
+        }
+        return {
+            message: failMessage(message, match),
+            pass: !message,
+        };
+    },
+});
+//# sourceMappingURL=JestExtensions.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cashscript",
-  "version": "0.9.2",
+  "version": "0.10.0-next.0",
   "description": "Easily write and interact with Bitcoin Cash contracts",
   "keywords": [
     "bitcoin cash",
@@ -38,26 +38,28 @@
     "compile:test": "tsc -p tsconfig.test.json",
     "lint": "eslint . --ext .ts --ignore-path ../../.eslintignore",
     "prepare": "yarn build",
-    "prepublishOnly": "yarn test && yarn lint",
+    "prepublishOnly": "yarn test",
     "pretest": "yarn build:test",
     "test": "NODE_OPTIONS='--experimental-vm-modules --no-warnings' jest"
   },
   "dependencies": {
     "@bitauth/libauth": "^2.0.0-alpha.8",
-    "@cashscript/utils": "^0.9.2",
+    "@cashscript/utils": "^0.10.0-next.0",
     "bip68": "^1.0.4",
     "bitcoin-rpc-promise-retry": "^1.3.0",
     "delay": "^5.0.0",
     "electrum-cash": "^2.0.10",
-    "fast-deep-equal": "^3.1.3"
+    "fast-deep-equal": "^3.1.3",
+    "pako": "^2.1.0"
   },
   "devDependencies": {
     "@jest/globals": "^29.4.1",
     "@psf/bch-js": "^4.15.0",
+    "@types/pako": "^2.0.3",
     "bip39": "^3.0.4",
-    "eslint": "^7.20.0",
+    "eslint": "^8.54.0",
     "jest": "^29.4.1",
     "typescript": "^4.1.5"
   },
-  "gitHead": "3cd562a31cc61058f368a8527505ca746cde60d8"
+  "gitHead": "3514c438fa3c8069c36f45cc80730293ac85dbdf"
 }