[subgraph-split-delegation] New strategy: Subgraph split delegation

src/strategies/index.ts

@@ -1,6 +1,7 @@
 import { readFileSync } from 'fs';
 import path from 'path';
 
+import * as subgraphSplitDelegation from './subgraph-split-delegation';
 import * as polygonSelfStaked from './polygon-self-staked-pol';
 import * as delegatexyzErc721BalanceOf from './delegatexyz-erc721-balance-of';
 import * as urbitGalaxies from './urbit-galaxies/index';
@@ -831,6 +832,7 @@ const strategies = {
   spaceid,
   'delegate-registry-v2': delegateRegistryV2,
   'split-delegation': splitDelegation,
+  'subgraph-split-delegation': subgraphSplitDelegation,
   'polygon-self-staked-pol': polygonSelfStaked,
   'hats-protocol-single-vote-per-org': hatsProtocolSingleVotePerOrg,
   'karma-discord-roles': karmaDiscordRoles,

src/strategies/subgraph-split-delegation/README.md

@@ -0,0 +1,33 @@
+# subgraph-split-delegation
+
+If you want to delegate your voting power to different addresses, you can use this strategy to calculate the voting power that will be delegated based on the Subgraph data.
+
+```TEXT
+Total VP = incoming delegated VP + own VP - outgoing delegated VP
+```
+
+The sub strategies defined in params are used to get the votint power that will be delegated based on the Subgraph data.
+
+| Param Name      | Description |
+| ----------- | ----------- |
+| strategies      | list of sub strategies to calculate voting power based on delegation      |
+| subgraphUrl   | The URL of the subgraph to query for the delegation data        |
+
+Here is an example of parameters:
+
+```json
+{
+  "subgraphUrl": "https://api.studio.thegraph.com/query/87073/split-delegation/v0.0.5",
+  "strategies": [
+    {
+      "name": "erc20-balance-of",
+      "params": {
+        "address": "0xD01Db8Fb3CE7AeeBfB24317E12a0A854c256E99b",
+        "symbol": "EPT",
+        "decimals": 18
+      }
+    }
+  ]
+}
+
+```

src/strategies/subgraph-split-delegation/examples.json

@@ -0,0 +1,35 @@
+[
+  {
+    "name": "Subgraph split delegation",
+    "strategy": {
+      "name": "subgraph-split-delegation",
+      "params": {
+        "subgraphUrl": "https://api.studio.thegraph.com/query/87073/split-delegation/v0.0.5",
+        "strategies": [
+          {
+            "name": "erc20-balance-of",
+            "params": {
+              "address": "0xD01Db8Fb3CE7AeeBfB24317E12a0A854c256E99b",
+              "symbol": "EPT",
+              "decimals": 18
+            }
+          }
+        ]
+      }
+    },
+    "network": "11155111",
+    "addresses": [
+      "0xb347106e4a026dd86c4bbe8df7274ba9ee7442cc",
+      "0x048fee7c3279a24af0790b6b002ded42be021d2b",
+      "0x139a9032a46c3afe3456eb5f0a35183b5f189cae",
+      "0xc1d60f584879f024299da0f19cdb47b931e35b53",
+      "0x376c649111543c46ce15fd3a9386b4f202a6e06c",
+      "0x0dcbc5d2bda11c4247d088f1ac5209e30f47b595",
+      "0x35911cc89aabe7af6726046823d5b678b6a1498d",
+      "0x6cdebe940bc0f26850285caca097c11c33103e47",
+      "0xa76c5788be9a2e1416de639c50c60b184d0ceccd",
+      "0xffb026f67da0869eb3abb090cb7f015ce0925cdf"
+    ],
+    "snapshot": 6716841
+  }
+]

src/strategies/subgraph-split-delegation/index.ts

@@ -0,0 +1,210 @@
+import { getAddress } from '@ethersproject/address';
+import { subgraphRequest, getScoresDirect } from '../../utils';
+import { Strategy } from '@snapshot-labs/snapshot.js/dist/src/voting/types';
+
+export const author = 'aragon';
+export const version = '0.1.0';
+
+const DEFAULT_BACKEND_URL =
+  'https://api.studio.thegraph.com/query/87073/split-delegation/version/latest';
+
+type Params = {
+  subgraphUrl: string;
+  strategies: Strategy[];
+};
+
+type Delegation = {
+  delegator?: Member;
+  delegatee?: Member;
+  ratio: number;
+};
+
+type Member = {
+  id?: string;
+  address: string;
+  delegators?: Delegation[];
+  delegatees?: Delegation[];
+};
+
+export async function strategy(
+  space: string,
+  network: string,
+  provider: any,
+  addresses: string[],
+  options: Params = {
+    subgraphUrl: DEFAULT_BACKEND_URL,
+    strategies: []
+  },
+  snapshot: string | number
+) {
+  const blockTag = typeof snapshot === 'number' ? snapshot : 'latest';
+  const block = await provider.getBlock(blockTag);
+
+  const members = await getDelegations(
+    options.subgraphUrl,
+    addresses,
+    space,
+    block
+  );
+
+  addresses = addresses.map(getAddress);
+
+  const allAddresses = new Set(addresses);
+
+  members.forEach((member) => {
+    allAddresses.add(member.address);
+    member.delegators?.forEach((delegation) =>
+      delegation.delegator
+        ? allAddresses.add(delegation.delegator.address)
+        : null
+    );
+    member.delegatees?.forEach((delegation) =>
+      delegation.delegatee
+        ? allAddresses.add(delegation.delegatee.address)
+        : null
+    );
+  });
+
+  const scores: { [k: string]: unknown }[] = (
+    await getScoresDirect(
+      space,
+      options.strategies,
+      network,
+      provider,
+      [...allAddresses],
+      snapshot
+    )
+  ).filter((score) => Object.keys(score).length !== 0);
+
+  return Object.fromEntries(
+    addresses.map((address) => {
+      const member = members.find(
+        (member) => member.address.toLowerCase() === address.toLowerCase()
+      );
+      return [
+        getAddress(address),
+        member ? getVp(member, scores) : getAddressScore(scores, address)
+      ];
+    })
+  );
+}
+
+const getAddressScore = (
+  scores: { [k: string]: any }[],
+  address?: string
+): any => {
+  if (!address) return 0;
+  return scores.reduce((total, score) => total + (score[address] ?? 0), 0);
+};
+
+const getVp = (member: Member, scores: { [k: string]: any }[]): any => {
+  const addressScore = getAddressScore(scores, member.address);
+  const delegatedVp =
+    member.delegatees?.reduce((total, delegation) => {
+      const vp = addressScore;
+      return total + delegation.ratio * vp;
+    }, 0) ?? 0;
+  const receivedVp =
+    member.delegators?.reduce((total, delegation) => {
+      const vp = getAddressScore(scores, delegation.delegator?.address);
+      return total + delegation.ratio * vp;
+    }, 0) ?? 0;
+
+  return addressScore + receivedVp - delegatedVp;
+};
+
+async function getDelegations(
+  subgraphURL: string,
+  addresses: string[],
+  space: string,
+  block: any
+): Promise<Member[]> {
+  const chunkSize = 25;
+  const pageSize = 20; // chunkSize * pageSize * 2 <= 1000 (max elements per query)
+
+  const chunks: string[][] = [];
+  for (let i = 0; i < addresses.length; i += chunkSize) {
+    chunks.push(addresses.slice(i, i + chunkSize));
+  }
+
+  const results: Member[] = [];
+  for (const chunk of chunks) {
+    let page = 0;
+    let reqAddresses = chunk.map((address) => address.toLowerCase());
+    while (reqAddresses.length) {
+      const params = {
+        members: {
+          __args: {
+            block: { number: block.number },
+            where: {
+              address_in: reqAddresses
+            }
+          },
+          id: true,
+          address: true,
+          delegators: {
+            __args: {
+              where: {
+                context: space,
+                expirationTimestamp_gte: block.timestamp
+              },
+              first: pageSize,
+              skip: page * pageSize
+            },
+            delegator: {
+              address: true
+            },
+            ratio: true
+          },
+          delegatees: {
+            __args: {
+              where: {
+                context: space,
+                expirationTimestamp_gte: block.timestamp
+              },
+              first: pageSize,
+              skip: page * pageSize
+            },
+            delegatee: {
+              address: true
+            },
+            ratio: true
+          }
+        }
+      };
+      const result: { members: Member[] } = await subgraphRequest(
+        subgraphURL,
+        params
+      );
+      result.members.forEach((newMember) => {
+        const existingMemberIndex = results.findIndex(
+          (member) =>
+            member.address.toLowerCase() === newMember.address.toLowerCase()
+        );
+        if (existingMemberIndex !== -1) {
+          const existingMember = results[existingMemberIndex];
+          existingMember.delegatees = [
+            ...(existingMember.delegatees || []),
+            ...(newMember.delegatees || [])
+          ];
+          existingMember.delegators = [
+            ...(existingMember.delegators || []),
+            ...(newMember.delegators || [])
+          ];
+        } else {
+          results.push(newMember);
+        }
+      });
+      reqAddresses = result.members
+        .filter(
+          (member) =>
+            member.delegatees?.length === pageSize ||
+            member.delegators?.length === pageSize
+        )
+        .map((member) => member.address);
+      page++;
+    }
+  }
+
+  return results;
+}

src/strategies/subgraph-split-delegation/schema.json

@@ -0,0 +1,44 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$ref": "#/definitions/Strategy",
+  "definitions": {
+    "Strategy": {
+      "title": "Strategy",
+      "type": "object",
+      "properties": {
+        "subgraphUrl": {
+          "type": "string",
+          "title": "Subgraph endpoint"
+        },
+        "strategies": {
+          "title": "Strategies",
+          "type": "array",
+          "items": {
+            "title": "Strategy",
+            "type": "object",
+            "properties": {
+              "name": {
+                "type": "string"
+              },
+              "network": {
+                "type": "string"
+              },
+              "params": {
+                "type": "object"
+              }
+            },
+            "required": [
+              "name",
+              "params"
+            ]
+          }
+        }
+      },
+      "required": [
+        "subgraphUrl",
+        "strategies"
+      ],
+      "additionalProperties": false
+    }
+  }
+}