cashscript 0.10.2 → 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

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/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.2",
+  "version": "0.10.3",
   "description": "Easily write and interact with Bitcoin Cash contracts",
   "keywords": [
     "bitcoin cash",
@@ -44,7 +44,7 @@
   },
   "dependencies": {
     "@bitauth/libauth": "^3.0.0",
-    "@cashscript/utils": "^0.10.2",
+    "@cashscript/utils": "^0.10.3",
     "@mr-zwets/bchn-api-wrapper": "^1.0.1",
     "delay": "^5.0.0",
     "electrum-cash": "^2.0.10",
@@ -59,5 +59,5 @@
     "jest": "^29.4.1",
     "typescript": "^5.5.4"
   },
-  "gitHead": "a7c4f652462ddfccd54fc929f06cb16022769df9"
+  "gitHead": "1aa7c6b26ee8add3ff8cf42227141d9bea8aba66"
 }