cashscript 0.11.2 → 0.11.4

package/dist/TransactionBuilder.js

@@ -1,6 +1,6 @@
 import { binToHex, decodeTransaction, decodeTransactionUnsafe, encodeTransaction, hexToBin, } from '@bitauth/libauth';
 import delay from 'delay';
-import { isUnlockableUtxo, isStandardUnlockableUtxo, } from './interfaces.js';
+import { isUnlockableUtxo, isStandardUnlockableUtxo, isP2PKHUnlocker, } from './interfaces.js';
 import { cashScriptOutputToLibauthOutput, createOpReturnOutput, generateLibauthSourceOutputs, validateInput, validateOutput, } from './utils.js';
 import { FailedTransactionError } from './Errors.js';
 import { getBitauthUri } from './LibauthTemplate.js';
@@ -90,6 +90,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/network/ElectrumNetworkProvider.js

@@ -14,7 +14,7 @@ export default class ElectrumNetworkProvider {
         if ('electrum' in options)
             return options.electrum;
         const server = 'hostname' in options ? options.hostname : this.getServerForNetwork(network);
-        return new ElectrumClient('CashScript Application', '1.4.1', server);
+        return new ElectrumClient('CashScript Application', '1.4.1', server, { disableBrowserVisibilityHandling: true });
     }
     // Get Electrum server based on network
     getServerForNetwork(network) {

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/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;

package/dist/utils.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),
         },
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cashscript",
-  "version": "0.11.2",
+  "version": "0.11.4",
   "description": "Easily write and interact with Bitcoin Cash contracts",
   "keywords": [
     "bitcoin cash",
@@ -46,13 +46,14 @@
   },
   "dependencies": {
     "@bitauth/libauth": "^3.1.0-next.2",
-    "@cashscript/utils": "^0.11.2",
-    "@electrum-cash/network": "^4.1.1",
+    "@cashscript/utils": "^0.11.4",
+    "@electrum-cash/network": "^4.1.3",
     "@mr-zwets/bchn-api-wrapper": "^1.0.1",
+    "@types/node": "^22.17.0",
     "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 +62,7 @@
     "@types/semver": "^7.5.8",
     "eslint": "^8.54.0",
     "jest": "^29.7.0",
-    "typescript": "^5.7.3"
+    "typescript": "^5.9.2"
   },
-  "gitHead": "81e7dc182ef71909af721d62751ef403bcfcc41e"
+  "gitHead": "d878d068b91ddc5a4ca1807376520ae451e4a0ed"
 }