fix: proper decoding for ServiceProviderRegistered

Signed-off-by: Tomás Migone <[email protected]>

Author: tmigone

config/localNetworkAddressScript.ts

@@ -0,0 +1,64 @@
+import * as fs from 'fs'
+import * as mustache from 'mustache'
+// Replace with proper imports once the packages are published
+import * as networkAddresses from '/opt/contracts.json'
+import { Addresses } from './addresses.template'
+
+// mustache doesn't like numbered object keys
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let renameAddresses: any = networkAddresses
+renameAddresses['localnetwork'] = networkAddresses['1337']
+
+export let addresses: Addresses = {
+  controller: '{{localnetwork.Controller.address}}',
+  graphToken: '{{localnetwork.L2GraphToken.address}}',
+  epochManager: '{{localnetwork.EpochManager.address}}',
+  disputeManager: '{{localnetwork.DisputeManager.address}}',
+  staking: '{{localnetwork.HorizonStaking.address}}',
+  stakingExtension: '{{localnetwork.HorizonStaking.address}}',
+  curation: '{{localnetwork.L2Curation.address}}',
+  rewardsManager: '{{localnetwork.RewardsManager.address}}',
+  serviceRegistry: '0x0000000000000000000000000000000000000000',
+  gns: '{{localnetwork.L2GNS.address}}',
+  ens: '{{localnetwork.IENS.address}}',
+  ensPublicResolver: '{{localnetwork.IPublicResolver.address}}',
+  blockNumber: '',
+  bridgeBlockNumber: '',
+  network: '',
+  tokenLockManager: '',
+  subgraphNFT: '{{localnetwork.SubgraphNFT.address}}',
+  l1GraphTokenGateway: '',
+  l2GraphTokenGateway: '{{localnetwork.L2GraphTokenGateway.address}}',
+  ethereumDIDRegistry: '{{localnetwork.EthereumDIDRegistry.address}}',
+  subgraphService: '{{localnetwork.SubgraphService.address}}',
+  graphPayments: '{{localnetwork.GraphPayments.address}}',
+  isL1: false,
+}
+
+const main = (): void => {
+  try {
+    let output = JSON.parse(mustache.render(JSON.stringify(addresses), renameAddresses))
+    output.blockNumber = '1'
+    output.bridgeBlockNumber = '1'
+    output.network = 'hardhat'
+    output.useTokenLockManager = false
+    if(output.ens == '') {
+      output.ens = '0x0000000000000000000000000000000000000000' // to avoid crashes due to bad config
+    }
+    if(output.ethereumDIDRegistry == '') {
+      output.ethereumDIDRegistry = '0x0000000000000000000000000000000000000000' // to avoid crashes due to bad config
+    }
+    // remove once we have proper packages
+    if(output.subgraphService == '') {
+      output.subgraphService = '0x0000000000000000000000000000000000000000' // to avoid crashes due to bad config
+    }
+    if(output.graphPayments == '') {
+      output.graphPayments = '0x0000000000000000000000000000000000000000' // to avoid crashes due to bad config
+    }
+    fs.writeFileSync(__dirname + '/generatedAddresses.json', JSON.stringify(output, null, 2))
+  } catch (e) {
+    console.log(`Error saving artifacts: ${e.message}`)
+  }
+}
+
+main()

package.json

@@ -43,7 +43,7 @@
   "devDependencies": {
     "@graphprotocol/contracts": "6.2.0",
     "@graphprotocol/graph-cli": "0.68.5",
-    "@graphprotocol/graph-ts": "0.32.0",
+    "@graphprotocol/graph-ts": "0.38.0",
     "@types/node": "^14.0.13",
     "@typescript-eslint/eslint-plugin": "^3.3.0",
     "@typescript-eslint/parser": "^3.3.0",
@@ -57,6 +57,5 @@
   "bugs": {
     "url": "https://github.com/graphprotocol/graph-network-subgraph/issues"
   },
-  "homepage": "https://github.com/graphprotocol/graph-network-subgraph#readme",
-  "dependencies": {}
+  "homepage": "https://github.com/graphprotocol/graph-network-subgraph#readme"
 }

schema.graphql

@@ -693,6 +693,8 @@ type Indexer @entity {
   url: String
   "Geohash of the indexer. Shows where their indexer is located in the world"
   geoHash: String
+  "Address that receives the rewards from the indexer"
+  rewardsDestination: Bytes
   "Default display name is the current default name. Used for filtered queries"
   defaultDisplayName: String
 

src/mappings/helpers/decoder.ts

@@ -0,0 +1,20 @@
+import { ByteArray, Bytes } from '@graphprotocol/graph-ts';
+
+
+// Wrap arguments with this function if (and only if) one of the arguments is an array or 'bytes' or 'string' (i.e. variable length arg)
+// See:
+// - https://medium.com/@r2d2_68242/indexing-transaction-input-data-in-a-subgraph-6ff5c55abf20
+// - https://ethereum.stackexchange.com/questions/114582/the-graph-nodes-cant-decode-abi-encoded-data-containing-arrays
+// - https://github.com/enzymefinance/subgraphs/blob/main/packages/utils/utils/decode.ts
+export function tuplePrefixBytes(input: Bytes): Bytes {
+  let inputTypedArray = input.subarray(0);
+
+  let tuplePrefix = ByteArray.fromHexString('0x0000000000000000000000000000000000000000000000000000000000000020');
+
+  let inputAsTuple = new Uint8Array(tuplePrefix.length + inputTypedArray.length);
+
+  inputAsTuple.set(tuplePrefix, 0);
+  inputAsTuple.set(inputTypedArray, tuplePrefix.length);
+
+  return Bytes.fromUint8Array(inputAsTuple);
+}

src/mappings/helpers/helpers.ts

@@ -178,6 +178,10 @@ export function createOrLoadIndexer(indexerAddress: Bytes, timestamp: BigInt): I
     indexer.annualizedReturn = BigDecimal.fromString('0')
     indexer.stakingEfficiency = BigDecimal.fromString('0')
 
+    indexer.url = ''
+    indexer.geoHash = ''
+    indexer.rewardsDestination = Address.fromString('0x0000000000000000000000000000000000000000')
+
     let graphAccount = createOrLoadGraphAccount(indexerAddress, timestamp)
     graphAccount.indexer = id
     graphAccount.save()

src/mappings/subgraphService.ts

@@ -3,15 +3,30 @@ import { AllocationClosed, AllocationCreated, AllocationResized, DelegationRatio
 import { batchUpdateSubgraphSignalledTokens, calculatePricePerShare, createOrLoadDataService, createOrLoadEpoch, createOrLoadGraphNetwork, createOrLoadIndexerQueryFeePaymentAggregation, createOrLoadPaymentSource, createOrLoadProvision, createOrLoadSubgraphDeployment, joinID, updateDelegationExchangeRate } from "./helpers/helpers"
 import { Allocation, GraphAccount, Indexer, PoiSubmission, SubgraphDeployment } from "../types/schema"
 import { addresses } from "../../config/addresses"
+import { tuplePrefixBytes } from "./helpers/decoder"
+import { createOrLoadIndexer } from "./helpers/helpers"
 
 export function handleServiceProviderRegistered(event: ServiceProviderRegistered): void {
-    let decodedCalldata = ethereum.decode('(string,string,address)', event.params.data)
+    let decodedCalldata = ethereum.decode('(string,string,address)', tuplePrefixBytes(event.params.data))
     if (decodedCalldata != null && decodedCalldata.kind == ethereum.ValueKind.TUPLE) {
         let tupleData = decodedCalldata.toTuple()
+        let url = tupleData[0].toString()
+        let geoHash = tupleData[1].toString()
+        let rewardsDestination = tupleData[2].toAddress()
+        
+        // Update provision
         let provision = createOrLoadProvision(event.params.serviceProvider, event.address, event.block.timestamp)
-        provision.url = tupleData[0].toString()
-        provision.geoHash = tupleData[1].toString()
+        provision.url = url
+        provision.geoHash = geoHash
+        provision.rewardsDestination = rewardsDestination
         provision.save()
+
+        // Update indexer
+        let indexer = createOrLoadIndexer(event.params.serviceProvider, event.block.timestamp)
+        indexer.url = url
+        indexer.geoHash = geoHash
+        indexer.rewardsDestination = rewardsDestination
+        indexer.save()
     } else {
         log.warning("ServiceProviderRegistered failed to decode: {}", [event.params.data.toHexString()])
     }