chore: events for GraphTallyCollector and PaymentsEscrow contracts

config/addresses.template.ts

@@ -23,6 +23,8 @@ export class Addresses {
   ethereumDIDRegistry: string
   subgraphService: string
   graphPayments: string
+  paymentsEscrow: string
+  graphTallyCollector: string
   isL1: boolean
 }
 
@@ -51,5 +53,7 @@ export let addresses: Addresses = {
   ethereumDIDRegistry: '{{ethereumDIDRegistry}}',
   subgraphService: '{{subgraphService}}',
   graphPayments: '{{graphPayments}}',
+  paymentsEscrow: '{{paymentsEscrow}}',
+  graphTallyCollector: '{{graphTallyCollector}}',
   isL1: {{isL1}},
 }

config/arbitrumSepoliaAddressScript.ts

@@ -32,6 +32,8 @@ export let addresses: Addresses = {
   ethereumDIDRegistry: '{{arbsep.EthereumDIDRegistry.address}}',
   subgraphService: '{{arbsep.SubgraphService.address}}',
   graphPayments: '{{arbsep.GraphPayments.address}}',
+  paymentsEscrow: '{{arbsep.PaymentsEscrow.address}}',
+  graphTallyCollector: '{{arbsep.GraphTallyCollector.address}}',
   isL1: false,
 }
 
@@ -58,6 +60,12 @@ const main = (): void => {
     if(output.horizonDisputeManager == '') {
       output.horizonDisputeManager = '0x0000000000000000000000000000000000000000' // to avoid crashes due to bad config
     }
+    if(output.paymentsEscrow == '') {
+      output.paymentsEscrow = '0x0000000000000000000000000000000000000000' // to avoid crashes due to bad config
+    }
+    if(output.graphTallyCollector == '') {
+      output.graphTallyCollector = '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}`)

config/localNetworkAddressScript.ts

@@ -36,6 +36,8 @@ export let addresses: Addresses = {
   ethereumDIDRegistry: '{{horizon.EthereumDIDRegistry.address}}',
   subgraphService: '{{subgraphService.SubgraphService.address}}',
   graphPayments: '{{horizon.GraphPayments.address}}',
+  paymentsEscrow: '{{horizon.PaymentsEscrow.address}}',
+  graphTallyCollector: '{{horizon.GraphTallyCollector.address}}',
   isL1: false,
 }
 
@@ -55,6 +57,12 @@ const main = (): void => {
     if(output.disputeManager == '') {
       output.disputeManager = '0x0000000000000000000000000000000000000000' // to avoid crashes due to bad config
     }
+    if(output.paymentsEscrow == '') {
+      output.paymentsEscrow = '0x0000000000000000000000000000000000000000' // to avoid crashes due to bad config
+    }
+    if(output.graphTallyCollector == '') {
+      output.graphTallyCollector = '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}`)

config/mainnetArbitrumAddressScript.ts

@@ -32,6 +32,8 @@ export let addresses: Addresses = {
   ethereumDIDRegistry: '{{arbitrum.IEthereumDIDRegistry.address}}',
   subgraphService: '{{arbitrum.SubgraphService.address}}',
   graphPayments: '{{arbitrum.GraphPayments.address}}',
+  paymentsEscrow: '{{arbitrum.PaymentsEscrow.address}}',
+  graphTallyCollector: '{{arbitrum.GraphTallyCollector.address}}',
   isL1: false,
 }
 
@@ -59,6 +61,12 @@ const main = (): void => {
     if(output.horizonDisputeManager == '') {
       output.horizonDisputeManager = '0x0000000000000000000000000000000000000000' // to avoid crashes due to bad config
     }
+    if(output.paymentsEscrow == '') {
+      output.paymentsEscrow = '0x0000000000000000000000000000000000000000' // to avoid crashes due to bad config
+    }
+    if(output.graphTallyCollector == '') {
+      output.graphTallyCollector = '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}`)

config/testAddressesL1.ts

@@ -32,6 +32,8 @@ export let addresses: Addresses = {
   ethereumDIDRegistry: '0x0000000000000000000000000000000000000000',
   subgraphService: '0x0000000000000000000000000000000000000000',
   graphPayments: '0x0000000000000000000000000000000000000000',
+  paymentsEscrow: '0x0000000000000000000000000000000000000000',
+  graphTallyCollector: '0x0000000000000000000000000000000000000000',
   isL1: true,
 }
 

config/testAddressesL2.ts

@@ -32,6 +32,8 @@ export let addresses: Addresses = {
   ethereumDIDRegistry: '0x0000000000000000000000000000000000000000',
   subgraphService: '0x0000000000000000000000000000000000000000',
   graphPayments: '0x0000000000000000000000000000000000000000',
+  paymentsEscrow: '0x0000000000000000000000000000000000000000',
+  graphTallyCollector: '0x0000000000000000000000000000000000000000',
   isL1: false,
 }
 

schema.graphql

@@ -1779,3 +1779,91 @@ type _Schema_
     algorithm: rank
     include: [{ entity: "Delegator", fields: [{ name: "defaultDisplayName" }, { name: "id" }] }]
   )
+
+"""
+Revelant data for a PaymentsEscrow accounts
+"""
+type PaymentsEscrowAccount @entity(immutable: false) {
+  "The payer, collector and receiver concatenated"
+  id: Bytes!
+  "The payer address of the account"
+  payer: Payer!
+  "The collector address of the account"
+  collector: Bytes!
+  "The receiver address of the account"
+  receiver: Receiver!
+  "The balance of the account"
+  balance: BigInt!
+  "The amount of tokens thawing on the account"
+  totalAmountThawing: BigInt!
+  "The thaw end timestamp"
+  thawEndTimestamp: BigInt!
+  "The transactions for the escrow account"
+  transactions: [PaymentsEscrowTransaction!]! @derivedFrom(field: "escrowAccount")
+}
+
+"""
+Payer of a PaymentsEscrow account
+"""
+type Payer @entity(immutable: false) {
+  "The address of the payer"
+  id: Bytes!
+  "The account of the payer"
+  escrowAccounts: [PaymentsEscrowAccount!]! @derivedFrom(field: "payer")
+  "The transactions for the payer"
+  transactions: [PaymentsEscrowTransaction!]! @derivedFrom(field: "payer")
+  "The signers for the payer"
+  signers: [Signer!]! @derivedFrom(field: "payer")
+}
+
+"""
+Receiver of a PaymentsEscrow account
+"""
+type Receiver @entity(immutable: false) {
+  "The address of the receiver"
+  id: Bytes!
+  "The account of the receiver"
+  escrowAccounts: [PaymentsEscrowAccount!]! @derivedFrom(field: "receiver")
+  "The transactions for the receiver"
+  transactions: [PaymentsEscrowTransaction!]! @derivedFrom(field: "receiver")
+}
+
+"""
+Transactions for a PaymentsEscrow account
+"""
+type PaymentsEscrowTransaction @entity(immutable: false) {
+  "The transaction hash concatenated with event log index"
+  id: Bytes!
+  "The transaction group id"
+  transactionGroupId: Bytes
+  "The transaction type"
+  type: String!
+  "The payer"
+  payer: Payer!
+  "The collector"
+  collector: Bytes!
+  "The receiver"
+  receiver: Receiver!
+  "The allocation id"
+  allocationId: Bytes
+  "The amount of tokens"
+  amount: BigInt!
+  "The escrow account"
+  escrowAccount: PaymentsEscrowAccount!
+  "The transaction timestamp"
+  timestamp: BigInt!
+}
+
+"""
+The signer of a PaymentsEscrow account
+"""
+type Signer @entity(immutable: false) {
+  "The address of the signer"
+  id: Bytes!
+  "Whether the signer is authorized"
+  isAuthorized: Boolean!
+  "The payer that authorized the signer"
+  payer: Payer!
+  "The thaw end timestamp for revoking the signer"
+  thawEndTimestamp: BigInt!
+}

src/mappings/graphTallyCollector.ts

@@ -0,0 +1,80 @@
+import { Address, BigInt } from '@graphprotocol/graph-ts'
+import { PaymentsEscrowTransaction, Signer } from '../types/schema'
+import { 
+    SignerAuthorized,
+    SignerThawing,
+    SignerThawCanceled,
+    SignerRevoked,
+    PaymentCollected
+} from '../types/GraphTallyCollector/GraphTallyCollector'
+import { createOrLoadEscrowAccount, createOrLoadPayer, createOrLoadReceiver } from './paymentsEscrow'
+
+const BIGINT_ZERO = BigInt.fromI32(0)
+const ADDRESS_ZERO = Address.fromString('0x0000000000000000000000000000000000000000')
+
+export function handleSignerAuthorized(event: SignerAuthorized): void {
+    let signer = createOrLoadSigner(event.params.signer)
+    signer.isAuthorized = true
+    signer.payer = event.params.authorizer
+    signer.save()
+}
+
+export function handleSignerThawing(event: SignerThawing): void {
+    let signer = createOrLoadSigner(event.params.signer)
+    signer.payer = event.params.authorizer
+    signer.isAuthorized = true
+    signer.thawEndTimestamp = event.params.thawEndTimestamp
+    signer.save()
+}
+
+export function handleSignerThawCanceled(event: SignerThawCanceled): void {
+    let signer = createOrLoadSigner(event.params.signer)
+    signer.payer = event.params.authorizer
+    signer.isAuthorized = true
+    signer.thawEndTimestamp = BIGINT_ZERO
+    signer.save()
+}
+
+export function handleSignerRevoked(event: SignerRevoked): void {
+    let signer = createOrLoadSigner(event.params.signer)
+    signer.payer = event.params.authorizer
+    signer.isAuthorized = false
+    signer.thawEndTimestamp = BIGINT_ZERO
+    signer.save()
+}
+
+export function handlePaymentCollected(event: PaymentCollected): void {
+    let index = event.logIndex.toI32()
+    let transactionId = event.transaction.hash.concatI32(index)
+    let transaction = new PaymentsEscrowTransaction(transactionId)
+
+    let payer = createOrLoadPayer(event.params.payer)
+    let receiver = createOrLoadReceiver(event.params.receiver)
+    let escrow = createOrLoadEscrowAccount(event.params.payer, event.params.dataService, event.params.receiver)
+    escrow.balance = escrow.balance.minus(event.params.tokens)
+
+    transaction.type = 'redeem'
+    transaction.payer = payer.id
+    transaction.collector = event.params.dataService
+    transaction.receiver = receiver.id
+    transaction.allocationId = Address.fromBytes(event.params.collectionId)
+    transaction.amount = event.params.tokens
+    transaction.escrowAccount = escrow.id
+    transaction.transactionGroupId = event.transaction.hash
+    transaction.timestamp = event.block.timestamp
+
+    transaction.save()
+    escrow.save()
+}
+
+export function createOrLoadSigner(address: Address): Signer {
+    let signer = Signer.load(address)
+    if(signer == null) {
+        signer = new Signer(address)
+        signer.isAuthorized = false
+        signer.payer = ADDRESS_ZERO
+        signer.thawEndTimestamp = BIGINT_ZERO
+        signer.save()
+    }
+    return signer
+}

src/mappings/paymentsEscrow.ts

@@ -0,0 +1,107 @@
+import { Address, BigInt } from '@graphprotocol/graph-ts'
+import { PaymentsEscrowAccount, Payer, Receiver, PaymentsEscrowTransaction } from '../types/schema'
+import {
+  Deposit,
+  Withdraw,
+  Thaw,
+  CancelThaw,
+} from '../types/PaymentsEscrow/PaymentsEscrow'
+
+const BIGINT_ZERO = BigInt.fromI32(0)
+
+export function handleDeposit(event: Deposit): void {
+    let index = event.logIndex.toI32()
+    let transactionId = event.transaction.hash.concatI32(index)
+    let transaction = new PaymentsEscrowTransaction(transactionId)
+    let payer = createOrLoadPayer(event.params.payer)
+    let receiver = createOrLoadReceiver(event.params.receiver)
+    let escrow = createOrLoadEscrowAccount(event.params.payer, event.params.collector, event.params.receiver)
+
+    escrow.balance = escrow.balance.plus(event.params.tokens)
+
+    transaction.type = 'deposit'
+    transaction.payer = payer.id
+    transaction.collector = event.params.collector
+    transaction.receiver = receiver.id
+    transaction.amount = event.params.tokens
+    transaction.escrowAccount = escrow.id
+    transaction.transactionGroupId = event.transaction.hash
+    transaction.timestamp = event.block.timestamp
+
+    transaction.save()
+    escrow.save()
+}
+
+export function handleWithdraw(event: Withdraw): void {
+    let index = event.logIndex.toI32()
+    let transactionId = event.transaction.hash.concatI32(index)
+    let transaction = new PaymentsEscrowTransaction(transactionId)
+    let payer = createOrLoadPayer(event.params.payer)
+    let receiver = createOrLoadReceiver(event.params.receiver)
+    let escrow = createOrLoadEscrowAccount(event.params.payer, event.params.collector, event.params.receiver)
+
+    escrow.balance = escrow.balance.minus(event.params.tokens)
+    escrow.totalAmountThawing = BIGINT_ZERO
+    escrow.thawEndTimestamp = BIGINT_ZERO
+
+    transaction.type = 'withdraw'
+    transaction.payer = payer.id
+    transaction.collector = event.params.collector
+    transaction.receiver = receiver.id
+    transaction.amount = event.params.tokens
+    transaction.escrowAccount = escrow.id
+    transaction.transactionGroupId = event.transaction.hash
+    transaction.timestamp = event.block.timestamp
+
+    transaction.save()
+    escrow.save()
+}
+
+export function handleThaw(event: Thaw): void {
+    let escrow = createOrLoadEscrowAccount(event.params.payer, event.params.collector, event.params.receiver)
+
+    escrow.totalAmountThawing = event.params.tokens
+    escrow.thawEndTimestamp = event.params.thawEndTimestamp
+    escrow.save()
+}
+
+export function handleCancelThaw(event: CancelThaw): void {
+    let escrow = createOrLoadEscrowAccount(event.params.payer, event.params.collector, event.params.receiver)
+    escrow.totalAmountThawing = BIGINT_ZERO
+    escrow.thawEndTimestamp = BIGINT_ZERO
+    escrow.save()
+}
+
+export function createOrLoadPayer(address: Address): Payer {
+    let payer = Payer.load(address)
+    if(payer == null) {
+        payer = new Payer(address)
+        payer.save()
+    }
+    return payer
+}
+
+export function createOrLoadReceiver(address: Address): Receiver {
+    let receiver = Receiver.load(address)
+    if(receiver == null) {
+        receiver = new Receiver(address)
+        receiver.save()
+    }
+    return receiver
+}
+
+export function createOrLoadEscrowAccount(payer: Address, collector: Address, receiver: Address): PaymentsEscrowAccount {
+    let sender_receiver = payer.concat(collector).concat(receiver)
+    let escrow = PaymentsEscrowAccount.load(sender_receiver)
+    if(escrow == null) {
+        escrow = new PaymentsEscrowAccount(sender_receiver)
+        escrow.balance = BIGINT_ZERO
+        escrow.thawEndTimestamp = BIGINT_ZERO
+        escrow.totalAmountThawing = BIGINT_ZERO
+        escrow.payer = payer
+        escrow.collector = collector
+        escrow.receiver = receiver
+        escrow.save()
+    }
+    return escrow
+}