cashscript 0.10.0-next.4 → 0.10.0-next.6

package/README.md

@@ -8,7 +8,7 @@
 
 CashScript is a high-level programming language for smart contracts on Bitcoin Cash. It offers a strong abstraction layer over Bitcoin Cash' native virtual machine, Bitcoin Script. Its syntax is based on Ethereum's smart contract language Solidity, but its functionality is very different since smart contracts on Bitcoin Cash differ greatly from smart contracts on Ethereum. For a detailed comparison of them, refer to the blog post [*Smart Contracts on Ethereum, Bitcoin and Bitcoin Cash*](https://kalis.me/smart-contracts-eth-btc-bch/).
 
-See the [GitHub repository](https://github.com/Bitcoin-com/cashscript) and the [CashScript website](https://cashscript.org) for full documentation and usage examples.
+See the [GitHub repository](https://github.com/CashScript/cashscript) and the [CashScript website](https://cashscript.org) for full documentation and usage examples.
 
 ## The CashScript Language
 CashScript is a high-level language that allows you to write Bitcoin Cash smart contracts in a straightforward and familiar way. Its syntax is inspired by Ethereum's Solidity language, but its functionality is different since the underlying systems have very different fundamentals. See the [language documentation](https://cashscript.org/docs/language/) for a full reference of the language.

package/dist/Argument.d.ts

@@ -1,3 +1,9 @@
+import { AbiFunction, Artifact } from '@cashscript/utils';
 import SignatureTemplate from './SignatureTemplate.js';
 export declare type Argument = bigint | boolean | string | Uint8Array | SignatureTemplate;
-export declare function encodeArgument(argument: Argument, typeStr: string): Uint8Array | SignatureTemplate;
+export declare type EncodedArgument = Uint8Array | SignatureTemplate;
+export declare type EncodeFunction = (arg: Argument, typeStr: string) => EncodedArgument;
+export declare function encodeArgument(argument: Argument, typeStr: string): EncodedArgument;
+export declare const encodeConstructorArguments: (artifact: Artifact, constructorArgs: Argument[], encodeFunction?: EncodeFunction) => Uint8Array[];
+export declare const encodeFunctionArguments: (abiFunction: AbiFunction, functionArgs: Argument[], encodeFunction?: EncodeFunction) => EncodedArgument[];
+export declare function encodeArgumentForLibauthTemplate(argument: Argument, typeStr: string): Uint8Array | SignatureTemplate;

package/dist/Argument.js

@@ -39,7 +39,7 @@ export function encodeArgument(argument, typeStr) {
     if (type === PrimitiveType.SIG && argument.byteLength !== 0) {
         type = new BytesType(65);
     }
-    // Redefine SIG as a bytes64 so it is included in the size checks below
+    // Redefine DATASIG as a bytes64 so it is included in the size checks below
     // Note that ONLY Schnorr signatures are accepted
     if (type === PrimitiveType.DATASIG && argument.byteLength !== 0) {
         type = new BytesType(64);
@@ -50,4 +50,24 @@ export function encodeArgument(argument, typeStr) {
     }
     return argument;
 }
+export const encodeConstructorArguments = (artifact, constructorArgs, encodeFunction = encodeArgument) => {
+    // Check there's no signature templates in the constructor
+    if (constructorArgs.some((arg) => arg instanceof SignatureTemplate)) {
+        throw new Error('Cannot use signatures in constructor');
+    }
+    const encodedArgs = constructorArgs
+        .map((arg, i) => encodeFunction(arg, artifact.constructorInputs[i].type));
+    return encodedArgs;
+};
+export const encodeFunctionArguments = (abiFunction, functionArgs, encodeFunction = encodeArgument) => {
+    const encodedArgs = functionArgs.map((arg, i) => encodeFunction(arg, abiFunction.inputs[i].type));
+    return encodedArgs;
+};
+// Note: BitAuth IDE requires 0 to be encoded as a single byte (rather than the default empty byte array)
+// TODO: Double check this with Pat
+export function encodeArgumentForLibauthTemplate(argument, typeStr) {
+    if (typeStr === PrimitiveType.INT && argument === 0n)
+        return Uint8Array.from([0]);
+    return encodeArgument(argument, typeStr);
+}
 //# sourceMappingURL=Argument.js.map

package/dist/Contract.d.ts

@@ -1,11 +1,10 @@
 import { Artifact, Script } from '@cashscript/utils';
 import { Transaction } from './Transaction.js';
 import { Argument } from './Argument.js';
-import { Unlocker, ContractOptions, Utxo } from './interfaces.js';
+import { Unlocker, ContractOptions, Utxo, AddressType } from './interfaces.js';
 import NetworkProvider from './network/NetworkProvider.js';
 export declare class Contract {
     artifact: Artifact;
-    constructorArgs: Argument[];
     private options?;
     name: string;
     address: string;
@@ -17,7 +16,8 @@ export declare class Contract {
     unlock: Record<string, ContractUnlocker>;
     redeemScript: Script;
     provider: NetworkProvider;
-    addressType: 'p2sh20' | 'p2sh32';
+    addressType: AddressType;
+    encodedConstructorArgs: Uint8Array[];
     constructor(artifact: Artifact, constructorArgs: Argument[], options?: ContractOptions | undefined);
     getBalance(): Promise<bigint>;
     getUtxos(): Promise<Utxo[]>;

package/dist/Contract.js

@@ -1,14 +1,13 @@
 import { binToHex } from '@bitauth/libauth';
 import { asmToScript, calculateBytesize, countOpcodes, generateRedeemScript, hash256, scriptToBytecode, } from '@cashscript/utils';
 import { Transaction } from './Transaction.js';
-import { encodeArgument } from './Argument.js';
+import { encodeArgument, encodeConstructorArguments, encodeFunctionArguments } from './Argument.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.constructorArgs = constructorArgs;
         this.options = options;
         this.provider = this.options?.provider ?? new ElectrumNetworkProvider();
         this.addressType = this.options?.addressType ?? 'p2sh32';
@@ -17,17 +16,11 @@ export class Contract {
             throw new Error('Invalid or incomplete artifact provided');
         }
         if (artifact.constructorInputs.length !== constructorArgs.length) {
-            throw new Error(`Incorrect number of arguments passed to ${artifact.contractName} constructor`);
+            throw new Error(`Incorrect number of arguments passed to ${artifact.contractName} constructor. Expected ${artifact.constructorInputs.length} arguments (${artifact.constructorInputs.map(input => input.type)}) but got ${constructorArgs.length}`);
         }
         // Encode arguments (this also performs type checking)
-        const encodedArgs = constructorArgs
-            .map((arg, i) => encodeArgument(arg, artifact.constructorInputs[i].type))
-            .reverse();
-        // Check there's no signature templates in the constructor
-        if (encodedArgs.some((arg) => arg instanceof SignatureTemplate)) {
-            throw new Error('Cannot use signatures in constructor');
-        }
-        this.redeemScript = generateRedeemScript(asmToScript(this.artifact.bytecode), encodedArgs);
+        this.encodedConstructorArgs = encodeConstructorArguments(artifact, constructorArgs);
+        this.redeemScript = generateRedeemScript(asmToScript(this.artifact.bytecode), this.encodedConstructorArgs);
         // Populate the functions object with the contract's functions
         // (with a special case for single function, which has no "function selector")
         this.functions = {};
@@ -69,17 +62,19 @@ export class Contract {
     createFunction(abiFunction, selector) {
         return (...args) => {
             if (abiFunction.inputs.length !== args.length) {
-                throw new Error(`Incorrect number of arguments passed to function ${abiFunction.name}`);
+                throw new Error(`Incorrect number of arguments passed to function ${abiFunction.name}. Expected ${abiFunction.inputs.length} arguments (${abiFunction.inputs.map(input => input.type)}) but got ${args.length}`);
             }
             // Encode passed args (this also performs type checking)
-            const encodedArgs = args
-                .map((arg, i) => encodeArgument(arg, abiFunction.inputs[i].type));
+            const encodedArgs = encodeFunctionArguments(abiFunction, args);
             const unlocker = this.createUnlocker(abiFunction, selector)(...args);
             return new Transaction(this, unlocker, abiFunction, encodedArgs, selector);
         };
     }
     createUnlocker(abiFunction, selector) {
         return (...args) => {
+            if (abiFunction.inputs.length !== args.length) {
+                throw new Error(`Incorrect number of arguments passed to function ${abiFunction.name}. Expected ${abiFunction.inputs.length} arguments (${abiFunction.inputs.map(input => input.type)}) but got ${args.length}`);
+            }
             const bytecode = scriptToBytecode(this.redeemScript);
             const encodedArgs = args
                 .map((arg, i) => encodeArgument(arg, abiFunction.inputs[i].type));

package/dist/Errors.d.ts

@@ -1,4 +1,4 @@
-import { Type } from '@cashscript/utils';
+import { RequireStatement, Type } from '@cashscript/utils';
 export declare class TypeError extends Error {
     constructor(actual: string, expected: Type);
 }
@@ -10,16 +10,18 @@ export declare class TokensToNonTokenAddressError extends Error {
 }
 export declare class FailedTransactionError extends Error {
     reason: string;
-    debugStr?: string | undefined;
-    constructor(reason: string, debugStr?: string | undefined);
+    bitauthUri?: string | undefined;
+    constructor(reason: string, bitauthUri?: string | undefined);
 }
-export declare class FailedRequireError extends FailedTransactionError {
+export declare class FailedRequireError extends Error {
+    contractName: string;
+    requireStatement: RequireStatement;
+    inputIndex: number;
+    libauthErrorMessage?: string | undefined;
+    bitauthUri?: string;
+    constructor(contractName: string, requireStatement: RequireStatement, inputIndex: number, libauthErrorMessage?: string | undefined);
 }
-export declare class FailedTimeCheckError extends FailedTransactionError {
-}
-export declare class FailedSigCheckError extends FailedTransactionError {
-}
-export declare enum Reason {
+export declare enum NodeErrorReason {
     EVAL_FALSE = "Script evaluated without error but finished with a false/empty top stack element",
     VERIFY = "Script failed an OP_VERIFY operation",
     EQUALVERIFY = "Script failed an OP_EQUALVERIFY operation",

package/dist/Errors.js

@@ -14,66 +14,72 @@ export class TokensToNonTokenAddressError extends Error {
     }
 }
 export class FailedTransactionError extends Error {
-    constructor(reason, debugStr) {
-        super(`Transaction failed with reason: ${reason}${debugStr ? `\n\n${debugStr}` : ''}`);
+    constructor(reason, bitauthUri) {
+        super(`${reason}\n\nBitauth URI: ${bitauthUri}`);
         this.reason = reason;
-        this.debugStr = debugStr;
+        this.bitauthUri = bitauthUri;
     }
 }
-export class FailedRequireError extends FailedTransactionError {
-}
-export class FailedTimeCheckError extends FailedTransactionError {
-}
-export class FailedSigCheckError extends FailedTransactionError {
+// TODO: Add tests for some non-require evaluation errors (e.g. invalid op_split range)
+export class FailedRequireError extends Error {
+    constructor(contractName, requireStatement, inputIndex, libauthErrorMessage) {
+        const baseMessage = `${contractName}.cash:${requireStatement.line} Require statement failed at line ${requireStatement.line}`;
+        const fullMessage = `${baseMessage} with the following message: ${requireStatement.message}`;
+        super(requireStatement.message ? fullMessage : baseMessage);
+        this.contractName = contractName;
+        this.requireStatement = requireStatement;
+        this.inputIndex = inputIndex;
+        this.libauthErrorMessage = libauthErrorMessage;
+    }
 }
 // TODO: Expand these reasons with non-script failures (like tx-mempool-conflict)
-export var Reason;
-(function (Reason) {
-    Reason["EVAL_FALSE"] = "Script evaluated without error but finished with a false/empty top stack element";
-    Reason["VERIFY"] = "Script failed an OP_VERIFY operation";
-    Reason["EQUALVERIFY"] = "Script failed an OP_EQUALVERIFY operation";
-    Reason["CHECKMULTISIGVERIFY"] = "Script failed an OP_CHECKMULTISIGVERIFY operation";
-    Reason["CHECKSIGVERIFY"] = "Script failed an OP_CHECKSIGVERIFY operation";
-    Reason["CHECKDATASIGVERIFY"] = "Script failed an OP_CHECKDATASIGVERIFY operation";
-    Reason["NUMEQUALVERIFY"] = "Script failed an OP_NUMEQUALVERIFY operation";
-    Reason["SCRIPT_SIZE"] = "Script is too big";
-    Reason["PUSH_SIZE"] = "Push value size limit exceeded";
-    Reason["OP_COUNT"] = "Operation limit exceeded";
-    Reason["STACK_SIZE"] = "Stack size limit exceeded";
-    Reason["SIG_COUNT"] = "Signature count negative or greater than pubkey count";
-    Reason["PUBKEY_COUNT"] = "Pubkey count negative or limit exceeded";
-    Reason["INVALID_OPERAND_SIZE"] = "Invalid operand size";
-    Reason["INVALID_NUMBER_RANGE"] = "Given operand is not a number within the valid range";
-    Reason["IMPOSSIBLE_ENCODING"] = "The requested encoding is impossible to satisfy";
-    Reason["INVALID_SPLIT_RANGE"] = "Invalid OP_SPLIT range";
-    Reason["INVALID_BIT_COUNT"] = "Invalid number of bit set in OP_CHECKMULTISIG";
-    Reason["BAD_OPCODE"] = "Opcode missing or not understood";
-    Reason["DISABLED_OPCODE"] = "Attempted to use a disabled opcode";
-    Reason["INVALID_STACK_OPERATION"] = "Operation not valid with the current stack size";
-    Reason["INVALID_ALTSTACK_OPERATION"] = "Operation not valid with the current altstack size";
-    Reason["OP_RETURN"] = "OP_RETURN was encountered";
-    Reason["UNBALANCED_CONDITIONAL"] = "Invalid OP_IF construction";
-    Reason["DIV_BY_ZERO"] = "Division by zero error";
-    Reason["MOD_BY_ZERO"] = "Modulo by zero error";
-    Reason["INVALID_BITFIELD_SIZE"] = "Bitfield of unexpected size error";
-    Reason["INVALID_BIT_RANGE"] = "Bitfield's bit out of the expected range";
-    Reason["NEGATIVE_LOCKTIME"] = "Negative locktime";
-    Reason["UNSATISFIED_LOCKTIME"] = "Locktime requirement not satisfied";
-    Reason["SIG_HASHTYPE"] = "Signature hash type missing or not understood";
-    Reason["SIG_DER"] = "Non-canonical DER signature";
-    Reason["MINIMALDATA"] = "Data push larger than necessary";
-    Reason["SIG_PUSHONLY"] = "Only push operators allowed in signature scripts";
-    Reason["SIG_HIGH_S"] = "Non-canonical signature: S value is unnecessarily high";
-    Reason["MINIMALIF"] = "OP_IF/NOTIF argument must be minimal";
-    Reason["SIG_NULLFAIL"] = "Signature must be zero for failed CHECK(MULTI)SIG operation";
-    Reason["SIG_BADLENGTH"] = "Signature cannot be 65 bytes in CHECKMULTISIG";
-    Reason["SIG_NONSCHNORR"] = "Only Schnorr signatures allowed in this operation";
-    Reason["DISCOURAGE_UPGRADABLE_NOPS"] = "NOPx reserved for soft-fork upgrades";
-    Reason["PUBKEYTYPE"] = "Public key is neither compressed or uncompressed";
-    Reason["CLEANSTACK"] = "Script did not clean its stack";
-    Reason["NONCOMPRESSED_PUBKEY"] = "Using non-compressed public key";
-    Reason["ILLEGAL_FORKID"] = "Illegal use of SIGHASH_FORKID";
-    Reason["MUST_USE_FORKID"] = "Signature must use SIGHASH_FORKID";
-    Reason["UNKNOWN"] = "unknown error";
-})(Reason || (Reason = {}));
+export var NodeErrorReason;
+(function (NodeErrorReason) {
+    NodeErrorReason["EVAL_FALSE"] = "Script evaluated without error but finished with a false/empty top stack element";
+    NodeErrorReason["VERIFY"] = "Script failed an OP_VERIFY operation";
+    NodeErrorReason["EQUALVERIFY"] = "Script failed an OP_EQUALVERIFY operation";
+    NodeErrorReason["CHECKMULTISIGVERIFY"] = "Script failed an OP_CHECKMULTISIGVERIFY operation";
+    NodeErrorReason["CHECKSIGVERIFY"] = "Script failed an OP_CHECKSIGVERIFY operation";
+    NodeErrorReason["CHECKDATASIGVERIFY"] = "Script failed an OP_CHECKDATASIGVERIFY operation";
+    NodeErrorReason["NUMEQUALVERIFY"] = "Script failed an OP_NUMEQUALVERIFY operation";
+    NodeErrorReason["SCRIPT_SIZE"] = "Script is too big";
+    NodeErrorReason["PUSH_SIZE"] = "Push value size limit exceeded";
+    NodeErrorReason["OP_COUNT"] = "Operation limit exceeded";
+    NodeErrorReason["STACK_SIZE"] = "Stack size limit exceeded";
+    NodeErrorReason["SIG_COUNT"] = "Signature count negative or greater than pubkey count";
+    NodeErrorReason["PUBKEY_COUNT"] = "Pubkey count negative or limit exceeded";
+    NodeErrorReason["INVALID_OPERAND_SIZE"] = "Invalid operand size";
+    NodeErrorReason["INVALID_NUMBER_RANGE"] = "Given operand is not a number within the valid range";
+    NodeErrorReason["IMPOSSIBLE_ENCODING"] = "The requested encoding is impossible to satisfy";
+    NodeErrorReason["INVALID_SPLIT_RANGE"] = "Invalid OP_SPLIT range";
+    NodeErrorReason["INVALID_BIT_COUNT"] = "Invalid number of bit set in OP_CHECKMULTISIG";
+    NodeErrorReason["BAD_OPCODE"] = "Opcode missing or not understood";
+    NodeErrorReason["DISABLED_OPCODE"] = "Attempted to use a disabled opcode";
+    NodeErrorReason["INVALID_STACK_OPERATION"] = "Operation not valid with the current stack size";
+    NodeErrorReason["INVALID_ALTSTACK_OPERATION"] = "Operation not valid with the current altstack size";
+    NodeErrorReason["OP_RETURN"] = "OP_RETURN was encountered";
+    NodeErrorReason["UNBALANCED_CONDITIONAL"] = "Invalid OP_IF construction";
+    NodeErrorReason["DIV_BY_ZERO"] = "Division by zero error";
+    NodeErrorReason["MOD_BY_ZERO"] = "Modulo by zero error";
+    NodeErrorReason["INVALID_BITFIELD_SIZE"] = "Bitfield of unexpected size error";
+    NodeErrorReason["INVALID_BIT_RANGE"] = "Bitfield's bit out of the expected range";
+    NodeErrorReason["NEGATIVE_LOCKTIME"] = "Negative locktime";
+    NodeErrorReason["UNSATISFIED_LOCKTIME"] = "Locktime requirement not satisfied";
+    NodeErrorReason["SIG_HASHTYPE"] = "Signature hash type missing or not understood";
+    NodeErrorReason["SIG_DER"] = "Non-canonical DER signature";
+    NodeErrorReason["MINIMALDATA"] = "Data push larger than necessary";
+    NodeErrorReason["SIG_PUSHONLY"] = "Only push operators allowed in signature scripts";
+    NodeErrorReason["SIG_HIGH_S"] = "Non-canonical signature: S value is unnecessarily high";
+    NodeErrorReason["MINIMALIF"] = "OP_IF/NOTIF argument must be minimal";
+    NodeErrorReason["SIG_NULLFAIL"] = "Signature must be zero for failed CHECK(MULTI)SIG operation";
+    NodeErrorReason["SIG_BADLENGTH"] = "Signature cannot be 65 bytes in CHECKMULTISIG";
+    NodeErrorReason["SIG_NONSCHNORR"] = "Only Schnorr signatures allowed in this operation";
+    NodeErrorReason["DISCOURAGE_UPGRADABLE_NOPS"] = "NOPx reserved for soft-fork upgrades";
+    NodeErrorReason["PUBKEYTYPE"] = "Public key is neither compressed or uncompressed";
+    NodeErrorReason["CLEANSTACK"] = "Script did not clean its stack";
+    NodeErrorReason["NONCOMPRESSED_PUBKEY"] = "Using non-compressed public key";
+    NodeErrorReason["ILLEGAL_FORKID"] = "Illegal use of SIGHASH_FORKID";
+    NodeErrorReason["MUST_USE_FORKID"] = "Signature must use SIGHASH_FORKID";
+    NodeErrorReason["UNKNOWN"] = "unknown error";
+})(NodeErrorReason || (NodeErrorReason = {}));
 //# sourceMappingURL=Errors.js.map

package/dist/LibauthTemplate.d.ts

@@ -1,8 +1,17 @@
 import { WalletTemplate } from '@bitauth/libauth';
 import { Transaction } from './Transaction.js';
-export declare const stringify: (any: any, spaces?: number | undefined) => string;
-export declare const buildTemplate: ({ transaction, transactionHex, }: {
+interface BuildTemplateOptions {
     transaction: Transaction;
-    transactionHex?: string | undefined;
-}) => Promise<WalletTemplate>;
+    transactionHex?: string;
+}
+export declare const buildTemplate: ({ transaction, transactionHex, }: BuildTemplateOptions) => Promise<WalletTemplate>;
 export declare const getBitauthUri: (template: WalletTemplate) => string;
+export interface LibauthTemplateTokenDetails {
+    amount: string;
+    category: string;
+    nft?: {
+        capability: 'none' | 'mutable' | 'minting';
+        commitment: string;
+    };
+}
+export {};