cashscript 0.9.1 → 0.9.3

package/dist/Contract.d.ts

@@ -1,7 +1,8 @@
-import { Artifact } from '@cashscript/utils';
+import { Artifact, Script } from '@cashscript/utils';
 import { Transaction } from './Transaction.js';
 import { Argument } from './Argument.js';
 import { Unlocker, ContractOptions, Utxo } from './interfaces.js';
+import NetworkProvider from './network/NetworkProvider.js';
 export declare class Contract {
     private artifact;
     private options?;
@@ -13,8 +14,8 @@ export declare class Contract {
     opcount: number;
     functions: Record<string, ContractFunction>;
     unlock: Record<string, ContractUnlocker>;
-    private redeemScript;
-    private provider;
+    redeemScript: Script;
+    provider: NetworkProvider;
     private addressType;
     constructor(artifact: Artifact, constructorArgs: Argument[], options?: ContractOptions | undefined);
     getBalance(): Promise<bigint>;

package/dist/Contract.js

@@ -73,7 +73,8 @@ export class Contract {
             // Encode passed args (this also performs type checking)
             const encodedArgs = args
                 .map((arg, i) => encodeArgument(arg, abiFunction.inputs[i].type));
-            return new Transaction(this.address, this.provider, this.redeemScript, abiFunction, encodedArgs, selector);
+            const unlocker = this.createUnlocker(abiFunction, selector)(...args);
+            return new Transaction(this, unlocker, abiFunction, encodedArgs, selector);
         };
     }
     createUnlocker(abiFunction, selector) {
@@ -82,14 +83,22 @@ export class Contract {
             const encodedArgs = args
                 .map((arg, i) => encodeArgument(arg, abiFunction.inputs[i].type));
             const generateUnlockingBytecode = ({ transaction, sourceOutputs, inputIndex }) => {
+                // TODO: Remove old-style covenant code for v1.0 release
+                let covenantHashType = -1;
                 const completeArgs = encodedArgs.map((arg) => {
                     if (!(arg instanceof SignatureTemplate))
                         return arg;
+                    // First signature is used for sighash preimage (maybe not the best way)
+                    if (covenantHashType < 0)
+                        covenantHashType = arg.getHashType();
                     const preimage = createSighashPreimage(transaction, sourceOutputs, inputIndex, bytecode, arg.getHashType());
                     const sighash = hash256(preimage);
                     return arg.generateSignature(sighash);
                 });
-                const unlockingBytecode = createInputScript(this.redeemScript, completeArgs, selector);
+                const preimage = abiFunction.covenant
+                    ? createSighashPreimage(transaction, sourceOutputs, inputIndex, bytecode, covenantHashType)
+                    : undefined;
+                const unlockingBytecode = createInputScript(this.redeemScript, completeArgs, selector, preimage);
                 return unlockingBytecode;
             };
             const generateLockingBytecode = () => addressToLockScript(this.address);

package/dist/Transaction.d.ts

@@ -1,11 +1,10 @@
-import { AbiFunction, Script } from '@cashscript/utils';
-import { Utxo, Recipient, TokenDetails, TransactionDetails } from './interfaces.js';
-import NetworkProvider from './network/NetworkProvider.js';
+import { AbiFunction } from '@cashscript/utils';
+import { Utxo, Recipient, TokenDetails, TransactionDetails, Unlocker } from './interfaces.js';
 import SignatureTemplate from './SignatureTemplate.js';
+import { Contract } from './Contract.js';
 export declare class Transaction {
-    private address;
-    private provider;
-    private redeemScript;
+    private contract;
+    private unlocker;
     private abiFunction;
     private args;
     private selector?;
@@ -17,7 +16,7 @@ export declare class Transaction {
     private hardcodedFee;
     private minChange;
     private tokenChange;
-    constructor(address: string, provider: NetworkProvider, redeemScript: Script, abiFunction: AbiFunction, args: (Uint8Array | SignatureTemplate)[], selector?: number | undefined);
+    constructor(contract: Contract, unlocker: Unlocker, abiFunction: AbiFunction, args: (Uint8Array | SignatureTemplate)[], selector?: number | undefined);
     from(input: Utxo): this;
     from(inputs: Utxo[]): this;
     fromP2PKH(input: Utxo, template: SignatureTemplate): this;

package/dist/Transaction.js

@@ -1,17 +1,17 @@
 import bip68 from 'bip68';
-import { hexToBin, binToHex, encodeTransaction, decodeTransaction, } from '@bitauth/libauth';
+import { hexToBin, decodeTransaction, } from '@bitauth/libauth';
 import delay from 'delay';
-import { hash256, placeholder, scriptToBytecode, } from '@cashscript/utils';
+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, createSighashPreimage, validateRecipient, utxoComparator, cashScriptOutputToLibauthOutput, calculateDust, getOutputSize, addressToLockScript, publicKeyToP2PKHLockingBytecode, utxoTokenComparator, } from './utils.js';
+import { meep, 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';
 export class Transaction {
-    constructor(address, provider, redeemScript, abiFunction, args, selector) {
-        this.address = address;
-        this.provider = provider;
-        this.redeemScript = redeemScript;
+    constructor(contract, unlocker, abiFunction, args, selector) {
+        this.contract = contract;
+        this.unlocker = unlocker;
         this.abiFunction = abiFunction;
         this.args = args;
         this.selector = selector;
@@ -43,7 +43,7 @@ export class Transaction {
             return this.to([recipient]);
         }
         if (Array.isArray(toOrOutputs) && amount === undefined) {
-            toOrOutputs.forEach(validateRecipient);
+            toOrOutputs.forEach(validateOutput);
             this.outputs = this.outputs.concat(toOrOutputs);
             return this;
         }
@@ -81,84 +81,37 @@ export class Transaction {
         return this;
     }
     async build() {
-        this.locktime = this.locktime ?? await this.provider.getBlockHeight();
+        this.locktime = this.locktime ?? await this.contract.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: isUtxoP2PKH(input) ? publicKeyToP2PKHLockingBytecode(input.template.getPublicKey()) : lockingBytecode,
-                token: input.token,
-            };
-            return cashScriptOutputToLibauthOutput(sourceOutput);
-        });
-        const outputs = this.outputs.map(cashScriptOutputToLibauthOutput);
-        const transaction = {
-            inputs,
-            locktime: this.locktime,
-            outputs,
-            version: 2,
-        };
-        const inputScripts = [];
-        this.inputs.forEach((utxo, i) => {
-            // UTXO's with signature templates are signed using P2PKH
+        const builder = new TransactionBuilder({ provider: this.contract.provider });
+        this.inputs.forEach((utxo) => {
             if (isUtxoP2PKH(utxo)) {
-                const pubkey = utxo.template.getPublicKey();
-                const prevOutScript = publicKeyToP2PKHLockingBytecode(pubkey);
-                const hashtype = utxo.template.getHashType();
-                const preimage = createSighashPreimage(transaction, sourceOutputs, i, prevOutScript, hashtype);
-                const sighash = hash256(preimage);
-                const signature = utxo.template.generateSignature(sighash);
-                const inputScript = scriptToBytecode([signature, pubkey]);
-                inputScripts.push(inputScript);
-                return;
+                builder.addInput(utxo, utxo.template.unlockP2PKH(), { sequence: this.sequence });
+            }
+            else {
+                builder.addInput(utxo, this.unlocker, { sequence: this.sequence });
             }
-            let covenantHashType = -1;
-            const completeArgs = this.args.map((arg) => {
-                if (!(arg instanceof SignatureTemplate))
-                    return arg;
-                // First signature is used for sighash preimage (maybe not the best way)
-                if (covenantHashType < 0)
-                    covenantHashType = 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, sourceOutputs, i, bytecode, covenantHashType)
-                : undefined;
-            const inputScript = createInputScript(this.redeemScript, completeArgs, this.selector, preimage);
-            inputScripts.push(inputScript);
-        });
-        inputScripts.forEach((script, i) => {
-            transaction.inputs[i].unlockingBytecode = script;
         });
-        return binToHex(encodeTransaction(transaction));
+        builder.addOutputs(this.outputs);
+        builder.setLocktime(this.locktime);
+        return builder.build();
     }
     async send(raw) {
         const tx = await this.build();
         try {
-            const txid = await this.provider.sendRawTransaction(tx);
+            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.redeemScript));
+            throw buildError(reason, meep(tx, this.inputs, this.contract.redeemScript));
         }
     }
     async getTxDetails(txid, raw) {
         for (let retries = 0; retries < 1200; retries += 1) {
             await delay(500);
             try {
-                const hex = await this.provider.getRawTransaction(txid);
+                const hex = await this.contract.provider.getRawTransaction(txid);
                 if (raw)
                     return hex;
                 const libauthTransaction = decodeTransaction(hexToBin(hex));
@@ -173,13 +126,16 @@ export class Transaction {
     }
     async meep() {
         const tx = await this.build();
-        return meep(tx, this.inputs, this.redeemScript);
+        return meep(tx, this.inputs, this.contract.redeemScript);
     }
     async setInputsAndOutputs() {
         if (this.outputs.length === 0) {
             throw Error('Attempted to build a transaction without outputs');
         }
-        const allUtxos = await this.provider.getUtxos(this.address);
+        // Fetched utxos are only used when no inputs are available, so only fetch in that case.
+        const allUtxos = this.inputs.length === 0
+            ? await this.contract.provider.getUtxos(this.contract.address)
+            : [];
         const tokenInputs = this.inputs.length > 0
             ? this.inputs.filter((input) => input.token)
             : selectAllTokenUtxos(allUtxos, this.outputs);
@@ -188,7 +144,7 @@ export class Transaction {
             selectAllTokenUtxos(this.inputs, this.outputs);
         }
         if (this.tokenChange) {
-            const tokenChangeOutputs = createFungibleTokenChangeOutputs(tokenInputs, this.outputs, this.address);
+            const tokenChangeOutputs = createFungibleTokenChangeOutputs(tokenInputs, this.outputs, this.contract.tokenAddress);
             this.outputs.push(...tokenChangeOutputs);
         }
         // Construct list with all nfts in inputs
@@ -268,7 +224,7 @@ export class Transaction {
                             commitment: unusedNft.commitment,
                         },
                     };
-                    const nftChangeOutput = { to: this.address, amount: BigInt(1000), token: tokenDetails };
+                    const nftChangeOutput = { to: this.contract.tokenAddress, amount: BigInt(1000), token: tokenDetails };
                     this.outputs.push(nftChangeOutput);
                 }
             }
@@ -277,11 +233,11 @@ export class Transaction {
         const placeholderArgs = this.args.map((arg) => (arg instanceof SignatureTemplate ? placeholder(65) : arg));
         // Create a placeholder preimage of the correct size
         const placeholderPreimage = this.abiFunction.covenant
-            ? placeholder(getPreimageSize(scriptToBytecode(this.redeemScript)))
+            ? placeholder(getPreimageSize(scriptToBytecode(this.contract.redeemScript)))
             : undefined;
         // Create a placeholder input script for size calculation using the placeholder
         // arguments and correctly sized placeholder preimage
-        const placeholderScript = createInputScript(this.redeemScript, placeholderArgs, this.selector, placeholderPreimage);
+        const placeholderScript = createInputScript(this.contract.redeemScript, placeholderArgs, this.selector, placeholderPreimage);
         // Add one extra byte per input to over-estimate tx-in count
         const contractInputSize = getInputSize(placeholderScript) + 1;
         // Note that we use the addPrecision function to add "decimal points" to BigInt numbers
@@ -331,11 +287,11 @@ export class Transaction {
         }
         // Account for the fee of adding a change output
         if (!this.hardcodedFee) {
-            const changeOutputSize = getOutputSize({ to: this.address, amount: 0n });
+            const changeOutputSize = getOutputSize({ to: this.contract.address, amount: 0n });
             change -= BigInt(changeOutputSize * this.feePerByte);
         }
         // Add a change output if applicable
-        const changeOutput = { to: this.address, amount: change };
+        const changeOutput = { to: this.contract.address, amount: change };
         if (change >= this.minChange && change >= calculateDust(changeOutput)) {
             this.outputs.push(changeOutput);
         }

package/dist/TransactionBuilder.js

@@ -1,7 +1,7 @@
 import { binToHex, decodeTransaction, encodeTransaction, hexToBin, } from '@bitauth/libauth';
 import delay from 'delay';
 import { isUnlockableUtxo, } from './interfaces.js';
-import { buildError, cashScriptOutputToLibauthOutput, createOpReturnOutput } from './utils.js';
+import { buildError, cashScriptOutputToLibauthOutput, createOpReturnOutput, validateOutput, } from './utils.js';
 const DEFAULT_SEQUENCE = 0xfffffffe;
 export class TransactionBuilder {
     constructor(options) {
@@ -26,10 +26,10 @@ export class TransactionBuilder {
         return this;
     }
     addOutput(output) {
-        this.outputs.push(output);
-        return this;
+        return this.addOutputs([output]);
     }
     addOutputs(outputs) {
+        outputs.forEach(validateOutput);
         this.outputs = this.outputs.concat(outputs);
         return this;
     }

package/dist/index.d.ts

@@ -6,6 +6,6 @@ export { TransactionBuilder } from './TransactionBuilder.js';
 export { Argument, encodeArgument } from './Argument.js';
 export { Artifact, AbiFunction, AbiInput } from '@cashscript/utils';
 export * as utils from '@cashscript/utils';
-export { Utxo, Recipient, SignatureAlgorithm, HashType, Network, isUtxoP2PKH, } from './interfaces.js';
+export * from './interfaces.js';
 export * from './Errors.js';
 export { NetworkProvider, BitcoinRpcNetworkProvider, ElectrumNetworkProvider, FullStackNetworkProvider, } from './network/index.js';

package/dist/index.js

@@ -5,7 +5,7 @@ export { Transaction } from './Transaction.js';
 export { TransactionBuilder } from './TransactionBuilder.js';
 export { encodeArgument } from './Argument.js';
 export * as utils from '@cashscript/utils';
-export { SignatureAlgorithm, HashType, Network, isUtxoP2PKH, } from './interfaces.js';
+export * from './interfaces.js';
 export * from './Errors.js';
 export { BitcoinRpcNetworkProvider, ElectrumNetworkProvider, FullStackNetworkProvider, } from './network/index.js';
 //# sourceMappingURL=index.js.map

package/dist/utils.d.ts

@@ -1,9 +1,9 @@
 import { Transaction } from '@bitauth/libauth';
 import { Script } from '@cashscript/utils';
-import { Utxo, Output, Recipient, LibauthOutput } from './interfaces.js';
+import { Utxo, Output, LibauthOutput } from './interfaces.js';
 import { FailedTransactionError } from './Errors.js';
-export declare function validateRecipient(recipient: Recipient): void;
-export declare function calculateDust(recipient: Recipient): number;
+export declare function validateOutput(output: Output): void;
+export declare function calculateDust(output: Output): number;
 export declare function getOutputSize(output: Output): number;
 export declare function encodeOutput(output: Output): Uint8Array;
 export declare function cashScriptOutputToLibauthOutput(output: Output): LibauthOutput;

package/dist/utils.js

@@ -1,22 +1,24 @@
-import { cashAddressToLockingBytecode, decodeCashAddress, addressContentsToLockingBytecode, lockingBytecodeToCashAddress, binToHex, generateSigningSerializationBCH, utf8ToBin, hexToBin, flattenBinArray, LockingBytecodeType, encodeTransactionOutput, } from '@bitauth/libauth';
+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 { Network, } from './interfaces.js';
 import { VERSION_SIZE, LOCKTIME_SIZE } from './constants.js';
 import { OutputSatoshisTooSmallError, TokensToNonTokenAddressError, Reason, FailedTransactionError, FailedRequireError, FailedTimeCheckError, FailedSigCheckError, } from './Errors.js';
 // ////////// PARAMETER VALIDATION ////////////////////////////////////////////
-export function validateRecipient(recipient) {
-    const minimumAmount = calculateDust(recipient);
-    if (recipient.amount < minimumAmount) {
-        throw new OutputSatoshisTooSmallError(recipient.amount, BigInt(minimumAmount));
+export function validateOutput(output) {
+    if (typeof output.to !== 'string')
+        return;
+    const minimumAmount = calculateDust(output);
+    if (output.amount < minimumAmount) {
+        throw new OutputSatoshisTooSmallError(output.amount, BigInt(minimumAmount));
     }
-    if (recipient.token) {
-        if (!isTokenAddress(recipient.to)) {
-            throw new TokensToNonTokenAddressError(recipient.to);
+    if (output.token) {
+        if (!isTokenAddress(output.to)) {
+            throw new TokensToNonTokenAddressError(output.to);
         }
     }
 }
-export function calculateDust(recipient) {
-    const outputSize = getOutputSize(recipient);
+export function calculateDust(output) {
+    const outputSize = getOutputSize(output);
     // Formula used to calculate the minimum allowed output
     const dustAmount = 444 + outputSize * 3;
     return dustAmount;
@@ -29,6 +31,14 @@ export function encodeOutput(output) {
     return encodeTransactionOutput(cashScriptOutputToLibauthOutput(output));
 }
 export function cashScriptOutputToLibauthOutput(output) {
+    if (output.token) {
+        if (typeof output.token.category !== 'string' || !isHex(output.token.category)) {
+            throw new Error(`Provided token category ${output.token?.category} is not a hex string`);
+        }
+        if (output.token.nft && (typeof output.token.nft.commitment !== 'string' || !isHex(output.token.nft.commitment))) {
+            throw new Error(`Provided token commitment ${output.token.nft?.commitment} is not a hex string`);
+        }
+    }
     return {
         lockingBytecode: typeof output.to === 'string' ? addressToLockScript(output.to) : output.to,
         valueSatoshis: output.amount,
@@ -92,7 +102,7 @@ export function getTxSizeWithoutInputs(outputs) {
     let size = VERSION_SIZE + LOCKTIME_SIZE;
     size += outputs.reduce((acc, output) => acc + getOutputSize(output), 0);
     // Add tx-out count (accounting for a potential change output)
-    size += encodeInt(BigInt(outputs.length + 1)).byteLength;
+    size += bigIntToCompactSize(BigInt(outputs.length + 1)).byteLength;
     return size;
 }
 // ////////// BUILD OBJECTS ///////////////////////////////////////////////////

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cashscript",
-  "version": "0.9.1",
+  "version": "0.9.3",
   "description": "Easily write and interact with Bitcoin Cash contracts",
   "keywords": [
     "bitcoin cash",
@@ -44,7 +44,7 @@
   },
   "dependencies": {
     "@bitauth/libauth": "^2.0.0-alpha.8",
-    "@cashscript/utils": "^0.9.1",
+    "@cashscript/utils": "^0.9.3",
     "bip68": "^1.0.4",
     "bitcoin-rpc-promise-retry": "^1.3.0",
     "delay": "^5.0.0",
@@ -59,5 +59,5 @@
     "jest": "^29.4.1",
     "typescript": "^4.1.5"
   },
-  "gitHead": "0043ea317d554436cf2c8927e82a8a8a04bee615"
+  "gitHead": "01f9b9bb552c3c4d63b0c7c8f065a0e23b536ca6"
 }