add to docs & release notes

Author: mr-zwets

website/docs/compiler/compiler.md

@@ -42,6 +42,14 @@ To have the best TypeScript integration, we recommend generating the artifact in
 cashc ./Contract.cash --output ./artifact.ts --format ts
 ```
 
+```bash
+cashc ./Contract.cash --size --opcount
+```
+
+:::info
+The size outputs of the `cashc` compiler are based on the bytecode without constructor arguments. This means they are always an underestimate, as the contract hasn't been initialized with contract arguments.
+:::
+
 ## JavaScript Compilation
 Generally CashScript contracts are compiled to an Artifact JSON file using the CLI compiler. As an alternative to this, CashScript contracts can be compiled from within JavaScript apps using the `cashc` package. This package exports two compilation functions.
 

website/docs/guides/infrastructure.md

@@ -65,7 +65,7 @@ Both the `Electrum` and `Chaingraph` indexers allow you to create websocket subs
 Contract-related events are when you want to update the server state to reflect changes on-chain, for example new contracts being created or existing contracts changing their state in an important way. So contract related events often don't trigger an on-chain transaction directly, but they update the information about the contracts tracked for time/oracle events by the server.
 
 :::tip
-Only the `Chaingraph` indexer allows for subscriptions to arbitrary on-chain events, with `Electrum` you can create subscriptions for changes in the transaction history of a specific (contract) address.
+With `Electrum` you can create subscriptions to transactions for a specific (contract) address, with `Chaingraph` you can create subscriptions to arbitrary on-chain events.
 :::
 
 ### Oracle-related events

website/docs/language/types.md

@@ -208,8 +208,9 @@ If you do need to pad bytes to a specific length, you can convert the bytes to `
 
 #### Example
 ```solidity
-bytes data = nftCommitment.split(10)[0]; // (type = bytes, content = 10 bytes)
-bytes20 paddedData = bytes20(int(data)); // (type = bytes20, content = 20 bytes)
+bytes10 data = nftCommitment.split(10)[0];
+// First convert 'bytes' type to 'int' to cast with padding
+bytes20 paddedData = bytes20(int(data));
 require(storedContractState == paddedData);
 ```
 
@@ -219,7 +220,8 @@ When casting unbounded `bytes` types to bounded `bytes` types (such as `bytes20`
 
 #### Example
 ```solidity
-bytes pkh = nftCommitment.split(20)[0]; // (type = bytes, content = 20 bytes)
+bytes pkh = tx.inputs[0].nftCommitment; // (type = bytes, content = 20 bytes)
+// Typecast the variable to be able to use it for 'new LockingBytecodeP2PKH()'
 bytes20 bytes20Pkh = bytes20(pkh); // (type = bytes20, content = 20 bytes)
 bytes25 lockingBytecode = new LockingBytecodeP2PKH(bytes20Pkh);
 ```

website/docs/releases/release-notes.md

@@ -6,6 +6,8 @@ title: Release Notes
 
 #### cashc compiler
 - :sparkles: Add `.slice(start, end)` operator for bytes and strings.
+- :sparkles: Add bounded bytes typing and bounds checking for `.split()`
+- :bug: Disallow incorrect bounded bytes typing when using `.split()`
 
 #### CashScript SDK
 - :bug: Fix bug with where `ElectrumNetworkProvider` would disconnect in browser on visibility change of the page

website/docs/sdk/electrum-network-provider.md

@@ -116,6 +116,10 @@ By default, the ElectrumNetworkProvider will automatically connect and disconnec
 const provider = new ElectrumNetworkProvider('chipnet', { manualConnectionManagement: true });
 ```
 
+:::tip
+If you're providing an `ElectrumClient` and using it to subscribe to address or blockheader events, you need to enable `manualConnectionManagement` to overwrite the default of connecting and disconnecting for each separate request.
+:::
+
 #### connect()
 ```ts
 provider.connect(): Promise<void>;

website/docs/sdk/instantiation.md

@@ -103,8 +103,9 @@ contract.bytesize: number
 
 The size of the contract's bytecode in bytes can be retrieved through the `bytesize` member field. This is useful to ensure that the contract is not too big, since Bitcoin Cash smart contracts can be 1,650 bytes at most.
 
-:::info
-The size outputs of the `cashc` compiler are based on the bytecode without constructor arguments. This means they will always be an underestimate, as the contract hasn't been initialized with contract arguments.
+:::tip
+Using `contract.bytesize` is the best way to get the size of contract bytecode, as it includes the constructor arguments.
+The size outputs of the `cashc` compiler are based on the bytecode without constructor arguments so are always an underestimate.
 :::
 
 #### Example