cashscript 0.10.1 → 0.10.3

package/README.md

@@ -14,7 +14,7 @@ See the [GitHub repository](https://github.com/CashScript/cashscript) and the [C
 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.
 
 ## The CashScript SDK
-The main way to interact with CashScript contracts and integrate them into applications is using the CashScript SDK. This SDK allows you to import `.json` artifact files that were compiled using the `cashc` compiler and convert them to `Contract` objects. These objects are used to create new contract instances. These instances are used to interact with the contracts using the functions that were implemented in the `.cash` file. For more information on the CashScript SDK, refer to the [SDK documentation](https://cashscript.org/docs/sdk/).
+The main way to interact with CashScript contracts and integrate them into applications is using the CashScript SDK. This SDK allows you to import `.json` (or `.ts`) artifact files that were compiled using the `cashc` compiler and convert them to `Contract` objects. These objects are used to create new contract instances. These instances are used to interact with the contracts using the functions that were implemented in the `.cash` file. For more information on the CashScript SDK, refer to the [SDK documentation](https://cashscript.org/docs/sdk/).
 
 ### Installation
 ```bash
@@ -31,7 +31,7 @@ Using the CashScript SDK, you can import contract artifact files, create new ins
 ```ts
 ...
   // Import the P2PKH artifact
-  import P2PKH from './p2pkh-artifact.json' assert { type: 'json' };
+  import P2PKH from './p2pkh-artifact.json' with { type: 'json' };
 
   // Instantiate a network provider for CashScript's network operations
   const provider = new ElectrumNetworkProvider('mainnet');

package/dist/Contract.d.ts

@@ -3,8 +3,17 @@ import { Transaction } from './Transaction.js';
 import { ConstructorArgument, FunctionArgument } from './Argument.js';
 import { Unlocker, ContractOptions, Utxo, AddressType } from './interfaces.js';
 import NetworkProvider from './network/NetworkProvider.js';
-export declare class Contract {
-    artifact: Artifact;
+import { ParamsToTuple, AbiToFunctionMap } from './types/type-inference.js';
+export declare class Contract<TArtifact extends Artifact = Artifact, TResolved extends {
+    constructorInputs: ConstructorArgument[];
+    functions: Record<string, any>;
+    unlock: Record<string, any>;
+} = {
+    constructorInputs: ParamsToTuple<TArtifact['constructorInputs']>;
+    functions: AbiToFunctionMap<TArtifact['abi'], Transaction>;
+    unlock: AbiToFunctionMap<TArtifact['abi'], Unlocker>;
+}> {
+    artifact: TArtifact;
     private options?;
     name: string;
     address: string;
@@ -12,13 +21,13 @@ export declare class Contract {
     bytecode: string;
     bytesize: number;
     opcount: number;
-    functions: Record<string, ContractFunction>;
-    unlock: Record<string, ContractUnlocker>;
+    functions: TResolved['functions'];
+    unlock: TResolved['unlock'];
     redeemScript: Script;
     provider: NetworkProvider;
     addressType: AddressType;
     encodedConstructorArgs: Uint8Array[];
-    constructor(artifact: Artifact, constructorArgs: ConstructorArgument[], options?: ContractOptions | undefined);
+    constructor(artifact: TArtifact, constructorArgs: TResolved['constructorInputs'], options?: ContractOptions | undefined);
     getBalance(): Promise<bigint>;
     getUtxos(): Promise<Utxo[]>;
     private createFunction;

package/dist/Contract.js

@@ -1,7 +1,7 @@
 import { binToHex } from '@bitauth/libauth';
 import { asmToScript, calculateBytesize, countOpcodes, generateRedeemScript, hash256, scriptToBytecode, } from '@cashscript/utils';
 import { Transaction } from './Transaction.js';
-import { encodeFunctionArgument, encodeConstructorArguments, encodeFunctionArguments } from './Argument.js';
+import { encodeFunctionArgument, encodeConstructorArguments, encodeFunctionArguments, } from './Argument.js';
 import { addressToLockScript, createInputScript, createSighashPreimage, scriptToAddress, } from './utils.js';
 import SignatureTemplate from './SignatureTemplate.js';
 import { ElectrumNetworkProvider } from './network/index.js';
@@ -16,7 +16,7 @@ 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. Expected ${artifact.constructorInputs.length} arguments (${artifact.constructorInputs.map(input => input.type)}) but got ${constructorArgs.length}`);
+            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)
         this.encodedConstructorArgs = encodeConstructorArguments(artifact, constructorArgs);
@@ -26,10 +26,12 @@ export class Contract {
         this.functions = {};
         if (artifact.abi.length === 1) {
             const f = artifact.abi[0];
+            // @ts-ignore TODO: see if we can use generics to make TypeScript happy
             this.functions[f.name] = this.createFunction(f);
         }
         else {
             artifact.abi.forEach((f, i) => {
+                // @ts-ignore TODO: see if we can use generics to make TypeScript happy
                 this.functions[f.name] = this.createFunction(f, i);
             });
         }
@@ -38,10 +40,12 @@ export class Contract {
         this.unlock = {};
         if (artifact.abi.length === 1) {
             const f = artifact.abi[0];
+            // @ts-ignore TODO: see if we can use generics to make TypeScript happy
             this.unlock[f.name] = this.createUnlocker(f);
         }
         else {
             artifact.abi.forEach((f, i) => {
+                // @ts-ignore TODO: see if we can use generics to make TypeScript happy
                 this.unlock[f.name] = this.createUnlocker(f, i);
             });
         }
@@ -62,7 +66,7 @@ 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}. Expected ${abiFunction.inputs.length} arguments (${abiFunction.inputs.map(input => input.type)}) but got ${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}`);
             }
             // Encode passed args (this also performs type checking)
             const encodedArgs = encodeFunctionArguments(abiFunction, args);
@@ -73,7 +77,7 @@ export class Contract {
     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}`);
+                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

package/dist/Transaction.js

@@ -1,9 +1,8 @@
-import bip68 from 'bip68';
 import { hexToBin, decodeTransaction, } from '@bitauth/libauth';
 import delay from 'delay';
-import { placeholder, scriptToBytecode, } from '@cashscript/utils';
+import { encodeBip68, placeholder, scriptToBytecode, } from '@cashscript/utils';
 import deepEqual from 'fast-deep-equal';
-import { isUtxoP2PKH, } from './interfaces.js';
+import { isUtxoP2PKH, SignatureAlgorithm, } from './interfaces.js';
 import { createInputScript, getInputSize, createOpReturnOutput, getTxSizeWithoutInputs, getPreimageSize, validateOutput, utxoComparator, calculateDust, getOutputSize, utxoTokenComparator, } from './utils.js';
 import SignatureTemplate from './SignatureTemplate.js';
 import { P2PKH_INPUT_SIZE } from './constants.js';
@@ -57,7 +56,7 @@ export class Transaction {
         return this;
     }
     withAge(age) {
-        this.sequence = bip68.encode({ blocks: age });
+        this.sequence = encodeBip68({ blocks: age });
         return this;
     }
     withTime(time) {
@@ -248,8 +247,18 @@ export class Transaction {
                 }
             }
         }
-        // Replace all SignatureTemplate with 65-length placeholder Uint8Arrays
-        const placeholderArgs = this.encodedFunctionArgs.map((arg) => (arg instanceof SignatureTemplate ? placeholder(65) : arg));
+        // Replace all SignatureTemplate with placeholder Uint8Arrays
+        const placeholderArgs = this.encodedFunctionArgs.map((arg) => {
+            if (!(arg instanceof SignatureTemplate))
+                return arg;
+            // Schnorr signatures are *always* 65 bytes: 64 for signature + 1 byte for hashtype.
+            if (arg.getSignatureAlgorithm() === SignatureAlgorithm.SCHNORR)
+                return placeholder(65);
+            // ECDSA signatures are at least 71 bytes: 64 bytes for signature + 1 byte for hashtype + 6 bytes for encoding
+            // overhead. But it may have up to 2 extra bytes for padding, so we overestimate by 2 bytes.
+            // (see https://transactionfee.info/charts/bitcoin-script-ecdsa-length/)
+            return placeholder(73);
+        });
         // Create a placeholder preimage of the correct size
         const placeholderPreimage = this.abiFunction.covenant
             ? placeholder(getPreimageSize(scriptToBytecode(this.contract.redeemScript)))

package/dist/network/BitcoinRpcNetworkProvider.d.ts

@@ -1,40 +1,16 @@
 import { Utxo, Network } from '../interfaces.js';
 import NetworkProvider from './NetworkProvider.js';
+import { BchnRpcClient } from '@mr-zwets/bchn-api-wrapper';
 export default class BitcoinRpcNetworkProvider implements NetworkProvider {
     network: Network;
     private rpcClient;
-    constructor(network: Network, url: string, opts?: object);
+    constructor(network: Network, url: string, opts: {
+        rpcUser: string;
+        rpcPassword: string;
+    });
     getUtxos(address: string): Promise<Utxo[]>;
     getBlockHeight(): Promise<number>;
     getRawTransaction(txid: string): Promise<string>;
     sendRawTransaction(txHex: string): Promise<string>;
-    getClient(): IRpcClientRetry;
+    getClient(): BchnRpcClient;
 }
-interface ListUnspentItem {
-    txid: string;
-    vout: number;
-    address: string;
-    label: string;
-    scriptPubKey: string;
-    amount: number;
-    confirmations: number;
-    redeemScript: string;
-    spendable: boolean;
-    solvable: boolean;
-    safe: boolean;
-}
-interface IRpcClientRetry {
-    constructor(url: string, opts?: object): void;
-    listUnspent(minConf?: number, maxConf?: number, addresses?: string[], includeUnsafe?: boolean, queryOptions?: object): Promise<ListUnspentItem[]>;
-    getBlockCount(): Promise<number>;
-    getRawTransaction(txid: string, verbose?: boolean, blockHash?: string): Promise<string>;
-    sendRawTransaction(hexString: string, allowHighFees?: boolean): Promise<string>;
-    generate(nBlocks: number, maxTries?: number): Promise<string[]>;
-    generateToAddress(nBlocks: number, address: string, maxTries?: number): Promise<string[]>;
-    getNewAddress(label?: string): Promise<string>;
-    dumpPrivKey(address: string): Promise<string>;
-    getBalance(dummy?: string, minConf?: number, includeWatchOnly?: boolean): Promise<number>;
-    getBlock(blockHash: string, verbosity?: number): Promise<string>;
-    importAddress(address: string, label?: string, rescan?: boolean, p2sh?: boolean): Promise<void>;
-}
-export {};

package/dist/network/BitcoinRpcNetworkProvider.js

@@ -1,11 +1,11 @@
-import RpcClientRetry from 'bitcoin-rpc-promise-retry';
+import { BchnRpcClient, } from '@mr-zwets/bchn-api-wrapper';
 export default class BitcoinRpcNetworkProvider {
     constructor(network, url, opts) {
         this.network = network;
-        this.rpcClient = new RpcClientRetry(url, opts);
+        this.rpcClient = new BchnRpcClient({ url, ...opts });
     }
     async getUtxos(address) {
-        const result = await this.rpcClient.listUnspent(0, 9999999, [address]);
+        const result = await this.rpcClient.request('listunspent', 0, 9999999, [address]);
         const utxos = result.map((utxo) => ({
             txid: utxo.txid,
             vout: utxo.vout,
@@ -14,13 +14,13 @@ export default class BitcoinRpcNetworkProvider {
         return utxos;
     }
     async getBlockHeight() {
-        return this.rpcClient.getBlockCount();
+        return this.rpcClient.request('getblockcount');
     }
     async getRawTransaction(txid) {
-        return this.rpcClient.getRawTransaction(txid);
+        return this.rpcClient.request('getrawtransaction', txid, 0);
     }
     async sendRawTransaction(txHex) {
-        return this.rpcClient.sendRawTransaction(txHex);
+        return this.rpcClient.request('sendrawtransaction', txHex);
     }
     getClient() {
         return this.rpcClient;

package/dist/types/type-inference.d.ts

@@ -0,0 +1,32 @@
+import type SignatureTemplate from '../SignatureTemplate.js';
+type TypeMap = {
+    [k: `bytes${number}`]: Uint8Array | string;
+} & {
+    byte: Uint8Array | string;
+    bytes: Uint8Array | string;
+    bool: boolean;
+    int: bigint;
+    string: string;
+    pubkey: Uint8Array | string;
+    sig: SignatureTemplate | Uint8Array | string;
+    datasig: Uint8Array | string;
+};
+type ProcessParam<Param> = Param extends {
+    type: infer Type;
+} ? Type extends keyof TypeMap ? TypeMap[Type] : any : any;
+export type ParamsToTuple<Params> = Params extends readonly [infer Head, ...infer Tail] ? [ProcessParam<Head>, ...ParamsToTuple<Tail>] : Params extends readonly [] ? [] : any[];
+type ProcessFunction<Function, ReturnType> = Function extends {
+    name: string;
+    inputs: readonly any[];
+} ? {
+    [functionName in Function['name']]: (...functionParameters: ParamsToTuple<Function['inputs']>) => ReturnType;
+} : {};
+type InternalAbiToFunctionMap<Abi, ReturnType> = unknown extends Abi ? GenericFunctionMap<ReturnType> : Abi extends readonly [infer Head, ...infer Tail] ? ProcessFunction<Head, ReturnType> & InternalAbiToFunctionMap<Tail, ReturnType> : Abi extends readonly [] ? {} : GenericFunctionMap<ReturnType>;
+type GenericFunctionMap<ReturnType> = {
+    [functionName: string]: (...functionParameters: any[]) => ReturnType;
+};
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type AbiToFunctionMap<T, ReturnType> = Prettify<InternalAbiToFunctionMap<T, ReturnType>>;
+export {};

package/dist/types/type-inference.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=type-inference.js.map

package/dist/utils.d.ts

@@ -34,4 +34,4 @@ export declare const randomNFT: (defaults?: Partial<TokenDetails>) => TokenDetai
 export declare function findLastIndex<T>(array: Array<T>, predicate: (value: T, index: number, obj: T[]) => boolean): number;
 export declare const snakeCase: (str: string) => string;
 export declare const extendedStringify: (obj: any, spaces?: number) => string;
-export declare const zip: <T, U>(a: T[], b: U[]) => [T, U][];
+export declare const zip: <T, U>(a: readonly T[], b: readonly U[]) => [T, U][];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cashscript",
-  "version": "0.10.1",
+  "version": "0.10.3",
   "description": "Easily write and interact with Bitcoin Cash contracts",
   "keywords": [
     "bitcoin cash",
@@ -44,9 +44,8 @@
   },
   "dependencies": {
     "@bitauth/libauth": "^3.0.0",
-    "@cashscript/utils": "^0.10.1",
-    "bip68": "^1.0.4",
-    "bitcoin-rpc-promise-retry": "^1.3.0",
+    "@cashscript/utils": "^0.10.3",
+    "@mr-zwets/bchn-api-wrapper": "^1.0.1",
     "delay": "^5.0.0",
     "electrum-cash": "^2.0.10",
     "fast-deep-equal": "^3.1.3",
@@ -54,12 +53,11 @@
   },
   "devDependencies": {
     "@jest/globals": "^29.4.1",
-    "@psf/bch-js": "^4.15.0",
+    "@psf/bch-js": "^6.8.0",
     "@types/pako": "^2.0.3",
-    "bip39": "^3.0.4",
     "eslint": "^8.54.0",
     "jest": "^29.4.1",
     "typescript": "^5.5.4"
   },
-  "gitHead": "0dd95d5b05a438ac1884bdb2252aec6a4c77e5b2"
+  "gitHead": "1aa7c6b26ee8add3ff8cf42227141d9bea8aba66"
 }