postchain-client 1.16.1 → 1.18.0

package/README.md

@@ -52,6 +52,7 @@ Create a Chromia client instance and configures it according to your needs.
     - `attemptsPerEndpoint` (Optional): Number of consecutive failed attempts allowed for each endpoint before considering it as unreachable. Defaults to 3.
     - `attemptInterval` (Optional): Interval (in milliseconds) between consecutive retry attempts during failover. Defaults to 5000 ms.
     - `unreachableDuration` (Optional): Duration (in milliseconds) that an endpoint should remain unreachable before reattempting. Defaults to 30000 ms.
+  - `useStickyNode`(Optional): A boolean that will make sure that on succefull requests to a node, the client will continue using this node unless it starts failing.
 
 ### Returns
 
@@ -77,6 +78,48 @@ const chromiaClient = await createClient({
 });
 ```
 
+### Use sticky node
+
+#### What is a "sticky node"?
+
+_A sticky node is a node that will will continue to be used for requests as long as the requests to it are successful, this means that if the client is making a request to get the block height of a dapp, and it successful, then following requests to get other data eg: dapp transactions will be using the same node, meaning that is "sticks" with the user once selected._
+
+#### How does it work?
+
+The client will need to be initialized with a `directoryNodeUrlPool` and have the property `useStickyNode` set to `true` in the `settings` parameter for it to be enabled. example:
+
+```typescript
+const client = createClient({
+  useStickyNode: true,
+  directoryNodeUrlPool: ["http://localhost:7740"],
+  ...restSettings,
+});
+```
+
+This will then create internally create a nodeManager, that handles and keeps track of which nodes are available and which one is currently set to be the "sticky node".
+
+As a user, when you first make a request with this feature enabled, you will not have any "sticky node" set. Instead whenever you make a request, the client will choose a random node out of the ones available. Should the request to the node be successful, then that node will be set as the "sticky node". This will happen regardless of what failoverStrategy has been set.
+
+Any subsequent requests after the first successful one will continue to use "sticky node" as long as it continues to give successful requests. Should the node fail however, then it will be set at unavailable for the duration configured in the client settings (or the default time of 30000ms) and following requests will once again try to use a random available node and if successful set that one as the new "sticky node".
+
+#### Setting how long a node should be unavailable
+
+The duration that a node is configured as unavailable can be se in the failoverConfig of the client settings:
+
+```typescript
+  const client = createClient({
+  useStickyNode: true,
+  directoryNodeUrlPool: ["http://localhost:7740"],
+  failOverConfig: {
+  startegy: "abortOnErrror",
+  attemptsPerEndpoint: 4,
+  attemptInterval: 3000,
+  unreachableDuration: 50000,
+  }
+  ...restSettings
+  })
+```
+
 ### Failover strategies
 
 When initializing a client, you have the option to configure the failover strategy for the client. Additionally, you can modify certain parameters within the failover configuration, such as the number of attempts per endpoint and the interval between attempts.
@@ -178,10 +221,10 @@ const signatureProviderA = newSignatureProvider({ privKey: signerPrivKeyA });
 
 ### Simple Transaction
 
-The `signAndSendUniqueTransaction` function streamlines the process of sending a transaction in three steps. It adds a "nop" (no operation) with a random number that ensures the transaction is unique, signs it with a signature provider or private key, and sends it. The function generates a receipt that includes a status code, status, and transactionRID. The status code indicates whether the server successfully processed the transaction. The status represents the current stage of the transaction on the blockchain, which can be one of the following: `Waiting`, `Rejected`, `Confirmed`, or `Unknown`.
+The `signAndSendUniqueTransaction` function streamlines the process of sending a transaction in three steps. It adds a "nop" (no operation) with a random number that ensures the transaction is unique, signs it with a signature provider or private key, and sends it. The function generates a receipt that includes a status code, status, and tansactionRid. The status code indicates whether the server successfully processed the transaction. The status represents the current stage of the transaction on the blockchain, which can be one of the following: `Waiting`, `Rejected`, `Confirmed`, or `Unknown`.
 
 ```typescript
-const { status, statusCode, transactionRID } =
+const { status, statusCode, transactionRid } =
   await chromiaClient.signAndSendUniqueTransaction(
     {
       operations: [
@@ -412,10 +455,14 @@ Integration tests:
 1. Make sure a postgres database is running. Read more [here](https://docs.chromia.com/getting-started/dev-setup/database-setup).
 2. Start blockchain
 
-   `cd resources`
+   `cd resources/testDapp`
 
    `chr node start --wipe`
 
 3. Run tests
 
    `npm run test:integration`
+
+## Release process
+
+Guide regarding realease process is [here](docs/release.md)