cashscript 0.8.1 → 0.9.0

package/dist/Contract.d.ts

@@ -1,7 +1,7 @@
 import { Artifact } from '@cashscript/utils';
 import { Transaction } from './Transaction.js';
 import { Argument } from './Argument.js';
-import { ContractOptions, Utxo } from './interfaces.js';
+import { Unlocker, ContractOptions, Utxo } from './interfaces.js';
 export declare class Contract {
     private artifact;
     private options?;
@@ -11,9 +11,8 @@ export declare class Contract {
     bytecode: string;
     bytesize: number;
     opcount: number;
-    functions: {
-        [name: string]: ContractFunction;
-    };
+    functions: Record<string, ContractFunction>;
+    unlock: Record<string, ContractUnlocker>;
     private redeemScript;
     private provider;
     private addressType;
@@ -21,5 +20,7 @@ export declare class Contract {
     getBalance(): Promise<bigint>;
     getUtxos(): Promise<Utxo[]>;
     private createFunction;
+    private createUnlocker;
 }
 export declare type ContractFunction = (...args: Argument[]) => Transaction;
+export declare type ContractUnlocker = (...args: Argument[]) => Unlocker;

package/dist/Contract.js

@@ -1,18 +1,16 @@
 import { binToHex } from '@bitauth/libauth';
-import { asmToScript, calculateBytesize, countOpcodes, generateRedeemScript, scriptToBytecode, } from '@cashscript/utils';
+import { asmToScript, calculateBytesize, countOpcodes, generateRedeemScript, hash256, scriptToBytecode, } from '@cashscript/utils';
 import { Transaction } from './Transaction.js';
 import { encodeArgument } from './Argument.js';
-import { scriptToAddress } from './utils.js';
+import { addressToLockScript, createInputScript, createSighashPreimage, scriptToAddress, } from './utils.js';
 import SignatureTemplate from './SignatureTemplate.js';
 import { ElectrumNetworkProvider } from './network/index.js';
 export class Contract {
     constructor(artifact, constructorArgs, options) {
         this.artifact = artifact;
         this.options = options;
-        const defaultProvider = new ElectrumNetworkProvider();
-        const defaultAddressType = 'p2sh32';
-        this.provider = this.options?.provider ?? defaultProvider;
-        this.addressType = this.options?.addressType ?? defaultAddressType;
+        this.provider = this.options?.provider ?? new ElectrumNetworkProvider();
+        this.addressType = this.options?.addressType ?? 'p2sh32';
         const expectedProperties = ['abi', 'bytecode', 'constructorInputs', 'contractName'];
         if (!expectedProperties.every((property) => property in artifact)) {
             throw new Error('Invalid or incomplete artifact provided');
@@ -41,6 +39,18 @@ export class Contract {
                 this.functions[f.name] = this.createFunction(f, i);
             });
         }
+        // Populate the functions object with the contract's functions
+        // (with a special case for single function, which has no "function selector")
+        this.unlock = {};
+        if (artifact.abi.length === 1) {
+            const f = artifact.abi[0];
+            this.unlock[f.name] = this.createUnlocker(f);
+        }
+        else {
+            artifact.abi.forEach((f, i) => {
+                this.unlock[f.name] = this.createUnlocker(f, i);
+            });
+        }
         this.name = artifact.contractName;
         this.address = scriptToAddress(this.redeemScript, this.provider.network, this.addressType, false);
         this.tokenAddress = scriptToAddress(this.redeemScript, this.provider.network, this.addressType, true);
@@ -66,5 +76,25 @@ export class Contract {
             return new Transaction(this.address, this.provider, this.redeemScript, abiFunction, encodedArgs, selector);
         };
     }
+    createUnlocker(abiFunction, selector) {
+        return (...args) => {
+            const bytecode = scriptToBytecode(this.redeemScript);
+            const encodedArgs = args
+                .map((arg, i) => encodeArgument(arg, abiFunction.inputs[i].type));
+            const generateUnlockingBytecode = ({ transaction, sourceOutputs, inputIndex }) => {
+                const completeArgs = encodedArgs.map((arg) => {
+                    if (!(arg instanceof SignatureTemplate))
+                        return arg;
+                    const preimage = createSighashPreimage(transaction, sourceOutputs, inputIndex, bytecode, arg.getHashType());
+                    const sighash = hash256(preimage);
+                    return arg.generateSignature(sighash);
+                });
+                const unlockingBytecode = createInputScript(this.redeemScript, completeArgs, selector);
+                return unlockingBytecode;
+            };
+            const generateLockingBytecode = () => addressToLockScript(this.address);
+            return { generateUnlockingBytecode, generateLockingBytecode };
+        };
+    }
 }
 //# sourceMappingURL=Contract.js.map

package/dist/Errors.d.ts

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

package/dist/Errors.js

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

package/dist/SignatureTemplate.d.ts

@@ -1,4 +1,4 @@
-import { HashType, SignatureAlgorithm } from './interfaces.js';
+import { Unlocker, HashType, SignatureAlgorithm } from './interfaces.js';
 export default class SignatureTemplate {
     private hashtype;
     private signatureAlgorithm;
@@ -7,6 +7,7 @@ export default class SignatureTemplate {
     generateSignature(payload: Uint8Array, bchForkId?: boolean): Uint8Array;
     getHashType(bchForkId?: boolean): number;
     getPublicKey(): Uint8Array;
+    unlockP2PKH(): Unlocker;
 }
 interface Keypair {
     toWIF(): string;

package/dist/SignatureTemplate.js

@@ -1,5 +1,7 @@
 import { decodePrivateKeyWif, secp256k1, SigningSerializationFlag } from '@bitauth/libauth';
-import { HashType, SignatureAlgorithm } from './interfaces.js';
+import { hash256, scriptToBytecode } from '@cashscript/utils';
+import { HashType, SignatureAlgorithm, } from './interfaces.js';
+import { createSighashPreimage, publicKeyToP2PKHLockingBytecode } from './utils.js';
 export default class SignatureTemplate {
     constructor(signer, hashtype = HashType.SIGHASH_ALL | HashType.SIGHASH_UTXOS, signatureAlgorithm = SignatureAlgorithm.SCHNORR) {
         this.hashtype = hashtype;
@@ -27,6 +29,21 @@ export default class SignatureTemplate {
     getPublicKey() {
         return secp256k1.derivePublicKeyCompressed(this.privateKey);
     }
+    unlockP2PKH() {
+        const publicKey = this.getPublicKey();
+        const prevOutScript = publicKeyToP2PKHLockingBytecode(publicKey);
+        const hashtype = this.getHashType();
+        return {
+            generateLockingBytecode: () => prevOutScript,
+            generateUnlockingBytecode: ({ transaction, sourceOutputs, inputIndex }) => {
+                const preimage = createSighashPreimage(transaction, sourceOutputs, inputIndex, prevOutScript, hashtype);
+                const sighash = hash256(preimage);
+                const signature = this.generateSignature(sighash);
+                const unlockingBytecode = scriptToBytecode([signature, publicKey]);
+                return unlockingBytecode;
+            },
+        };
+    }
 }
 function isKeypair(obj) {
     return typeof obj.toWIF === 'function';

package/dist/Transaction.js

@@ -1,12 +1,12 @@
+import bip68 from 'bip68';
 import { hexToBin, binToHex, encodeTransaction, decodeTransaction, } from '@bitauth/libauth';
 import delay from 'delay';
 import { hash256, placeholder, scriptToBytecode, } from '@cashscript/utils';
 import deepEqual from 'fast-deep-equal';
-import { isSignableUtxo, } from './interfaces.js';
+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 SignatureTemplate from './SignatureTemplate.js';
 import { P2PKH_INPUT_SIZE } from './constants.js';
-const bip68 = await import('bip68');
 export class Transaction {
     constructor(address, provider, redeemScript, abiFunction, args, selector) {
         this.address = address;
@@ -95,7 +95,7 @@ export class Transaction {
         const sourceOutputs = this.inputs.map((input) => {
             const sourceOutput = {
                 amount: input.satoshis,
-                to: isSignableUtxo(input) ? publicKeyToP2PKHLockingBytecode(input.template.getPublicKey()) : lockingBytecode,
+                to: isUtxoP2PKH(input) ? publicKeyToP2PKHLockingBytecode(input.template.getPublicKey()) : lockingBytecode,
                 token: input.token,
             };
             return cashScriptOutputToLibauthOutput(sourceOutput);
@@ -110,7 +110,7 @@ export class Transaction {
         const inputScripts = [];
         this.inputs.forEach((utxo, i) => {
             // UTXO's with signature templates are signed using P2PKH
-            if (isSignableUtxo(utxo)) {
+            if (isUtxoP2PKH(utxo)) {
                 const pubkey = utxo.template.getPublicKey();
                 const prevOutScript = publicKeyToP2PKHLockingBytecode(pubkey);
                 const hashtype = utxo.template.getHashType();
@@ -293,7 +293,7 @@ export class Transaction {
         if (this.inputs.length > 0) {
             // If inputs are already defined, the user provided the UTXOs and we perform no further UTXO selection
             if (!this.hardcodedFee) {
-                const totalInputSize = this.inputs.reduce((acc, input) => acc + (isSignableUtxo(input) ? P2PKH_INPUT_SIZE : contractInputSize), 0);
+                const totalInputSize = this.inputs.reduce((acc, input) => acc + (isUtxoP2PKH(input) ? P2PKH_INPUT_SIZE : contractInputSize), 0);
                 fee += addPrecision(totalInputSize * this.feePerByte);
             }
             satsAvailable = addPrecision(this.inputs.reduce((acc, input) => acc + input.satoshis, 0n));

package/dist/TransactionBuilder.d.ts

@@ -0,0 +1,26 @@
+import { Unlocker, Output, TransactionDetails, UnlockableUtxo, Utxo, InputOptions } from './interfaces.js';
+import { NetworkProvider } from './network/index.js';
+export interface TransactionBuilderOptions {
+    provider: NetworkProvider;
+}
+export declare class TransactionBuilder {
+    private provider;
+    private inputs;
+    private outputs;
+    private locktime;
+    private maxFee?;
+    constructor(options: TransactionBuilderOptions);
+    addInput(utxo: Utxo, unlocker: Unlocker, options?: InputOptions): this;
+    addInputs(utxos: Utxo[], unlocker: Unlocker, options?: InputOptions): this;
+    addInputs(utxos: UnlockableUtxo[]): this;
+    addOutput(output: Output): this;
+    addOutputs(outputs: Output[]): this;
+    addOpReturnOutput(chunks: string[]): this;
+    setLocktime(locktime: number): this;
+    setMaxFee(maxFee: bigint): this;
+    private checkMaxFee;
+    build(): string;
+    send(): Promise<TransactionDetails>;
+    send(raw: true): Promise<string>;
+    private getTxDetails;
+}

package/dist/TransactionBuilder.js

@@ -0,0 +1,118 @@
+import { binToHex, decodeTransaction, encodeTransaction, hexToBin, } from '@bitauth/libauth';
+import delay from 'delay';
+import { isUnlockableUtxo, } from './interfaces.js';
+import { buildError, cashScriptOutputToLibauthOutput, createOpReturnOutput } from './utils.js';
+const DEFAULT_SEQUENCE = 0xfffffffe;
+export class TransactionBuilder {
+    constructor(options) {
+        this.inputs = [];
+        this.outputs = [];
+        this.provider = options.provider;
+    }
+    addInput(utxo, unlocker, options) {
+        this.inputs.push({ ...utxo, unlocker, options });
+        return this;
+    }
+    addInputs(utxos, unlocker, options) {
+        if ((!unlocker && utxos.some((utxo) => !isUnlockableUtxo(utxo)))
+            || (unlocker && utxos.some((utxo) => isUnlockableUtxo(utxo)))) {
+            throw new Error('Either all UTXOs must have an individual unlocker speciifed, or no UTXOs must have an individual unlocker specified and a shared unlocker must be provided');
+        }
+        if (!unlocker) {
+            this.inputs = this.inputs.concat(utxos);
+            return this;
+        }
+        this.inputs = this.inputs.concat(utxos.map(((utxo) => ({ ...utxo, unlocker, options }))));
+        return this;
+    }
+    addOutput(output) {
+        this.outputs.push(output);
+        return this;
+    }
+    addOutputs(outputs) {
+        this.outputs = this.outputs.concat(outputs);
+        return this;
+    }
+    // TODO: allow uint8array for chunks
+    addOpReturnOutput(chunks) {
+        this.outputs.push(createOpReturnOutput(chunks));
+        return this;
+    }
+    setLocktime(locktime) {
+        this.locktime = locktime;
+        return this;
+    }
+    setMaxFee(maxFee) {
+        this.maxFee = maxFee;
+        return this;
+    }
+    checkMaxFee() {
+        if (!this.maxFee)
+            return;
+        const totalInputAmount = this.inputs.reduce((total, input) => total + input.satoshis, 0n);
+        const totalOutputAmount = this.outputs.reduce((total, output) => total + output.amount, 0n);
+        const fee = totalInputAmount - totalOutputAmount;
+        if (fee > this.maxFee) {
+            throw new Error(`Transaction fee of ${fee} is higher than max fee of ${this.maxFee}`);
+        }
+    }
+    build() {
+        this.checkMaxFee();
+        const inputs = this.inputs.map((utxo) => ({
+            outpointIndex: utxo.vout,
+            outpointTransactionHash: hexToBin(utxo.txid),
+            sequenceNumber: utxo.options?.sequence ?? DEFAULT_SEQUENCE,
+            unlockingBytecode: new Uint8Array(),
+        }));
+        const outputs = this.outputs.map(cashScriptOutputToLibauthOutput);
+        const transaction = {
+            inputs,
+            locktime: this.locktime,
+            outputs,
+            version: 2,
+        };
+        // Generate source outputs from inputs (for signing with SIGHASH_UTXOS)
+        const sourceOutputs = this.inputs.map((input) => {
+            const sourceOutput = {
+                amount: input.satoshis,
+                to: input.unlocker.generateLockingBytecode(),
+                token: input.token,
+            };
+            return cashScriptOutputToLibauthOutput(sourceOutput);
+        });
+        const inputScripts = this.inputs.map((input, inputIndex) => (input.unlocker.generateUnlockingBytecode({ transaction, sourceOutputs, inputIndex })));
+        inputScripts.forEach((script, i) => {
+            transaction.inputs[i].unlockingBytecode = script;
+        });
+        return binToHex(encodeTransaction(transaction));
+    }
+    async send(raw) {
+        const tx = this.build();
+        try {
+            const txid = await this.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);
+        }
+    }
+    async getTxDetails(txid, raw) {
+        for (let retries = 0; retries < 1200; retries += 1) {
+            await delay(500);
+            try {
+                const hex = await this.provider.getRawTransaction(txid);
+                if (raw)
+                    return hex;
+                const libauthTransaction = decodeTransaction(hexToBin(hex));
+                return { ...libauthTransaction, txid, hex };
+            }
+            catch (ignored) {
+                // ignored
+            }
+        }
+        // Should not happen
+        throw new Error('Could not retrieve transaction details for over 10 minutes');
+    }
+}
+//# sourceMappingURL=TransactionBuilder.js.map

package/dist/index.d.ts

@@ -5,6 +5,6 @@ export { Transaction } from './Transaction.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, isSignableUtxo, } from './interfaces.js';
+export { Utxo, Recipient, SignatureAlgorithm, HashType, Network, isUtxoP2PKH, } from './interfaces.js';
 export * from './Errors.js';
 export { NetworkProvider, BitcoinRpcNetworkProvider, ElectrumNetworkProvider, FullStackNetworkProvider, } from './network/index.js';

package/dist/index.js

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

package/dist/interfaces.d.ts

@@ -7,10 +7,27 @@ export interface Utxo {
     satoshis: bigint;
     token?: TokenDetails;
 }
-export interface SignableUtxo extends Utxo {
+export interface UnlockableUtxo extends Utxo {
+    unlocker: Unlocker;
+    options?: InputOptions;
+}
+export declare function isUnlockableUtxo(utxo: Utxo): utxo is UnlockableUtxo;
+export interface InputOptions {
+    sequence?: number;
+}
+export interface GenerateUnlockingBytecodeOptions {
+    transaction: Transaction;
+    sourceOutputs: LibauthOutput[];
+    inputIndex: number;
+}
+export interface Unlocker {
+    generateLockingBytecode: () => Uint8Array;
+    generateUnlockingBytecode: (options: GenerateUnlockingBytecodeOptions) => Uint8Array;
+}
+export interface UtxoP2PKH extends Utxo {
     template: SignatureTemplate;
 }
-export declare function isSignableUtxo(utxo: Utxo): utxo is SignableUtxo;
+export declare function isUtxoP2PKH(utxo: Utxo): utxo is UtxoP2PKH;
 export interface Recipient {
     to: string;
     amount: bigint;

package/dist/interfaces.js

@@ -1,4 +1,7 @@
-export function isSignableUtxo(utxo) {
+export function isUnlockableUtxo(utxo) {
+    return 'unlocker' in utxo;
+}
+export function isUtxoP2PKH(utxo) {
     return 'template' in utxo;
 }
 export var SignatureAlgorithm;

package/dist/network/BitcoinRpcNetworkProvider.js

@@ -1,4 +1,4 @@
-const { default: RpcClientRetry } = await import('bitcoin-rpc-promise-retry');
+import RpcClientRetry from 'bitcoin-rpc-promise-retry';
 export default class BitcoinRpcNetworkProvider {
     constructor(network, url, opts) {
         this.network = network;

package/dist/network/ElectrumNetworkProvider.d.ts

@@ -1,4 +1,4 @@
-import { ElectrumCluster } from 'electrum-cash';
+import { ElectrumCluster, RequestResponse } from 'electrum-cash';
 import { Utxo, Network } from '../interfaces.js';
 import NetworkProvider from './NetworkProvider.js';
 export default class ElectrumNetworkProvider implements NetworkProvider {
@@ -13,7 +13,7 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
     sendRawTransaction(txHex: string): Promise<string>;
     connectCluster(): Promise<void[]>;
     disconnectCluster(): Promise<boolean[]>;
-    private performRequest;
+    performRequest(name: string, ...parameters: (string | number | boolean)[]): Promise<RequestResponse>;
     private shouldConnect;
     private shouldDisconnect;
 }

package/dist/utils.d.ts

@@ -14,7 +14,7 @@ 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 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cashscript",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "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.8.1",
+    "@cashscript/utils": "^0.9.0",
     "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": "a70a5a57a938bc81fdf4180b1451cfcc0ff0214b"
+  "gitHead": "63d31cbb8def1fab291b2e76f5a7dc603f4c4bab"
 }