add to type casting docs

Author: mr-zwets

website/docs/language/types.md

@@ -153,7 +153,16 @@ require(hello + "world" == "Hello " + world);
 ```
 
 ## Type Casting
-Type casting can be done both explicitly and implicitly as illustrated below. `pubkey`, `sig` and `datasig` can be implicitly cast to `bytes`, meaning they can be used anywhere where you would normally use a `bytes` type. Explicit type casting can be done with a broader range of types, but is still limited. The syntax of this explicit type casting is illustrated below. Note that you can also cast to bounded `bytes` types.
+Type casting can be done both explicitly and implicitly depending on the type. `pubkey`, `sig` and `datasig` can be implicitly cast to `bytes`, meaning they can be used anywhere where you would normally use a `bytes` type. Explicit type casting can be done with a broader range of types, but is still limited. The syntax of this explicit type casting is illustrated below:
+
+#### Example
+```solidity
+pubkey pk = pubkey(0x0000);
+bytes editedPk = bytes(pk) + 0x1234;
+bytes4 zeroBytes = bytes4(0); // 0x00000000
+```
+
+### Casting Table
 
 See the following table for information on which types can be cast to other which other types.
 
@@ -167,44 +176,46 @@ See the following table for information on which types can be cast to other whic
 | sig     | bytes                  | bytes                              |
 | datasig | bytes                  | bytes                              |
 
-#### Example
-```solidity
-pubkey pk = pubkey(0x0000);
-bytes editedPk = bytes(pk) + 0x1234;
-bytes4 integer = bytes4(25);
-```
-
 ### Int to Byte Casting
 
-When casting integer types to bytes of a certain size, the integer value is padded with zeros, e.g. `bytes4(0) == 0x00000000`. It is also possible to pad with a variable number of zeros by passing in a `size` parameter, which indicates the size of the output, e.g. `bytes(0, 4 - 2) == 0x0000`. The size casting can be a very important feature when keeping local state in an nftCommitment or in the simulated state.
+When casting integer types to bytes of a certain size, the integer value is padded with zeros, e.g. `bytes4(0) == 0x00000000`. It is also possible to pad with a variable number of zeros by passing in a `size` parameter, which indicates the size of the output, e.g. `bytes(0, 4 - 2) == 0x0000`.
 
 :::tip
 Using `bytes20 placeholderPkh= bytes20(0)` will generate a 20 byte zero-array programmatically, whereas 
 `bytes20 placeholderPkh= 0x0000000000000000000000000000000000000000` will actually take 20 bytes of space in your contract.
 :::
 
-:::note
+Casting an integer to a fixed-size byte-length can be a very important when storing local state in an nftCommitment. Developers need to consider what the preferable fixed-size length is for each indivual case depending on the interger range. Below we add a table with information on the maximum integer size for satoshis and fungible CashTokens:
+
+| Integer Type    | Maximum amount         | Max Byte Size                      |
+| --------------  | ---------------------- | ---------------------------------- |
+| Satoshis        | 2.1 quadrillion        | 6 bytes (5 bytes for 1 quadrillion)|
+| CashTokens      | 9223 quadrillion       | 8 bytes for max supply token       |
+
+:::info
 VM numbers follow Script Number format (A.K.A. CSCriptNum), to convert VM number to bytes or the reverse, it's recommended to use helper functions for these conversions from libraries like Libauth.
 :::
 
-### Semantic Byte Casting
+### Bytes to BytesX Casting
 
-When casting unbounded `bytes` types to bounded `bytes` types (such as `bytes20` or `bytes32`), this is a purely semantic cast. The bytes are not padded with zeros, and no checks are performed to ensure the cast bytes are of the correct length. This can be helpful in certain cases, such as `LockingBytecode`, which expects a specific length input.
+If you do need to pad bytes to a specific length, you can convert the bytes to `int` first, and then cast to the bounded `bytes` type. This will pad the bytes with zeros to the specified length, like specified in the *Int to Byte Casting* section above.
 
 #### Example
 ```solidity
-bytes pkh = nftCommitment.split(20)[0]; // (type = bytes, content = 20 bytes)
-bytes20 bytes20Pkh = bytes20(pkh); // (type = bytes20, content = 20 bytes)
-bytes25 lockingBytecode = new LockingBytecodeP2PKH(bytes20Pkh);
+bytes data = nftCommitment.split(10)[0]; // (type = bytes, content = 10 bytes)
+bytes20 paddedData = bytes20(int(data)); // (type = bytes20, content = 20 bytes)
+require(storedContractState == paddedData);
 ```
 
-If you do need to pad bytes to a specific length, you can convert the bytes to `int` first, and then cast to the bounded `bytes` type. This will pad the bytes with zeros to the specified length, like specified in the *Int to Byte Casting* section above.
+### Semantic Byte Casting
+
+When casting unbounded `bytes` types to bounded `bytes` types (such as `bytes20` or `bytes32`), this is a purely semantic cast. The bytes are not padded with zeros, and no checks are performed to ensure the cast bytes are of the correct length. This can be helpful in certain cases, such as `LockingBytecode`, which expects a specific length input.
 
 #### Example
 ```solidity
-bytes data = nftCommitment.split(10)[0]; // (type = bytes, content = 10 bytes)
-bytes20 paddedData = bytes20(int(data)); // (type = bytes20, content = 20 bytes)
-require(storedContractState == paddedData);
+bytes pkh = nftCommitment.split(20)[0]; // (type = bytes, content = 20 bytes)
+bytes20 bytes20Pkh = bytes20(pkh); // (type = bytes20, content = 20 bytes)
+bytes25 lockingBytecode = new LockingBytecodeP2PKH(bytes20Pkh);
 ```
 
 ## Operators