Unlisted Middleware example page

Generated new unlisted participants weight example page
Added Google Tag plugin and related config
Removed mainnet mentions from smart contracts page
Fixed address in Troubleshooting page

Author: RaekwonIII

docs/based-applications/developers/based-application-depvelopment.md

@@ -1,15 +1,15 @@
 ---
 sidebar_label: 'Based App Development'
-sidebar_position: 1
+sidebar_position: 2
 ---
 
 # Based Application Development
 
 This guide outlines the steps for based applications developers looking to build on the Based Applications platform.
 
-## 0. Developing a Based Application Middleware smart contract
+<!-- ## 0. Developing a Based Application Middleware smart contract
 
-The `BAppManager` smart contract developed by SSV Labs accepts registrations of BApps that implement a specific interface. This is outlined [in this dedicated page](./smart-contracts/based-app-middleware-example.md), that also provides a simple example.
+The `BAppManager` smart contract developed by SSV Labs accepts registrations of BApps that implement a specific interface. This is outlined [in this dedicated page](./smart-contracts/based-app-middleware-example.md), that also provides a simple example. -->
 
 ## 1. Configuring and Registering the bApp
 
@@ -67,9 +67,8 @@ bApp clients need to track the weight of each participant in the bApp.
 A simple way to do so would be to use the Subgraph and perform a request with this query:
 
 ```graphql
-
 query MyQuery {
-  bapp(id: "1") {
+  bapp(id: "0xaA184b86B4cdb747F4A3BF6e6FCd5e27c1d92c5a") {
     # this is a mapping table, representing the many-to-many relationship between bapps and strategies
     strategies {
       obligations {
@@ -100,48 +99,30 @@ query MyQuery {
 ```
 
 This will return:
-* **all balances** per token for a given strategy
-* **all obligations** per token for a given strategy
-* TODO add remaining data
+* **all `Strategies`** that opted in to the `bApp`
+* for each `Strategy`, it will also provide
+  * **all `Obligation`s** per token
+  * **all `balance`s** per token
+  * **all `Account`s** that delegated validator balance to the strategy owner
+* the **shared risk level** for each token added to the bApp
 
-For all the strategies that opted-in to a given bApp
+For all the strategies that opted-in to a given bApp, clients will have to:
 
-1. Clients will have to use this data to obtain a global mapping of `Token -> Strategy -> Amount`
-   
+1. **Gather Obligated Balances**: Get the obligated balance from each strategy, for each token used by the bApp.
+   ```go
+   ObligatedBalance mapping(Token -> Strategy -> Amount)
+   ```
    This is done by multiplying the `percentage` of obligated tokens by the `balance` of such tokens deposited to the strategy
 
-   ```typescript
-   // build a map that links each token with the mapping of a strategy and their related obligated balance
-   let strategiesObligatedBalancesPerToken: Map<string, Map<number, number>> = new Map();
-   
-   // build the two separate mappings of obligations per token, balances per token
-   // calculate the actual balance obligated for each token
-   // and add the entry to the global mapping
-   for (let strategy of response.data.data.bapp.strategies) {
-      let obligationsPerToken: Map<string, number> = new Map(strategy.obligations.map(
-         (obligation) => return [token, percentage]
-      ))
-      let balancesPerToken: Map<string, number> = new Map(strategy.strategy.balances.map(
-         (obligation) => return [token, balance]
-      ))
-
-      obligationsPerToken.keys().map(
-         (token) => {
-            strategiesObligatedBalancesPerToken.set(token) = new Map([strategy.id, obligationsPerToken.get(token) * balancesPerToken.get(token)])
-         }
-      )
-   }
-   ```
-2. TODO Add Validator balance calculation
-3. **Sum Obligations**: From `ObligatedBalance`, it can sum all obligations and compute the total amount obligated to the bApp by all strategies.
+2. **Sum Obligations**: From `ObligatedBalance`, bApps should sum all obligations and compute the total amount obligated to the bApp by all strategies.
    ```go
    TotalBAppBalance mapping(Token -> Amount)
    ```
-4. **Calculate Risk**: For each token, it should get the risk (token-over usage) of each strategy.
+3. **Calculate Risk**: For each token, it should get the risk (token-over usage) of each strategy. This is obtained by summing all the `percentages` in all `Obligations` for a given token, and dividing it by `100`.
    ```go
    Risk mapping(Token -> Strategy -> Float)
    ```
-5. **Compute Risk-Aware Weights**: With this information, it can compute the weight of a participant for a certain token by
+4. **Compute Risk-Aware Weights**: With this information, bApps can compute the weight of a participant for a certain token by
 
    $$
    W_{\text{strategy, token}} = c_{\text{token}} \times \dfrac{ObligatedBalance[\text{token}][\text{strategy}]}{TotalBAppBalance[\text{token}]} e^{-\beta_{\text{token}} \times max(1, Risk[\text{token}][\text{strategy}])}
@@ -153,25 +134,29 @@ For all the strategies that opted-in to a given bApp
    c_{\text{token}} = \left( \sum_{\text{strategy}} \dfrac{ObligatedBalance[\text{token}][\text{strategy}]}{TotalBAppBalance[\text{token}]} e^{-\beta_{\text{token}} \times max(1, Risk[\text{token}][\text{strategy}])} \right)^{-1}
    $$
 
-   :::info
-   If the bApp uses validator balance, the client should also read a `map[Strategy]ValidatorBalance` with the amount from each strategy. As this capital doesn't involve any type of risk, all risk values can be set to 0. Thus, for this capital, this is equivalent to
+5. **If the bApp uses validator balance**, the client should also generate a mapping of `Strategy -> Validator Balance` with the amount from each strategy.
+   
+   This is obtained as *the sum of all the validator balances delegated to the owner of the strategy*. Bear in mind, these are stored as percentages, so the actual *effective validator balance* for a given `delegator` has to be looked up the beacon chain (the [`based-apps-sdk`](https://github.com/ssvlabs/based-apps-sdk) provides a function to do this: `getValidatorsBalance(account)`), and then multiplied by the percentage that is delegated.
+   
+   As this capital doesn't involve any type of risk, all risk values can be set to 0. Thus, for this capital, this is equivalent to:
+
    $$
    W_{\text{strategy, validator balance}} = \dfrac{ObligatedBalance[\text{validator balance}][\text{strategy}]}{TotalBAppBalance[\text{validator balance}]}
    $$
-   :::
 
 6. **Combine into the Final Weight**: With the per-token weights, the final step is to compute a final weight for the participant using a **combination function**. Such function is defined by the bApp and can be tailored to its specific needs. Traditional examples include the arithmetic mean, geometric mean, and harmonic mean.
 
 
-   **Example**: Let's consider a bApp that uses tokens $A$ and $B$, and considers $A$ to be twice as important as $B$. Then, it could use the following weighted harmonic mean as its combination function:
+**Example**: Let's consider a bApp that uses tokens $A$ and $B$, and considers $A$ to be twice as important as $B$. Then, it could use the following weighted harmonic mean as its combination function:
 
-   $$
-   W^{\text{final}}_{\text{strategy}} = c_{\text{final}} \times \dfrac{1}{\dfrac{2/3}{W_{\text{strategy, A}}} + \dfrac{1/3}{W_{\text{strategy, B}}}}
-   $$
+$$
+W^{\text{final}}_{\text{strategy}} = c_{\text{final}} \times \dfrac{1}{\dfrac{2/3}{W_{\text{strategy, A}}} + \dfrac{1/3}{W_{\text{strategy, B}}}}
+$$
 
-   where $c_{\text{final}}$ is a normalization constant computed as
+where $c_{\text{final}}$ is a normalization constant computed as
 
-   $$
-   c_{\text{final}} = \left( \sum_{\text{strategy}} \dfrac{1}{\dfrac{2/3}{W_{\text{strategy, A}}} + \dfrac{1/3}{W_{\text{strategy, B}}}} \right)^{-1}
-   $$
+$$
+c_{\text{final}} = \left( \sum_{\text{strategy}} \dfrac{1}{\dfrac{2/3}{W_{\text{strategy, A}}} + \dfrac{1/3}{W_{\text{strategy, B}}}} \right)^{-1}
+$$
 
+<!-- [At the following page](./participant-weight-example.md), you can find a coded example of how to combine Subgraph data with the logic described above. -->

docs/based-applications/developers/participant-weight-example.md

@@ -0,0 +1,113 @@
+---
+sidebar_label: 'Participant Weight Example'
+sidebar_position: 3
+unlisted: true
+---
+
+# Participant Weight Script
+
+The script below uses the logic described in the [related section of the Based Application Development page](based-application-depvelopment.md/#3-participant-weight), fetching the data from the Based Application Subgraph, and returns the Weight for all Strategies that have opted in to a given Based Application
+   
+```typescript
+import fetch from "node-fetch";
+
+// Define the GraphQL endpoint URL
+const url = "https://api.studio.thegraph.com/query/53804/ssv-bapps-subgraph/version/latest";
+
+// Define the GraphQL query - Update operators and account address to query different clusters
+const query = `{
+  bapp(id: "0xaA184b86B4cdb747F4A3BF6e6FCd5e27c1d92c5a") {
+    # this is a mapping table, representing the many-to-many relationship between bapps and strategies
+    strategies {
+      obligations {
+        token
+        percentage
+      }
+      # this is the actual strategy entity
+      strategy {
+        balances {
+          balance
+          token
+        }
+        id
+        owner {
+          delegators {
+            percentage
+            id
+          }
+        }
+      }
+    }
+    bAppTokens {
+      sharedRiskLevel
+      token
+    }
+  }
+}`
+
+// Function to fetch data
+async function fetchData() {
+  try {
+    // Make the HTTP request to the GraphQL endpoint
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ query })
+    });
+
+    // Parse the response data
+    const responseData = await response.json();
+
+   // ➡️ 1. **Gather Obligated Balances**
+   // build a map that links each token with the mapping of a strategy and their related obligated balance
+   let strategiesObligatedBalancesPerToken: Map<string, Map<number, number>> = new Map();
+
+   // build the two separate mappings of obligations per token, balances per token
+   // calculate the actual balance obligated for each token
+   // and add the entry to the global mapping
+   for (let strategy of response.data.data.bapp.strategies) {
+      let obligationsPerToken: Map<string, number> = new Map(strategy.obligations.map(
+         (obligation) => return [token, percentage]
+      ))
+      let balancesPerToken: Map<string, number> = new Map(strategy.strategy.balances.map(
+         (obligation) => return [token, balance]
+      ))
+
+      obligationsPerToken.keys().map(
+         (token) => {
+            strategiesObligatedBalancesPerToken.set(token) = new Map([strategy.id, obligationsPerToken.get(token) * balancesPerToken.get(token)])
+         }
+      )
+   }
+
+   // ➡️ 2. **Sum Obligations**
+   let totalBAppBalancePerToken: Map<string, number> = new Map();
+
+   strategiesObligatedBalancesPerToken.entries().map(
+      (token, strategyObligationsPerToken) => {
+         totalBAppBalancePerToken.set(token) = strategyObligationsPerToken.values().reduce((accumulator, currentValue) => accumulator + currentValue, 0);
+      }
+    )
+   
+   // ➡️ 3. **Calculate Risk**
+   let riskPerTokenPerStrategy: Map<string, Map<number, number>>
+   // ➡️ 4. **Compute Risk-Aware Weights**
+   let cToken = 
+   // ➡️ 5. **Gather Obligated Validator Balances**
+   // ➡️ 6. **Combine into the Final Weight**
+
+
+
+
+
+  } catch (error) {
+    // Log any errors that occur during the fetch
+    console.error("Error fetching data:", error);
+  }
+}
+
+// Run the fetchData function
+fetchData();
+```

docs/based-applications/developers/smart-contracts/README.md

@@ -15,7 +15,6 @@ This smart contract is under development and as such, it is only deployed on Hol
 
 
 #### Holesky Testnet
-<!-- TODO missing deployment address -->
 | Contract        | Address                                                                                                      |
 |-----------------|-------------------------------------------------------------------------------------------------------------|
 | BasedAppManager       | [`0x9B3345F3B1Ce2d8655FC4B6e2ed39322d52aA317`](https://holesky.etherscan.io/address/0x9B3345F3B1Ce2d8655FC4B6e2ed39322d52aA317) |
@@ -24,5 +23,4 @@ This smart contract is under development and as such, it is only deployed on Hol
 #### ABI
 
 <!-- TODO missing ABI -->
-* [Mainnet](https://github.com/ssvlabs/based-applications/tree/contract-abi/docs/mainnet/v1.1.0/abi)
 * [Testnet](https://github.com/ssvlabs/based-applications/tree/contract-abi/docs/testnet/v1.1.0/abi)

docs/based-applications/developers/smart-contracts/based-app-middleware-example.md

@@ -1,6 +1,7 @@
 ---
 sidebar_label: 'Based App Middleware Example'
 sidebar_position: 2
+unlisted: true
 ---
 
 # :warning: PAGE UNDER CONSTRUCTION :warning:

docs/based-applications/developers/smart-contracts/troubleshooting.md

@@ -12,5 +12,4 @@ The best way to investigate this issue is to inspect the 4-byte selector for the
 
 A useful tool that is able to do this comparison, is [tenderly](https://dashboard.tenderly.co/explorer), thanks to the fact that ssv.network's Smart Contracts have been verified. 
 
-<!-- TODO fix address -->
-Here is the [SSVNetwork contract, for example](https://dashboard.tenderly.co/contract/holesky/0x).  
+Here is the [`BasedAppManager` contract, for example](https://dashboard.tenderly.co/contract/holesky/0x9B3345F3B1Ce2d8655FC4B6e2ed39322d52aA317).  

docusaurus.config.ts

@@ -39,15 +39,17 @@ const config: Config = {
           sidebarPath: './sidebars.ts',
           remarkPlugins: [remarkMath],
           rehypePlugins: [rehypeKatex],
-
-          // Please change this to your repo.
-          // Remove this to remove the "edit this page" links.
           editUrl:
-            'https://github.com/ssvlabs/gitbook-docs/tree/main/packages/create-docusaurus/templates/shared/',
+            'https://github.com/ssvlabs/gitbook-docs/tree/main/',
+            
         },
         theme: {
           customCss: './src/css/custom.css',
         },
+        gtag: {
+          trackingID: 'G-PYFERXZQP7',
+          anonymizeIP: true,
+        },
       } satisfies Preset.Options,
     ],
   ],