cashscript 0.11.3 → 0.11.5

package/dist/Transaction.js

@@ -1,9 +1,8 @@
 import { hexToBin, decodeTransaction, } from '@bitauth/libauth';
-import delay from 'delay';
 import { encodeBip68, placeholder, } from '@cashscript/utils';
 import deepEqual from 'fast-deep-equal';
 import { isUtxoP2PKH, SignatureAlgorithm, } from './interfaces.js';
-import { createInputScript, getInputSize, createOpReturnOutput, getTxSizeWithoutInputs, validateOutput, utxoComparator, calculateDust, getOutputSize, utxoTokenComparator, } from './utils.js';
+import { createInputScript, getInputSize, createOpReturnOutput, getTxSizeWithoutInputs, validateOutput, utxoComparator, calculateDust, getOutputSize, utxoTokenComparator, delay, } from './utils.js';
 import SignatureTemplate from './SignatureTemplate.js';
 import { P2PKH_INPUT_SIZE } from './constants.js';
 import { TransactionBuilder } from './TransactionBuilder.js';

package/dist/TransactionBuilder.js

@@ -1,7 +1,6 @@
 import { binToHex, decodeTransaction, decodeTransactionUnsafe, encodeTransaction, hexToBin, } from '@bitauth/libauth';
-import delay from 'delay';
-import { isUnlockableUtxo, isStandardUnlockableUtxo, } from './interfaces.js';
-import { cashScriptOutputToLibauthOutput, createOpReturnOutput, generateLibauthSourceOutputs, validateInput, validateOutput, } from './utils.js';
+import { isUnlockableUtxo, isStandardUnlockableUtxo, isP2PKHUnlocker, } from './interfaces.js';
+import { cashScriptOutputToLibauthOutput, createOpReturnOutput, delay, generateLibauthSourceOutputs, validateInput, validateOutput, } from './utils.js';
 import { FailedTransactionError } from './Errors.js';
 import { getBitauthUri } from './LibauthTemplate.js';
 import { debugLibauthTemplate, getLibauthTemplates } from './advanced/LibauthTemplate.js';
@@ -90,6 +89,10 @@ export class TransactionBuilder {
         return binToHex(encodeTransaction(transaction));
     }
     debug() {
+        // do not debug a pure P2PKH-spend transaction
+        if (this.inputs.every((input) => isP2PKHUnlocker(input.unlocker))) {
+            return {};
+        }
         if (this.inputs.some((input) => !isStandardUnlockableUtxo(input))) {
             throw new Error('Cannot debug a transaction with custom unlocker');
         }

package/dist/advanced/LibauthTemplate.js

@@ -360,7 +360,7 @@ export const getLibauthTemplates = (txn) => {
 export const debugLibauthTemplate = (template, transaction) => {
     const allArtifacts = transaction.inputs
         .map(input => 'contract' in input.unlocker ? input.unlocker.contract : undefined)
-        .filter((contract) => !!contract)
+        .filter((contract) => Boolean(contract))
         .map(contract => contract.artifact);
     return debugTemplate(template, allArtifacts);
 };

package/dist/debugging.js

@@ -41,7 +41,8 @@ const debugSingleScenario = (template, artifact, unlockingScriptId, scenarioId)
     const executedLogs = (artifact.debug?.logs ?? [])
         .filter((log) => executedDebugSteps.some((debugStep) => log.ip === debugStep.ip));
     for (const log of executedLogs) {
-        logConsoleLogStatement(log, executedDebugSteps, artifact);
+        const inputIndex = extractInputIndexFromScenario(scenarioId);
+        logConsoleLogStatement(log, executedDebugSteps, artifact, inputIndex);
     }
     const lastExecutedDebugStep = executedDebugSteps[executedDebugSteps.length - 1];
     // If an error is present in the last step, that means a require statement in the middle of the function failed
@@ -91,6 +92,13 @@ const debugSingleScenario = (template, artifact, unlockingScriptId, scenarioId)
     }
     return fullDebugSteps;
 };
+// Note: this relies on the naming convention that the scenario ID is of the form <name>_input<index>_evaluate
+const extractInputIndexFromScenario = (scenarioId) => {
+    const match = scenarioId.match(/_input(\d+)_/);
+    if (!match)
+        throw new Error(`Invalid scenario ID: ${scenarioId}`);
+    return parseInt(match[1]);
+};
 // internal util. instantiates the virtual machine and compiles the template into a program
 const createProgram = (template, unlockingScriptId, scenarioId) => {
     const configuration = walletTemplateToCompilerConfiguration(template);
@@ -115,7 +123,7 @@ const createProgram = (template, unlockingScriptId, scenarioId) => {
     }
     return { vm, program: scenarioGeneration.scenario.program };
 };
-const logConsoleLogStatement = (log, debugSteps, artifact) => {
+const logConsoleLogStatement = (log, debugSteps, artifact, inputIndex) => {
     let line = `${artifact.contractName}.cash:${log.line}`;
     const decodedData = log.data.map((element) => {
         if (typeof element === 'string')
@@ -124,7 +132,7 @@ const logConsoleLogStatement = (log, debugSteps, artifact) => {
         const transformedDebugStep = applyStackItemTransformations(element, debugStep);
         return decodeStackItem(element, transformedDebugStep.stack);
     });
-    console.log(`${line} ${decodedData.join(' ')}`);
+    console.log(`[Input #${inputIndex}] ${line} ${decodedData.join(' ')}`);
 };
 const applyStackItemTransformations = (element, debugStep) => {
     if (!element.transformations)

package/dist/network/MockNetworkProvider.d.ts

@@ -1,16 +1,21 @@
 import { Utxo, Network } from '../interfaces.js';
 import NetworkProvider from './NetworkProvider.js';
+interface MockNetworkProviderOptions {
+    updateUtxoSet: boolean;
+}
 export default class MockNetworkProvider implements NetworkProvider {
-    private utxoMap;
+    private utxoSet;
     private transactionMap;
     network: Network;
     blockHeight: number;
-    constructor();
+    options: MockNetworkProviderOptions;
+    constructor(options?: Partial<MockNetworkProviderOptions>);
     getUtxos(address: string): Promise<Utxo[]>;
     setBlockHeight(newBlockHeight: number): void;
     getBlockHeight(): Promise<number>;
     getRawTransaction(txid: string): Promise<string>;
     sendRawTransaction(txHex: string): Promise<string>;
-    addUtxo(address: string, utxo: Utxo): void;
+    addUtxo(addressOrLockingBytecode: string, utxo: Utxo): void;
     reset(): void;
 }
+export {};

package/dist/network/MockNetworkProvider.js

@@ -1,17 +1,21 @@
-import { binToHex, hexToBin } from '@bitauth/libauth';
+import { binToHex, decodeTransactionUnsafe, hexToBin, isHex } from '@bitauth/libauth';
 import { sha256 } from '@cashscript/utils';
 import { Network } from '../interfaces.js';
-import { addressToLockScript, randomUtxo } from '../utils.js';
+import { addressToLockScript, libauthTokenDetailsToCashScriptTokenDetails, 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';
+// We are setting the default updateUtxoSet to 'false' so that it doesn't break the current behaviour
+// TODO: in a future breaking release we want to set this to 'true' by default
 export default class MockNetworkProvider {
-    constructor() {
-        this.utxoMap = {};
+    constructor(options) {
+        // we use lockingBytecode hex as the key for utxoMap to make cash addresses and token addresses interchangeable
+        this.utxoSet = [];
         this.transactionMap = {};
         this.network = Network.MOCKNET;
         this.blockHeight = 133700;
+        this.options = { updateUtxoSet: false, ...options };
         for (let i = 0; i < 3; i += 1) {
             this.addUtxo(aliceAddress, randomUtxo());
             this.addUtxo(bobAddress, randomUtxo());
@@ -19,8 +23,8 @@ export default class MockNetworkProvider {
         }
     }
     async getUtxos(address) {
-        const lockingBytecode = binToHex(addressToLockScript(address));
-        return this.utxoMap[lockingBytecode] ?? [];
+        const addressLockingBytecode = binToHex(addressToLockScript(address));
+        return this.utxoSet.filter(([lockingBytecode]) => lockingBytecode === addressLockingBytecode).map(([, utxo]) => utxo);
     }
     setBlockHeight(newBlockHeight) {
         this.blockHeight = newBlockHeight;
@@ -34,18 +38,42 @@ export default class MockNetworkProvider {
     async sendRawTransaction(txHex) {
         const transactionBin = hexToBin(txHex);
         const txid = binToHex(sha256(sha256(transactionBin)).reverse());
+        if (this.options.updateUtxoSet && this.transactionMap[txid]) {
+            throw new Error(`Transaction with txid ${txid} was already submitted`);
+        }
         this.transactionMap[txid] = txHex;
+        // If updateUtxoSet is false, we don't need to update the utxo set, and just return the txid
+        if (!this.options.updateUtxoSet)
+            return txid;
+        const decodedTransaction = decodeTransactionUnsafe(transactionBin);
+        decodedTransaction.inputs.forEach((input) => {
+            const utxoIndex = this.utxoSet.findIndex(([, utxo]) => utxo.txid === binToHex(input.outpointTransactionHash) && utxo.vout === input.outpointIndex);
+            // TODO: we should check what error a BCHN node throws, so we can throw the same error here
+            if (utxoIndex === -1) {
+                throw new Error(`UTXO not found for input ${input.outpointIndex} of transaction ${txid}`);
+            }
+            this.utxoSet.splice(utxoIndex, 1);
+        });
+        decodedTransaction.outputs.forEach((output, vout) => {
+            this.addUtxo(binToHex(output.lockingBytecode), {
+                txid,
+                vout,
+                satoshis: output.valueSatoshis,
+                token: output.token && libauthTokenDetailsToCashScriptTokenDetails(output.token),
+            });
+        });
         return txid;
     }
-    addUtxo(address, utxo) {
-        const lockingBytecode = binToHex(addressToLockScript(address));
-        if (!this.utxoMap[lockingBytecode]) {
-            this.utxoMap[lockingBytecode] = [];
-        }
-        this.utxoMap[lockingBytecode].push(utxo);
+    // Note: the user can technically add the same UTXO multiple times (txid + vout), to the same or different addresses
+    // but we don't check for this in the sendRawTransaction method. We might want to prevent duplicates from being added
+    // in the first place.
+    addUtxo(addressOrLockingBytecode, utxo) {
+        const lockingBytecode = isHex(addressOrLockingBytecode) ?
+            addressOrLockingBytecode : binToHex(addressToLockScript(addressOrLockingBytecode));
+        this.utxoSet.push([lockingBytecode, utxo]);
     }
     reset() {
-        this.utxoMap = {};
+        this.utxoSet = [];
         this.transactionMap = {};
     }
 }

package/dist/types/type-inference.d.ts

@@ -1,15 +1,17 @@
 import type SignatureTemplate from '../SignatureTemplate.js';
+type BytesType = Uint8Array | string;
+type SignatureType = SignatureTemplate | BytesType;
 type TypeMap = {
-    [k: `bytes${number}`]: Uint8Array | string;
+    [k: `bytes${number}`]: BytesType;
 } & {
-    byte: Uint8Array | string;
-    bytes: Uint8Array | string;
+    byte: BytesType;
+    bytes: BytesType;
     bool: boolean;
     int: bigint;
     string: string;
-    pubkey: Uint8Array | string;
-    sig: SignatureTemplate | Uint8Array | string;
-    datasig: Uint8Array | string;
+    pubkey: BytesType;
+    sig: SignatureType;
+    datasig: BytesType;
 };
 type ProcessParam<Param> = Param extends {
     type: infer Type;

package/dist/utils.d.ts

@@ -1,6 +1,6 @@
 import { Transaction } from '@bitauth/libauth';
 import { Script } from '@cashscript/utils';
-import { Utxo, Output, LibauthOutput, TokenDetails, AddressType, UnlockableUtxo } from './interfaces.js';
+import { Utxo, Output, LibauthOutput, TokenDetails, AddressType, UnlockableUtxo, LibauthTokenDetails } from './interfaces.js';
 export declare function validateInput(utxo: Utxo): void;
 export declare function validateOutput(output: Output): void;
 export declare function calculateDust(output: Output): number;
@@ -8,6 +8,7 @@ export declare function getOutputSize(output: Output): number;
 export declare function encodeOutput(output: Output): Uint8Array;
 export declare function cashScriptOutputToLibauthOutput(output: Output): LibauthOutput;
 export declare function libauthOutputToCashScriptOutput(output: LibauthOutput): Output;
+export declare function libauthTokenDetailsToCashScriptTokenDetails(token: LibauthTokenDetails): TokenDetails;
 export declare function generateLibauthSourceOutputs(inputs: UnlockableUtxo[]): LibauthOutput[];
 export declare function getInputSize(inputScript: Uint8Array): number;
 export declare function getTxSizeWithoutInputs(outputs: Output[]): number;
@@ -37,3 +38,4 @@ export declare const extendedStringify: (obj: any, spaces?: number) => string;
 export declare const zip: <T, U>(a: readonly T[], b: readonly U[]) => [T, U][];
 export declare const isFungibleTokenUtxo: (utxo: Utxo) => boolean;
 export declare const isNonTokenUtxo: (utxo: Utxo) => boolean;
+export declare const delay: (ms: number) => Promise<void>;

package/dist/utils.js

@@ -1,5 +1,5 @@
-import { cashAddressToLockingBytecode, decodeCashAddress, addressContentsToLockingBytecode, lockingBytecodeToCashAddress, binToHex, generateSigningSerializationBch, utf8ToBin, hexToBin, flattenBinArray, LockingBytecodeType, encodeTransactionOutput, isHex, bigIntToCompactUint, NonFungibleTokenCapability, bigIntToVmNumber, } from '@bitauth/libauth';
-import { encodeInt, hash160, hash256, sha256, Op, scriptToBytecode, } from '@cashscript/utils';
+import { cashAddressToLockingBytecode, decodeCashAddress, addressContentsToLockingBytecode, lockingBytecodeToCashAddress, binToHex, generateSigningSerializationBch, utf8ToBin, hexToBin, LockingBytecodeType, encodeTransactionOutput, isHex, bigIntToCompactUint, NonFungibleTokenCapability, bigIntToVmNumber, } from '@bitauth/libauth';
+import { encodeInt, hash160, hash256, sha256, Op, scriptToBytecode, encodeNullDataScript, } from '@cashscript/utils';
 import { Network, } from './interfaces.js';
 import { VERSION_SIZE, LOCKTIME_SIZE } from './constants.js';
 import { OutputSatoshisTooSmallError, OutputTokenAmountTooSmallError, TokensToNonTokenAddressError, UndefinedInputError, } from './Errors.js';
@@ -64,13 +64,16 @@ export function libauthOutputToCashScriptOutput(output) {
     return {
         to: output.lockingBytecode,
         amount: output.valueSatoshis,
-        token: output.token && {
-            ...output.token,
-            category: binToHex(output.token.category),
-            nft: output.token.nft && {
-                ...output.token.nft,
-                commitment: binToHex(output.token.nft.commitment),
-            },
+        token: output.token && libauthTokenDetailsToCashScriptTokenDetails(output.token),
+    };
+}
+export function libauthTokenDetailsToCashScriptTokenDetails(token) {
+    return {
+        ...token,
+        category: binToHex(token.category),
+        nft: token.nft && {
+            ...token.nft,
+            commitment: binToHex(token.nft.commitment),
         },
     };
 }
@@ -217,27 +220,6 @@ export function getNetworkPrefix(network) {
             return 'bitcoincash';
     }
 }
-// ////////////////////////////////////////////////////////////////////////////
-// For encoding OP_RETURN data (doesn't require BIP62.3 / MINIMALDATA)
-function encodeNullDataScript(chunks) {
-    return flattenBinArray(chunks.map((chunk) => {
-        if (typeof chunk === 'number') {
-            return new Uint8Array([chunk]);
-        }
-        const pushdataOpcode = getPushDataOpcode(chunk);
-        return new Uint8Array([...pushdataOpcode, ...chunk]);
-    }));
-}
-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 new Error('Pushdata too large');
-}
 const randomInt = () => BigInt(Math.floor(Math.random() * 10000));
 export const randomUtxo = (defaults) => ({
     ...{
@@ -287,4 +269,5 @@ export const extendedStringify = (obj, spaces) => JSON.stringify(obj, (_, v) =>
 export const zip = (a, b) => (Array.from(Array(Math.max(b.length, a.length)), (_, i) => [a[i], b[i]]));
 export const isFungibleTokenUtxo = (utxo) => (utxo.token !== undefined && utxo.token.amount > 0n && utxo.token.nft === undefined);
 export const isNonTokenUtxo = (utxo) => utxo.token === undefined;
+export const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 //# sourceMappingURL=utils.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cashscript",
-  "version": "0.11.3",
+  "version": "0.11.5",
   "description": "Easily write and interact with Bitcoin Cash contracts",
   "keywords": [
     "bitcoin cash",
@@ -46,13 +46,12 @@
   },
   "dependencies": {
     "@bitauth/libauth": "^3.1.0-next.2",
-    "@cashscript/utils": "^0.11.3",
+    "@cashscript/utils": "^0.11.5",
     "@electrum-cash/network": "^4.1.3",
     "@mr-zwets/bchn-api-wrapper": "^1.0.1",
-    "delay": "^6.0.0",
     "fast-deep-equal": "^3.1.3",
     "pako": "^2.1.0",
-    "semver": "^7.6.3"
+    "semver": "^7.7.2"
   },
   "devDependencies": {
     "@jest/globals": "^29.7.0",
@@ -61,7 +60,7 @@
     "@types/semver": "^7.5.8",
     "eslint": "^8.54.0",
     "jest": "^29.7.0",
-    "typescript": "^5.7.3"
+    "typescript": "^5.9.2"
   },
-  "gitHead": "6bc2941e919411e04b7408dca7239da8ec1768f6"
+  "gitHead": "0ccda722dde4c0825285f3a6aa05898a8f62c160"
 }