add translation for scrypt language

Author: KaKeimei

docs/contract/scrypt-language/basic-syntax.md

@@ -1,4 +1,151 @@
 ---
 sidebar_position: 2
 ---
+
 # Basic Syntax
+
+Introduction to the basic grammar and rules of the Scrypt language.
+
+Reference: https://scryptdoc.readthedocs.io/en/latest/
+
+## Constructor
+
+Each contract has only one constructor, which is used to initialize member variables. If no constructor is specified, a
+default constructor will be generated to initialize all members.
+
+![img.png](/img/scrypt-constructor.png)
+
+## Require()
+
+The `require` function specifies contract conditions and accepts a boolean parameter. If the parameter is false, the
+contract execution will be interrupted, and it will return a failure.
+
+When the parameter is true, the verification will pass.
+
+## Public Functions
+
+Each contract has at least one public function. This function does not return a value (void return). It can be
+considered the locking script or the entry point of the entire contract. Only when all the `require` conditions in the
+public function are met and end normally, can the contract be unlocked.
+
+In the case of multiple public functions, the contract can be considered to have multiple unlocking methods, each
+capable of unlocking the output.
+
+## Basic Data Structures
+
+- Bool: true or false
+- Int: Signed integers of any length in decimal or hexadecimal
+- Byte: Hexadecimal format starting with b and single quotes, or UTF-8 characters enclosed in double quotes
+    - Array type: separated by commas, with a fixed length
+
+```c
+bool[3] b = [false, false && true || false, true || (1 > 2)];
+int[3] c = [72, -4 - 1 - 40, 833 * (99 + 9901) + 8888];
+bytes[3] a = [b'ffee', b'11', b'22'];
+int[2][3] d = [[11, 12, 13], [21, 22, 23]];
+// array dimension can be omitted when declared
+int[] e = [1, 4, 2];  // e is of type int[3]
+int[][] f = [[11, 12, 13], [21, 22, 23]]; // f is of type int[2][3]
+```
+
+Arrays can use the `repeat` function to set all values to the same.
+
+```text
+// a == [0, 0, 0]
+int[3] a = repeat(0, 3);
+```
+
+Arrays can be indexed using indices starting from 0. If out of bounds, the contract will fail.
+
+Two arrays are considered equal if they have the same number of elements and each element is the same.
+
+## Struct Type
+
+A struct is a group of member variables, which can be basic data structures or nested structs.
+
+When using arrays, members can be accessed directly using the dot (.) notation.
+
+Type inference: The `auto` keyword can automatically infer basic data types.
+
+Type alias: You can assign aliases to specific data types.
+
+## Generics
+
+Generics can be defined in libraries and structs. When using generics, the corresponding type must be explicitly
+declared.
+
+```c
+library HashedMap<K, V> {
+    // use them as function parameter's type
+    function set(K k, V v, int idx) {
+        ...
+    }
+}
+
+struct ST<T, P> {
+    T t;
+    P p;
+}
+```
+
+## Domain Types
+
+Domain types are subtypes of basic types, mainly used for types related to Bitcoin transactions. Using domain types can
+enhance type safety.
+
+- PublicKey: PubKey(b'0200112233445566778899aabbccddeeffffeeddccbbaa99887766554433221100');
+- Sig: Sig(
+  b'3045022100b71be3f1dc001e0a1ad65ed84e7a5a0bfe48325f2146ca1d677cf15e96e8b80302206d74605e8234eae3d4980fcd7b2fdc1c5b9374f0ce71dea38707fccdbd28cf7e41');
+- Ripemd160: Ripemd160(b'0011223344556677889999887766554433221100');
+- PubKeyHash: PubKeyHash(b'0011223344556677889999887766554433221100');
+- Sha1: Sha1(b'0011223344556677889999887766554433221100');
+- Sha256: Sha256(b'00112233445566778899aabbccddeeffffeeddccbbaa99887766554433221100');
+- SigHashType: SigHashType(b'01'); SigHashType s = SigHash.ALL | SigHash.ANYONECANPAY;
+- SigHashPreimage: SigHashPreimage(b'0100000028bcef7e73248aa273db19d73');
+- OpCodeType: OpCode.OP_DUP + OpCode.OP_ADD;
+- PrivKey: PrivKey(0x00112233445566778899aabbccddeeffffeeddccbbaa99887766554433221100);
+
+## Constants
+
+Constants cannot be modified once declared.
+
+```text
+contract Test { 
+    const int x;
+    
+    constructor(int x) {
+        this.x = x;
+    }
+    
+    public function equal(const int y) {
+        y = 1; // error
+        const int a = 36;
+        a = 11; // error
+    }
+}
+```
+
+## If Condition
+
+The `if` condition is used to control the program logic flow. Besides bool, int, and bytes can also use `if`. Int 0 and
+byte b'', b'00' are considered false.
+
+## Exit Method
+
+The `exit` method ends the function logic early. The parameter can be true or false.
+
+## Code Separator
+
+Three or more asterisks (*) will insert an OP_CODESEPARATOR operation, which affects the signature calculation.
+
+## Access Control
+
+- Default: no keyword required
+- Private
+- Public: only applies to functions
+
+| Access Level | Same Contract | Other Contract | Externally |
+|--------------|---------------|----------------|------------|
+| Default      | Yes           | Yes            | No         |
+| Private      | Yes           | No             | No         |
+| Public       | Yes           | Yes            | Yes        |

docs/contract/scrypt-language/compile-time-constant.md

@@ -1,4 +1,62 @@
 ---
 sidebar_position: 6
 ---
-# Compile Time Constant
+
+# Compile Time Constants
+
+An introduction to the concept and usage of Compile Time Constants (CTCs).
+
+Compile Time Constants (CTCs) are values that can be calculated at compile time. There are four types of compile time
+constants:
+
+- Literals
+- Induction variables
+- Static constant properties of a contract initialized with literals
+- Static constant function parameters
+
+There are several cases where only compile time constants can be used:
+
+- Loop boundaries
+- Array sizes
+- Writing to array elements using the indexing operator
+- Declaring static constant function parameters, such as `size` in `reverseBytes(bytes b, static const int size)`
+  and `repeat(T e, static const int size)`
+
+```c
+contract CTC {
+    static const int N = 4;
+    static const int LOOPCOUNT = 30;
+
+    // A is not a CTC because the right-hand side is an expression, not a literal
+    static const int A = 2 + 1;
+    // B is not a CTC because it is not static
+    const int B;
+
+    // FC is declared as a CTC in the function parameter
+    // It can be used within this function, including in parameters and return types declared after it
+    function incArr(static const int FC, int[FC] x) : int[FC] {
+        loop(FC): i {
+            x[i] += i; // Induction variable CTC
+        }
+        return x;
+    }
+
+    public function unlock(int y) {
+        int[N] arr0 = [1, 2, 3, 4];
+        // Using `N` to initialize the CTC parameter `FC` of the function `incArr`
+        int[N] arr1 = this.incArr(N, repeat(1, N));
+        loop(N): i {
+            require(arr0[i] == arr1[i]);
+        }
+
+        int z = 0;
+        loop(LOOPCOUNT) {
+            if (z < y) z += 4;
+        }
+        require(y == 1);
+    }
+}
+```
+
+Note: Order matters: when declaring function parameters, `const static` is not allowed, but it is allowed when declaring
+properties.

docs/contract/scrypt-language/functions.md

@@ -1,4 +1,67 @@
 ---
 sidebar_position: 4
 ---
+
 # Functions
+
+How to define and use user-defined functions.
+
+## Private and Public Functions
+
+Users can specify their own functions, but functions are private by default and can only be seen within the contract.
+
+Public functions are specifically used to unlock the contract, and they return `true` by default. If the `require`
+conditions are not met, they will terminate and return `false`.
+
+## Static Functions
+
+Static functions can be called directly using the Contract name as a prefix or internally within the contract. Static
+functions do not modify any external state.
+
+## `return` Keyword
+
+Since the script does not support the `return` syntax, `return` must be placed at the end of the function. This
+restriction cannot be lifted for now, but there are ways to bypass it.
+
+## Recursive Calls
+
+Recursive calls are not permitted.
+
+## Library Functions
+
+Scrypt provides some convenient public library functions that can be called directly.
+
+### Math
+
+- `int abs(int a)`
+- `int min(int a, int b)`
+- `int max(int a, int b)`
+- `bool within(int x, int min, int max)`
+
+### Hashing
+
+- `Ripemd160 ripemd160(bytes b)`
+- `Sha1 sha1(bytes b)`
+- `Sha256 sha256(bytes b)`
+- `Ripemd160 hash160(bytes b)` - `ripemd160(sha256(b))`
+- `Sha256 hash256(bytes b)` - `sha256(sha256(b))`
+- `Sha256 flattenSha256(T a)`
+
+### Signature Verification
+
+- `bool checkSig(Sig sig, PubKey pk)`
+    - Returns true if the signature matches the public key. Returns false if the signature is an empty byte array.
+      Otherwise, the entire contract fails immediately due to the NULLFAIL rule.
+- `bool checkMultiSig(Sig[M] sigs, PubKey[N] pks)`
+    - Returns true if and only if M signatures match M out of N public keys. Returns false if all signatures are an
+      empty byte array. Otherwise, the entire contract fails immediately.
+
+### Byte Operations
+
+- Convert to and from `int`, using `unpack` or `pack` methods for conversion.
+- `bytes num2bin(int num, int size)`
+- `len()` - Returns the length of bytes.
+- Slicing Operator - `b[start:end]` - inclusive of start, exclusive of end. If `start` is omitted, it defaults to 0.
+  If `end` is omitted, it defaults to the length.
+- Byte concatenation: `bytes b = b'00112233' + b'334455'` results in `b == b'00112233334455'`
+- `reverseBytes(bytes b, static const int size)`

docs/contract/scrypt-language/introduction.md

@@ -1,4 +1,23 @@
 ---
 sidebar_position: 1
 ---
-# Introduction to Scrypt Language
+
+# Introduction to sCrypt Language
+
+Introducing the programming language sCrypt for MVC contracts.
+
+> Note: The latest version of the sCrypt language has adopted TypeScript as its underlying language. Therefore, the
+> syntax of the sCrypt language is similar to that of TypeScript. The TypeScript version is currently being integrated
+> into MVC, and the knowledge base will be updated according to the development progress of the new SDK.
+
+sCrypt (pronounced "ess crypt") is a high-level smart contract language designed for the Bitcoin Virtual Machine.
+Bitcoin supports writing smart contracts using a Forth-like stack-based Script language. However, writing smart
+contracts in native Script is both cumbersome and error-prone. As the size and complexity of contracts increase, these
+issues become increasingly difficult to manage.
+
+sCrypt aims to simplify the process of writing smart contracts that run on-chain.
+
+It is easy to learn. Syntactically, sCrypt is similar to JavaScript and Solidity, making it more accessible and easier
+to use for existing web and smart contract developers.
+
+It is statically typed. Type checking can detect many errors at compile time.

docs/contract/scrypt-language/loop.md

@@ -1,4 +1,64 @@
 ---
 sidebar_position: 3
 ---
-# Loop
+
+# Loops
+
+Introduction to using loops in sCrypt contracts.
+
+Bitcoin Script does not provide built-in loop functionality. sCrypt implements loops by repeating the loop's internal
+data script n times.
+
+```c
+loop (maxLoopCount) [: loopIndex]{
+    loopBody
+}
+
+loop (10) {x = x * 2;} // Equivalent to unfolding x = x * 2; ten times
+```
+
+Since loop unfolding occurs at compile time, the number of iterations must be known at compile time and must be a
+constant.
+
+## Loop Increment
+
+Loop increment refers to the operation of incrementing or decrementing the loop variable within the loop body.
+
+```c
+// int[3][4] matrix;
+// i & j are induction variables
+loop (3) : i {
+    // i is the outer loop index
+    loop (4) : j {
+        // j is the inner loop index
+        matrix[i][j] = i + j;
+    }
+}
+```
+
+## Adding Conditions Inside the Loop
+
+```c
+loop (3) {
+    // place condition here
+    if (x < 8) {
+        x = x * 2;
+    }
+}
+```
+
+## Exiting the Loop
+
+To exit the loop within the loop body, use the following method:
+
+```c
+bool done = false;
+loop (3) {
+    if (!done) {
+        x = x * 2;
+        if (x >= 8) {
+            done = true;
+        }
+    }
+}
+```