Scrypt-ts: remove scryptType class, use type

.nycrc

@@ -13,7 +13,8 @@
     "src/test/**",
     "**/*.d.ts",
     "**/*.test.ts",
-    "src/index.ts"
+    "src/index.ts",
+    "src/findCompiler.ts"
   ],
   "sourceMap": true,
   "reporter": [

.travis.yml

@@ -24,6 +24,6 @@ script:
   - cd boilerplate
   - npm install
   - npm link scryptlib # use this version
-  #- npm ls scryptlib    # double check the latest version is used
+  # #- npm ls scryptlib    # double check the latest version is used
   - npm test
-  - npx scryptlib contracts/demo.scrypt
+  - npx scryptlib compile contracts/demo.scrypt

CHANGELOG.md

@@ -1,6 +1,25 @@
 # CHANGELOG
 
 
+
+## 2.0.0
+
+- remove scryptType class, use type
+- add bsv typescript defined
+- firstCall rename to isGenesis
+- auto complete transation sig and sighashpreimage.
+- optimize cli
+- remove FORKID from sighash flag
+- auto calc keyIndex
+- Fix genLaunchConfigFile
+- rename desc files to contractname.json now
+
+see [PR #211](https://github.com/sCrypt-Inc/scryptlib/pull/211)
+
+*Release Date: 2023/01/08*
+
+
+
 ## 1.0.9
 
 - Fix big int issue [#206](https://github.com/sCrypt-Inc/scryptlib/issues/206)

README.md

@@ -17,11 +17,11 @@ A smart contract is compiled to a locking script template. A contract function c
 
 By using `scryptlib`, both scripts can be obtained with ease.
 
-## Contract Description File
+## Contract Artifact File
 
-The compiler output results in a JSON file. It’s a representation used to build locking and unlocking scripts. We call this file a [**contract description file**](docs/counter_debug_desc.json).
+The compiler output results in a JSON file. It’s a representation used to build locking and unlocking scripts. We call this file a [**contract artifact file**](docs/counter_debug.json).
 
-There are three ways to generate this file (named as `xxx_desc.json`):
+There are three ways to generate this file (named as `<contract_name>.json`):
 
 1. Use [**sCrypt VS Code extension**](https://marketplace.visualstudio.com/items?itemName=bsv-scrypt.sCrypt) to compile manually;
 2. Use the function `compile` programmatically:
@@ -35,7 +35,7 @@ There are three ways to generate this file (named as `xxx_desc.json`):
       path: contractFilePath  //  the file path of the contract
     },
     {
-      desc: true  // set this flag to be `true` to get the description file output
+      artifact: true  // set this flag to be `true` to get the artifact file output
       asm: true // set this flag to be `true` to get the asm file output
       optimize: false //set this flag to be `true` to get optimized asm opcode
       sourceMap: true //set this flag to be `true` to get source map
@@ -64,8 +64,10 @@ There are three ways to generate this file (named as `xxx_desc.json`):
 ```sh
   # install compiler binary
   npx scryptlib download
+  # the latest compiler may be incompatible with the current scryptlib
+  npx scryptlib download latest
   # compiling contract
-  npx scryptlib your_directory/your_scrypt.scrypt
+  npx scryptlib compile your_directory/your_scrypt.scrypt
 ```
 
 ## Types
@@ -75,18 +77,18 @@ All basic types of the **sCrypt** language have their corresponding javascript c
 
 |  Types (scrypt) | scryptlib (javascript/typescript)|
 | :---------: | :--------: |
-| `int` | `new Int(1)` or `number` or `bigint` |
-| `bool` | `new Bool(true)` or `boolean` |
-| `bytes` | `new Bytes('0001')` or `new String("hello world 😊")`|
-| `PubKey` | `new PubKey('0001')`|
-| `PrivKey` | `new PrivKey(1)`|
-| `Sig` | `new Sig('0001')`|
-| `Ripemd160` | `new Ripemd160('0001')`|
-| `Sha1` | `new Sha1('0001')`|
-| `Sha256` | `new Sha256('0001')`|
-| `SigHashType` | `new SigHashType('01')`|
-| `SigHashPreimage` | `new SigHashPreimage('010001')`|
-| `OpCodeType` | `new OpCodeType('76')`|
+| `int` | `Int(1)` or `number` or `bigint` |
+| `bool` | `Bool(true)` or `boolean` |
+| `bytes` | `Bytes('0001')` or `stringToBytes("hello world 😊")`|
+| `PubKey` | `PubKey('0001')`|
+| `PrivKey` | `PrivKey(1)`|
+| `Sig` | `Sig('0001')`|
+| `Ripemd160` | `Ripemd160('0001')`|
+| `Sha1` | `Sha1('0001')`|
+| `Sha256` | `Sha256('0001')`|
+| `SigHashType` | `SigHashType('01')`|
+| `SigHashPreimage` | `SigHashPreimage('010001')`|
+| `OpCodeType` | `OpCodeType('76')`|
 
 ### 2. Array Types
 
@@ -96,76 +98,69 @@ scryptlib uses javascript array to represent the array types of the **sCrypt** l
 
 [[1, 3, 1]] // represent `int[1][3]` in **sCrypt** language
 
-[new Bytes("00"), new Bytes("00"), new Bytes("00")] // represent `bytes[3]` in **sCrypt** language
+[Bytes("00"), Bytes("00"), Bytes("00")] // represent `bytes[3]` in **sCrypt** language
 
 ```
 
 
 
 ### 3. Structure and Type Aliases
 
-Composite types, including structs and type aliases, are dynamically generated by `buildTypeClasses`. When creating a structure, all members must specify values. Use dot to access structure members.
+The structure in sCrypt needs to be represented by object in **SDK**. When creating a structure, all members must specify values. Use `.` to access structure members.
+
+A type alias needs to be represented by a value corresponding to the original type
 
 Structure and type aliases defined in sCrypt:
 
-```javascript
+```ts
+/*Person is structure and Male, Female are type aliases */
 struct Person {
     bytes addr;
     bool isMale;
     int age;
 }
 
-struct Block {
-    bytes hash;
-    bytes header;
-    int time;
-}
-
 type Male = Person;
 type Female = Person;
 
-contract Main {
-    Person person;
-    int x;
-
+contract PersonContract {
+    Male man;
+    Female woman;
     ...
 
 }
-
 ```
 
 Access Structure and type aliases by **SDK** :
 
-
 ```typescript
 
-const PersonContract = buildContractClass(loadDescription('person_desc.json'));
+const PersonContract = buildContractClass(loadArtifact('person.json'));
 
-/*Person is structure and Male, Female are type aliases */
-const { Person, Male, Female } = buildTypeClasses(PersonContract);
 
-let man = new Person({
+let man = {
     isMale: true,
-    age: 14,
-    addr: new Bytes("68656c6c6f20776f726c6421")
-  });
+    age: 14n,
+    addr: Bytes("68656c6c6f20776f726c6421")
+  };
 
-man.age = 20;
+man.age = 20n;
 
-let woman = new Female({
+let woman = {
     isMale: false,
-    age: 18,
-    addr: new Bytes("68656c6c6f20776f726c6421")
-  });
+    age: 18n,
+    addr: Bytes("68656c6c6f20776f726c6421")
+  };
 
-woman.addr = new Bytes("")
+woman.addr = Bytes("")
 
+const instance = new PersonContract(man, woman);
 ```
 
 
 ### 4. Library
 
-Library is another composite types. When the constructor parameter of the contract contains library, we need to create library through sdk.
+Library is another composite types. When the constructor parameter of the contract contains library, we have to pass an array according to the constructor parameter of the library.
 
 Library defined in sCrypt:
 
@@ -195,15 +190,14 @@ Access Library by **SDK** :
 
 ```typescript
 
-const Test = buildContractClass(loadDescription('test_desc.json'));
+const Test = buildContractClass(loadArtifact('test.json'));
 
-const { L } = buildTypeClasses(Test);
-
-let test = new Test(1, new L(1, 2));
+let l = [1n, 2n];
 
+let test = new Test(1n, l);
 ```
 
-As you can see, creating a library instance is similar to creating a contract instance. Sometimes the constructor parameters of the library may be generic types. At this time, the sdk will deduce the generic type based on the constructor arguments you pass.
+Sometimes the constructor parameters of the library may be generic types. At this time, the sdk will deduce the generic type based on the constructor arguments you pass.
 
 ## Deploy a Contract and Call Its Function
 
@@ -214,13 +208,13 @@ Both **deploying a contract** and **calling a contract function** are achieved b
 
 There are 2 steps.
 ### 1. Get Locking and Unlocking Script
-You can use the description file to build a reflected contract class in Javascript/TypeScript like this:
+You can use the artifact file to build a reflected contract class in Javascript/TypeScript like this:
 ```typescript
-const MyContract = buildContractClass(JSON.parse(descFileContent));
+const MyContract = buildContractClass(JSON.parse(artifactFileContent));
 ```
 To create an instance of the contract class, for example:
 ```typescript
-const instance = new MyContract(1234, true, ...parameters);
+const instance = new MyContract(1234n, true, ...parameters);
 ```
 To get the locking script, use:
 ```typescript
@@ -246,9 +240,14 @@ const unlockingScriptHex = unlockingScript.toHex();
 A useful method `verify(txContext)` is provided for each contract function call. It would execute the function call with the given context locally. The `txContext` argument provides some context information of the current transaction, **needed only if signature is checked inside the contract**.
 ```typescript
 {
-  tx?: any;                 // current transaction represented in bsv.Transaction object
+  tx?: bsv.Transaction;                 // current transaction represented in bsv.Transaction object
   inputIndex?: number;      // input index, default value: 0
+  /**
+   * @deprecated no need any more
+   */
   inputSatoshis?: number;   // input amount in satoshis
+  opReturn?: string;        // contract state in ASM format
+  opReturnHex?: string;     // contract state in hex format
 }
 ```
 It returns an object:
@@ -265,7 +264,7 @@ It usually appears in unit tests, like:
 const context = { tx, inputIndex, inputSatoshis };
 
 // 1) set context per verify()
-const funcCall = instance.someFunc(new Sig('0123456'), new Bytes('aa11ff'), ...parameters);
+const funcCall = instance.someFunc(Sig('0123456'), Bytes('aa11ff'), ...parameters);
 const result = funcCall.verify(context);
 // 2) alternatively, context can be set at instance level and all following verify() will use it
 instance.txContext = context;
@@ -291,7 +290,7 @@ contract Counter {
 Use the initial state to instantiate the contract and read the state by accessing the properties of the contract instance.
 
 ```typescript
-const instance = new Counter(0);
+const instance = new Counter(0n);
 
 let state = instance.counter;
 // update state
@@ -321,7 +320,7 @@ You can also access the state of the contract by accessing the properties of the
 ```typescript
 
 instance.counter++;
-instance.person.name = new Bytes('0001');
+instance.person.name = Bytes('0001');
 
 ```
 
@@ -349,7 +348,7 @@ In addition to using a constructor to create a contract, you can also use a raw
 ```typescript
 const axios = require('axios');
 
-const Counter = buildContractClass(loadDesc("counter_debug_desc.json"));
+const Counter = buildContractClass(loadArtifact("counter_debug.json"));
 let response = await axios.get("https://api.whatsonchain.com/v1/bsv/test/tx/7b9bc5c67c91a3caa4b3212d3a631a4b61e5c660f0369615e6e3a969f6bef4de/hex")
 // constructor from raw Transaction.
 let counter = Counter.fromTransaction(response.data, 0/** output index**/);
@@ -374,9 +373,9 @@ import 'core-js/features/array';
 
 
 
-let demo = new Demo("11111111111111111111111111111111111", 1);
+let demo = new Demo(Int("11111111111111111111111111111111111"), 1n);
 
-let result = demo.add(new Int("11111111111111111111111111111111112")).verify();
+let result = demo.add(Int("11111111111111111111111111111111112")).verify();
 
 console.assert(result.success, result.error)
 ```

VERSIONLOG.md

@@ -1,4 +1,4 @@
-# Contract Description Version 
+# Contract Artifact Version 
 
 
 ## version = 1