cashscript 0.8.0-next.2 → 0.8.0-next.3

package/dist/SignatureTemplate.js

@@ -1,7 +1,7 @@
 import { decodePrivateKeyWif, secp256k1, SigningSerializationFlag } from '@bitauth/libauth';
 import { HashType, SignatureAlgorithm } from './interfaces.js';
 export default class SignatureTemplate {
-    constructor(signer, hashtype = HashType.SIGHASH_ALL, signatureAlgorithm = SignatureAlgorithm.SCHNORR) {
+    constructor(signer, hashtype = HashType.SIGHASH_ALL | HashType.SIGHASH_UTXOS, signatureAlgorithm = SignatureAlgorithm.SCHNORR) {
         this.hashtype = hashtype;
         this.signatureAlgorithm = signatureAlgorithm;
         if (isKeypair(signer)) {

package/dist/Transaction.d.ts

@@ -20,8 +20,8 @@ export declare class Transaction {
     constructor(address: string, provider: NetworkProvider, redeemScript: Script, abiFunction: AbiFunction, args: (Uint8Array | SignatureTemplate)[], selector?: number | undefined);
     from(input: Utxo): this;
     from(inputs: Utxo[]): this;
-    experimentalFromP2PKH(input: Utxo, template: SignatureTemplate): this;
-    experimentalFromP2PKH(inputs: Utxo[], template: SignatureTemplate): this;
+    fromP2PKH(input: Utxo, template: SignatureTemplate): this;
+    fromP2PKH(inputs: Utxo[], template: SignatureTemplate): this;
     to(to: string, amount: bigint, token?: TokenDetails): this;
     to(outputs: Recipient[]): this;
     withOpReturn(chunks: string[]): this;

package/dist/Transaction.js

@@ -1,8 +1,8 @@
-import { hexToBin, binToHex, encodeTransaction, addressContentsToLockingBytecode, decodeTransaction, LockingBytecodeType, } from '@bitauth/libauth';
+import { hexToBin, binToHex, encodeTransaction, decodeTransaction, } from '@bitauth/libauth';
 import delay from 'delay';
-import { hash160, hash256, placeholder, scriptToBytecode, } from '@cashscript/utils';
+import { hash256, placeholder, scriptToBytecode, } from '@cashscript/utils';
 import { isSignableUtxo, } from './interfaces.js';
-import { meep, createInputScript, getInputSize, createOpReturnOutput, getTxSizeWithoutInputs, getPreimageSize, buildError, createSighashPreimage, validateRecipient, utxoComparator, cashScriptOutputToLibauthOutput, calculateDust, getOutputSize, } from './utils.js';
+import { meep, createInputScript, getInputSize, createOpReturnOutput, getTxSizeWithoutInputs, getPreimageSize, buildError, createSighashPreimage, validateRecipient, utxoComparator, cashScriptOutputToLibauthOutput, calculateDust, getOutputSize, addressToLockScript, publicKeyToP2PKHLockingBytecode, utxoTokenComparator, } from './utils.js';
 import SignatureTemplate from './SignatureTemplate.js';
 const bip68 = await import('bip68');
 export class Transaction {
@@ -27,7 +27,7 @@ export class Transaction {
         this.inputs = this.inputs.concat(inputOrInputs);
         return this;
     }
-    experimentalFromP2PKH(inputOrInputs, template) {
+    fromP2PKH(inputOrInputs, template) {
         if (!Array.isArray(inputOrInputs)) {
             inputOrInputs = [inputOrInputs];
         }
@@ -82,12 +82,22 @@ export class Transaction {
         this.locktime = this.locktime ?? await this.provider.getBlockHeight();
         await this.setInputsAndOutputs();
         const bytecode = scriptToBytecode(this.redeemScript);
+        const lockingBytecode = addressToLockScript(this.address);
         const inputs = this.inputs.map((utxo) => ({
             outpointIndex: utxo.vout,
             outpointTransactionHash: hexToBin(utxo.txid),
             sequenceNumber: this.sequence,
             unlockingBytecode: new Uint8Array(),
         }));
+        // Generate source outputs from inputs (for signing with SIGHASH_UTXOS)
+        const sourceOutputs = this.inputs.map((input) => {
+            const sourceOutput = {
+                amount: input.satoshis,
+                to: isSignableUtxo(input) ? publicKeyToP2PKHLockingBytecode(input.template.getPublicKey()) : lockingBytecode,
+                token: input.token,
+            };
+            return cashScriptOutputToLibauthOutput(sourceOutput);
+        });
         const outputs = this.outputs.map(cashScriptOutputToLibauthOutput);
         const transaction = {
             inputs,
@@ -100,11 +110,9 @@ export class Transaction {
             // UTXO's with signature templates are signed using P2PKH
             if (isSignableUtxo(utxo)) {
                 const pubkey = utxo.template.getPublicKey();
-                const pubkeyHash = hash160(pubkey);
-                const addressContents = { payload: pubkeyHash, type: LockingBytecodeType.p2pkh };
-                const prevOutScript = addressContentsToLockingBytecode(addressContents);
+                const prevOutScript = publicKeyToP2PKHLockingBytecode(pubkey);
                 const hashtype = utxo.template.getHashType();
-                const preimage = createSighashPreimage(transaction, this.inputs, i, prevOutScript, hashtype);
+                const preimage = createSighashPreimage(transaction, sourceOutputs, i, prevOutScript, hashtype);
                 const sighash = hash256(preimage);
                 const signature = utxo.template.generateSignature(sighash);
                 const inputScript = scriptToBytecode([signature, pubkey]);
@@ -118,12 +126,12 @@ export class Transaction {
                 // First signature is used for sighash preimage (maybe not the best way)
                 if (covenantHashType < 0)
                     covenantHashType = arg.getHashType();
-                const preimage = createSighashPreimage(transaction, this.inputs, i, bytecode, arg.getHashType());
+                const preimage = createSighashPreimage(transaction, sourceOutputs, i, bytecode, arg.getHashType());
                 const sighash = hash256(preimage);
                 return arg.generateSignature(sighash);
             });
             const preimage = this.abiFunction.covenant
-                ? createSighashPreimage(transaction, this.inputs, i, bytecode, covenantHashType)
+                ? createSighashPreimage(transaction, sourceOutputs, i, bytecode, covenantHashType)
                 : undefined;
             const inputScript = createInputScript(this.redeemScript, completeArgs, this.selector, preimage);
             inputScripts.push(inputScript);
@@ -169,67 +177,48 @@ export class Transaction {
         if (this.outputs.length === 0) {
             throw Error('Attempted to build a transaction without outputs');
         }
-        // Construct object with total output of fungible tokens by tokenId
-        const netBalanceTokens = {};
+        const allUtxos = await this.provider.getUtxos(this.address);
+        const manualTokenInputs = this.inputs.filter((input) => input.token);
+        // This will throw if the amount is not enough
+        if (manualTokenInputs.length > 0) {
+            selectAllTokenUtxos(manualTokenInputs, this.outputs);
+        }
+        const automaticTokenInputs = selectAllTokenUtxos(allUtxos, this.outputs);
+        const tokenInputs = manualTokenInputs.length > 0 ? manualTokenInputs : automaticTokenInputs;
+        if (this.tokenChange) {
+            const tokenChangeOutputs = createTokenChangeOutputs(tokenInputs, this.outputs, this.address);
+            this.outputs.push(...tokenChangeOutputs);
+        }
         // Construct list with all nfts in inputs
         const listNftsInputs = [];
         // If inputs are manually selected, add their tokens to balance
-        for (const input of this.inputs) {
+        this.inputs.forEach((input) => {
             if (!input.token)
-                continue;
-            const tokenCategory = input.token.category;
-            if (!netBalanceTokens[tokenCategory]) {
-                netBalanceTokens[tokenCategory] = input.token.amount;
-            }
-            else {
-                netBalanceTokens[tokenCategory] += input.token.amount;
-            }
+                return;
             if (input.token.nft) {
                 listNftsInputs.push({ ...input.token.nft, category: input.token.category });
             }
-        }
+        });
         // Construct list with all nfts in outputs
         let listNftsOutputs = [];
         // Subtract all token outputs from the token balances
-        for (const output of this.outputs) {
+        this.outputs.forEach((output) => {
             if (!output.token)
-                continue;
-            const tokenCategory = output.token.category;
-            if (!netBalanceTokens[tokenCategory]) {
-                netBalanceTokens[tokenCategory] = -output.token.amount;
-            }
-            else {
-                netBalanceTokens[tokenCategory] -= output.token.amount;
-            }
+                return;
             if (output.token.nft) {
                 listNftsOutputs.push({ ...output.token.nft, category: output.token.category });
             }
-        }
+        });
         // If inputs are manually provided, check token balances
         if (this.inputs.length > 0) {
-            for (const [category, balance] of Object.entries(netBalanceTokens)) {
-                // Add token change outputs if applicable
-                if (this.tokenChange && balance > 0) {
-                    const tokenDetails = {
-                        category,
-                        amount: balance,
-                    };
-                    const tokenChangeOutput = { to: this.address, amount: BigInt(1000), token: tokenDetails };
-                    this.outputs.push(tokenChangeOutput);
-                }
-                // Throw error when token balance is insufficient
-                if (balance < 0) {
-                    throw new Error(`Insufficient token balance for token with category ${category}.`);
-                }
-            }
             // Compare nfts in- and outputs, check if inputs have nfts corresponding to outputs
             // Keep list of nfts in inputs without matching output
             // First check immutable nfts, then mutable & minting nfts together
-            // this is so the mutable nft in input does not get match to an output nft corresponding to an immutable nft in the inputs
+            // This is so an immutible input gets matched first and is removed from the list of unused nfts
             let unusedNfts = listNftsInputs;
             for (const nftInput of listNftsInputs) {
                 if (nftInput.capability === 'none') {
-                    for (let i = 0; i < listNftsOutputs.length; i++) {
+                    for (let i = 0; i < listNftsOutputs.length; i += 1) {
                         // Deep equality check token objects
                         if (JSON.stringify(listNftsOutputs[i]) === JSON.stringify(nftInput)) {
                             listNftsOutputs.splice(i, 1);
@@ -241,6 +230,7 @@ export class Transaction {
             }
             for (const nftInput of listNftsInputs) {
                 if (nftInput.capability === 'minting') {
+                    // eslint-disable-next-line max-len
                     const newListNftsOutputs = listNftsOutputs.filter((nftOutput) => nftOutput.category !== nftInput.category);
                     if (newListNftsOutputs !== listNftsOutputs) {
                         unusedNfts = unusedNfts.filter((nft) => nft !== nftInput);
@@ -248,7 +238,7 @@ export class Transaction {
                     }
                 }
                 if (nftInput.capability === 'mutable') {
-                    for (let i = 0; i < listNftsOutputs.length; i++) {
+                    for (let i = 0; i < listNftsOutputs.length; i += 1) {
                         if (listNftsOutputs[i].category === nftInput.category) {
                             listNftsOutputs.splice(i, 1);
                             unusedNfts = unusedNfts.filter((nft) => nft !== nftInput);
@@ -257,8 +247,14 @@ export class Transaction {
                     }
                 }
             }
+            for (const nftOutput of listNftsOutputs) {
+                const genesisUtxo = getTokenGenesisUtxo(this.inputs, nftOutput.category);
+                if (genesisUtxo) {
+                    listNftsOutputs = listNftsOutputs.filter((nft) => nft !== nftOutput);
+                }
+            }
             if (listNftsOutputs.length !== 0) {
-                throw new Error('Nfts in outputs don\'t have corresponding nfts in inputs!');
+                throw new Error(`NFT output with token category ${listNftsOutputs[0].category} does not have corresponding input`);
             }
             if (this.tokenChange) {
                 for (const unusedNft of unusedNfts) {
@@ -300,17 +296,24 @@ export class Transaction {
         }
         else {
             // If inputs are not defined yet, we retrieve the contract's UTXOs and perform selection
-            const utxos = await this.provider.getUtxos(this.address);
+            const bchUtxos = allUtxos.filter((utxo) => !utxo.token);
             // We sort the UTXOs mainly so there is consistent behaviour between network providers
             // even if they report UTXOs in a different order
-            utxos.sort(utxoComparator).reverse();
-            for (const utxo of utxos) {
+            bchUtxos.sort(utxoComparator).reverse();
+            // Add all automatically added token inputs to the transaction
+            for (const utxo of automaticTokenInputs) {
                 this.inputs.push(utxo);
                 satsAvailable += addPrecision(utxo.satoshis);
                 if (!this.hardcodedFee)
                     fee += addPrecision(inputSize * this.feePerByte);
+            }
+            for (const utxo of bchUtxos) {
                 if (satsAvailable > amount + fee)
                     break;
+                this.inputs.push(utxo);
+                satsAvailable += addPrecision(utxo.satoshis);
+                if (!this.hardcodedFee)
+                    fee += addPrecision(inputSize * this.feePerByte);
             }
         }
         // Remove "decimal points" from BigInt numbers (rounding up for fee, down for others)
@@ -334,6 +337,52 @@ export class Transaction {
         }
     }
 }
+const getTokenGenesisUtxo = (utxos, tokenCategory) => {
+    const creationUtxo = utxos.find((utxo) => utxo.vout === 0 && utxo.txid === tokenCategory);
+    return creationUtxo;
+};
+const getTokenCategories = (outputs) => (outputs
+    .filter((output) => output.token)
+    .map((output) => output.token.category));
+const calculateTotalTokenAmount = (outputs, tokenCategory) => (outputs
+    .filter((output) => output.token?.category === tokenCategory)
+    .reduce((acc, output) => acc + output.token.amount, 0n));
+const selectTokenUtxos = (utxos, amountNeeded, tokenCategory) => {
+    const genesisUtxo = getTokenGenesisUtxo(utxos, tokenCategory);
+    if (genesisUtxo) {
+        return [genesisUtxo];
+    }
+    const tokenUtxos = utxos.filter((utxo) => utxo.token?.category === tokenCategory);
+    // We sort the UTXOs mainly so there is consistent behaviour between network providers
+    // even if they report UTXOs in a different order
+    tokenUtxos.sort(utxoTokenComparator).reverse();
+    let amountAvailable = 0n;
+    const selectedUtxos = [];
+    // Add token UTXOs until we have enough to cover the amount needed (no fee calculation because it's a token)
+    for (const utxo of tokenUtxos) {
+        selectedUtxos.push(utxo);
+        amountAvailable += utxo.token.amount;
+        if (amountAvailable >= amountNeeded)
+            break;
+    }
+    if (amountAvailable < amountNeeded) {
+        throw new Error(`Insufficient funds for token ${tokenCategory}: available (${amountAvailable}) < needed (${amountNeeded}).`);
+    }
+    return selectedUtxos;
+};
+const selectAllTokenUtxos = (utxos, outputs) => {
+    const tokenCategories = getTokenCategories(outputs);
+    return tokenCategories.flatMap((tokenCategory) => selectTokenUtxos(utxos, calculateTotalTokenAmount(outputs, tokenCategory), tokenCategory));
+};
+const createTokenChangeOutputs = (utxos, outputs, address) => {
+    const tokenCategories = getTokenCategories(utxos);
+    return tokenCategories.map((tokenCategory) => {
+        const required = calculateTotalTokenAmount(outputs, tokenCategory);
+        const available = calculateTotalTokenAmount(utxos, tokenCategory);
+        const change = available - required;
+        return { to: address, amount: BigInt(1000), token: { category: tokenCategory, amount: change } };
+    });
+};
 // Note: the below is a very simple implementation of a "decimal point" system for BigInt numbers
 // It is safe to use for UTXO fee calculations due to its low numbers, but should not be used for other purposes
 // Also note that multiplication and division between two "decimal" bigints is not supported

package/dist/interfaces.d.ts

@@ -29,6 +29,11 @@ export interface TokenDetails {
         commitment: string;
     };
 }
+export interface NftObject {
+    category: string;
+    capability: 'none' | 'mutable' | 'minting';
+    commitment: string;
+}
 export interface LibauthOutput {
     lockingBytecode: Uint8Array;
     valueSatoshis: bigint;
@@ -50,6 +55,7 @@ export declare enum HashType {
     SIGHASH_ALL = 1,
     SIGHASH_NONE = 2,
     SIGHASH_SINGLE = 3,
+    SIGHASH_UTXOS = 32,
     SIGHASH_ANYONECANPAY = 128
 }
 export declare const Network: {

package/dist/interfaces.js

@@ -11,6 +11,7 @@ export var HashType;
     HashType[HashType["SIGHASH_ALL"] = 1] = "SIGHASH_ALL";
     HashType[HashType["SIGHASH_NONE"] = 2] = "SIGHASH_NONE";
     HashType[HashType["SIGHASH_SINGLE"] = 3] = "SIGHASH_SINGLE";
+    HashType[HashType["SIGHASH_UTXOS"] = 32] = "SIGHASH_UTXOS";
     HashType[HashType["SIGHASH_ANYONECANPAY"] = 128] = "SIGHASH_ANYONECANPAY";
 })(HashType || (HashType = {}));
 // Weird setup to allow both Enum parameters, as well as literal strings

package/dist/utils.d.ts

@@ -13,12 +13,14 @@ export declare function getPreimageSize(script: Uint8Array): number;
 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, inputs: Utxo[], inputIndex: number, coveredBytecode: Uint8Array, hashtype: number): Uint8Array;
+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 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;
 export declare function utxoComparator(a: Utxo, b: Utxo): number;
+export declare function utxoTokenComparator(a: Utxo, b: Utxo): number;
 /**
 * Helper function to convert an address to a locking script
 *

package/dist/utils.js

@@ -119,15 +119,7 @@ function toBin(output) {
     const encode = data === output ? utf8ToBin : hexToBin;
     return encode(data);
 }
-export function createSighashPreimage(transaction, inputs, inputIndex, coveredBytecode, hashtype) {
-    const sourceOutputs = inputs.map((input) => {
-        const sourceOutput = {
-            amount: input.satoshis,
-            to: Uint8Array.of(),
-            token: input.token,
-        };
-        return cashScriptOutputToLibauthOutput(sourceOutput);
-    });
+export function createSighashPreimage(transaction, sourceOutputs, inputIndex, coveredBytecode, hashtype) {
     const context = { inputIndex, sourceOutputs, transaction };
     const signingSerializationType = new Uint8Array([hashtype]);
     const sighashPreimage = generateSigningSerializationBCH(context, { coveredBytecode, signingSerializationType });
@@ -175,6 +167,12 @@ export function scriptToLockingBytecode(script, addressType) {
     const lockingBytecode = addressContentsToLockingBytecode(addressContents);
     return lockingBytecode;
 }
+export function publicKeyToP2PKHLockingBytecode(publicKey) {
+    const pubkeyHash = hash160(publicKey);
+    const addressContents = { payload: pubkeyHash, type: LockingBytecodeType.p2pkh };
+    const lockingBytecode = addressContentsToLockingBytecode(addressContents);
+    return lockingBytecode;
+}
 export function utxoComparator(a, b) {
     if (a.satoshis > b.satoshis)
         return 1;
@@ -182,6 +180,17 @@ export function utxoComparator(a, b) {
         return -1;
     return 0;
 }
+export function utxoTokenComparator(a, b) {
+    if (!a.token || !b.token)
+        throw new Error('UTXO does not have token data');
+    if (!a.token.category !== !b.token.category)
+        throw new Error('UTXO token categories do not match');
+    if (a.token.amount > b.token.amount)
+        return 1;
+    if (a.token.amount < b.token.amount)
+        return -1;
+    return 0;
+}
 /**
 * Helper function to convert an address to a locking script
 *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cashscript",
-  "version": "0.8.0-next.2",
+  "version": "0.8.0-next.3",
   "description": "Easily write and interact with Bitcoin Cash contracts",
   "keywords": [
     "bitcoin cash",
@@ -38,12 +38,13 @@
     "compile:test": "tsc -p tsconfig.test.json",
     "lint": "eslint . --ext .ts --ignore-path ../../.eslintignore",
     "prepare": "yarn build",
+    "prepublishOnly": "yarn test && yarn lint",
     "pretest": "yarn build:test",
     "test": "NODE_OPTIONS='--experimental-vm-modules --no-warnings' jest"
   },
   "dependencies": {
     "@bitauth/libauth": "^2.0.0-alpha.8",
-    "@cashscript/utils": "^0.8.0-next.2",
+    "@cashscript/utils": "^0.8.0-next.3",
     "bip68": "^1.0.4",
     "bitcoin-rpc-promise-retry": "^1.3.0",
     "delay": "^5.0.0",
@@ -57,5 +58,5 @@
     "jest": "^29.4.1",
     "typescript": "^4.1.5"
   },
-  "gitHead": "37bcb8e924fc56ef8da2cb2a2640eb5478de39b2"
+  "gitHead": "398ff2afab6d731f077002e6be021ed2f1996b4a"
 }