Implementing first pass of veAllocate schema, handlers, and test cove… (#490)

* Implementing first pass of veAllocate schema, handlers, and test coverage.

* Fixed compiling issues, wrote compiling & testing outline inside of veAllocate.test. More to come.

* Created documentation. Moving tests away from subgraph and into df-py.

* Expanding documentation to be thorough and cover more of the work involved.

* use barge artifacts

* use proper contracts in ci

* use barge artifacts folder

* fix replace

* use npm contracts dep

* use latest contracts for barge

* fix some lint

* Fix linter errors

* Update schema

* Finished basic integration of setAllocation event and verified queries/schema is working as intended.

* Fixing amount getter.

* Fixed remaining implementation, verified SimpleSubgraph.test is working, and fixed lint errors.

* Fixing import.

* Use .zero()

* Improve readability

* Add allocated to schema

* Update abi

* Update event handlers in the template

* Update veREADME

* Remove `AllocationRemoved` handler

* Hooking data for tx, firstContact, lastUpdate, block

* Update event abi

* Add chainId and nftAddress to schema

* Update `handleAllocationSet`

* Update abi

* Update readme

* Set initial values

* Fix math

* Missing event param

* set initial value of `lastContact`

* veOcean template

* VeOcean entity

* Handler functions - wip

* rename file

* Delegation schema

* veDelegate mapping file

* Rename

* Update template

* Update schema

* Update replaces

* Add handler for delegation

* Update schema

* getveDelegation

* Update naming

* Add deposit entity

* Update template

* Make delegation an array

* Add `handleDelegation`

* Add `handleDeposit` for veOCEAN

* Add `getveOCEAN` util function

* Add `getDeposit` util function

* Add `handleBurnBoost`

* Add `handleExtendBoost`

* Add `handleTransferBoost`

* Set default veOCEAN

* Remove unused import

* Rename Deposit to VeDeposit

* Include block number

* Remove `allocatedTotal`

* Updating schema and fixing errors due to naming changes. Let's keep the user current allocation, maybe we need to create a feature to more easily let them know whether they are fully allocated, or not..

* bump contracts to v1.1.1

* bump contracts

* bump to contracts 1.1.2

* fix script for networks without ve

* add veAllocation.sol's AllocationSetMultiple

* copy artfacts from barge for npm quickstart:barge

* fix using barge artifacts

* temp debug

* use barge artifacts

* use contracts 1.1.3

* use same approach for 'development'

* bump ocean-contracts

Co-authored-by: alexcos20 <alex.coseru@gmail.com>
Co-authored-by: mihaisc <mihai@oceanprotocol.com>
Co-authored-by: trizin <25263018+trizin@users.noreply.github.com>
pull/524/head
Idiom 3 months ago committed by GitHub
parent dbb296063b
commit a10c6244b5
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
  1. 4
      .github/workflows/tests.yml
  2. 166
      docs/README-local-veSubgraph.md
  3. 14
      package-lock.json
  4. 1
      package.json
  5. 95
      schema.graphql
  6. 28
      scripts/generatenetworkssubgraphs.js
  7. 5
      src/mappings/utils/constants.ts
  8. 194
      src/mappings/utils/veUtils.ts
  9. 35
      src/mappings/veAllocate.ts
  10. 63
      src/mappings/veDelegation.ts
  11. 30
      src/mappings/veOCEAN.ts
  12. 130
      subgraph.template.yaml
  13. 68
      subgraph_ve.template.yaml
  14. 124
      test/integration/SimpleSubgraph.test.ts

@ -52,7 +52,7 @@ jobs:
run: |
bash -x start_ocean.sh --with-thegraph --skip-subgraph-deploy --no-dashboard 2>&1 > start_ocean.log &
env:
CONTRACTS_VERSION: v1.0.0-alpha.28
CONTRACTS_VERSION: v1.1.3
- run: npm ci
@ -69,6 +69,8 @@ jobs:
sleep 20
env:
ADDRESS_FILE: /home/runner/.ocean/ocean-contracts/artifacts/address.json
BARGE_FOLDER: /home/runner/.ocean/
- run: npm run test-integration
env:
ADDRESS_FILE: /home/runner/.ocean/ocean-contracts/artifacts/address.json
BARGE_FOLDER: /home/runner/.ocean/

@ -0,0 +1,166 @@
# Add contract as dataSource and use local Subgraph + Ganache + Brownie
To develop new features on top of `ocean-subgraph`, it pays to deploy a local Subgraph that consumes from Ganache, so you can deploy your Contracts, execute their functionality, and query the Subgraph to verify Events are being Handled correctly, w/ the right Schema being yielded.
The following doc takes you through:
1. Configuring `docker-compose.yml` to run an internal Subgraph that consumes from a local Ganache.
2. Configuring `df-py` + Brownie to connect to the `ocean-subgraph` Ganache so we can deploy our local contracts.
3. Adding our smart contract as a dataSource for our internal Subgraph. We can then handle contract events, and transform that data into queryable entities using GQL.
4. Finally, we can hook our contracts into Testing & verifying that your subgraph is working as intended.
Note 1: For this tutorial, you should be using multiple terminal windows. These will be referred to at the top of each section.
Note 2: For this example, we're going to use the `df-py` repository and integrate `veAllocate` contract into `ocean-subgraph`
Note 3: For the sake of versatility, the example below is being executed using `df-py` while verification is being done by hand by viewing & querying GQL on the browser.
### 1. ocean-subgraph - Add & Connect Ganache
Section 1 takes place inside `ocean-subgraph` terminal window.
You should have this repository configured and working on your machine.
We now need to update `./docker/docker-compose.yml` to implement a local instance of Ganache. Our `graph-node` needs to listen to Ganache for events, so we update the ethereum url.
```
services:
ganache:
image: trufflesuite/ganache-cli:latest
ports:
- 8545:8545
entrypoint: ["node", "/app/ganache-core.docker.cli.js", "--db", "./ganache_cache","--chainId","0x2324","--networkId","0x2324","--gasLimit","10000000000","--gasPrice","1","---hardfork","istanbul","--mnemonic","${GANACHE_MNEMONIC}", "-e", "100", "-a", "20"]
graph-node:
environment:
ethereum: 'development:http://ganache:8545'
```
Great, our docker environment is now setup. We can finally deploy it by typing `docker-compose up` inside of `./docker/`.
### 2a. df-py - Configure to connect to Subgraph
Section 2 takes place inside `df-py` terminal window.
You should have this repository configured and working on your machine.
First, we make sure that we're inside our venv by typing `source venv/bin/activate/`. Again, we're assuming your requirements.txt, and other dependencies have been properly initialized.
We now `df-py` connect to Ganache via Brownie. To do this, we're going to add a network so Brownie can listen to our Ganache service.
```
brownie networks add Ethereum subgraph-ganache host=http://127.0.0.1:8545, chainid=8996
```
We then update our `brownie-config.yaml` so that it uses the network above by default.
```
networks:
default: subgraph-ganache
```
You should now be able to verify that the accounts from `subgraph-ganache` are working from inside `df-py` brownie.
```
brownie console --network subgraph-ganache
>>> accounts[0].balance()
100000000000000000000
```
### 2b. df-py - Configure dftools and deploy contracts
This section continues from Section 2.
We can now, also configure dftools to use accounts from Ganache, and deploy contracts into `ocean-subgraph`.
Look inside the `ocean-subgraph` terminal for the private accounts that were generated for you inside of Ganache. Copy one of their private keys, and do the following inside of `df-py/(venv)/`
```
export DFTOOL_KEY=0xYourUserPrivateKeyFromGanache
export WEB3_INFURA_PROJECT_ID=YourInfuraKey
```
You should now be able to deploy a newToken + veOCEAN + veAllocate contracts.
```
// deploy a new token
dftool newToken 8996
// use the token address from above to deploy veOcean
dftool newVeOcean 8996 token_address
// deploy veAllocate
dftool newVeAllocate 8996
```
You will need the address from the new `veAllocate` contract you just deployed for the next section. This contract will be used in the future so our subgraph can listen for events.
### 3a. ocean-subgraph - Initialize the project
Section 3 takes place inside `ocean-subgraph` terminal.
We're going to now generate `subgraph.yaml` so we can start connecting the veOCEAN contract into the logic of `ocean-subpgrah`.
We begin by running the following node script from the root folder.
```
node ./scripts/generatenetworkssubgraphs.js
```
Here, we're going to configure our local `subgraph.yaml` file so we can serve our local ganache, contracts, and everything that `df-py` depends on.
Use this file for all of your development until you have things sorted out. If you make any mistakes, you can just recreate the file. You should make your final changes inside of `subgraph.template.yaml` before submitting a PR.
### 3b. ocean-subgraph - Configure dataSources
We now configure our `subgraph.yaml` to talk to ganache and add our veAllocate Contract as a dataSource.
Our first step is to reset our `subgraph.yaml` so that it can consume all the events. Do a search for `startBlock` and make sure all params are initialized to 0.
```
- kind: ethereum/contract
source:
startBlock: 0
```
We then add our contract as a dataSource. We get our address from Section 2b `dftool newVeAllocate 8996` and enter it in the `dataSources` section of the `subgraph.yaml` file.
```
dataSources:
- kind: ethereum/contract
name: veAllocate
network: development
source:
address: 0x0000000000000000000000000000000
abi: veAllocate
startBlock: 0
mapping:
kind: ethereum/events
apiVersion: 0.0.6
language: wasm/assemblyscript
file: ./src/mappings/veAllocate.ts
entities:
- veAllocate
abis:
- name: veAllocate
file: ./abis/veAllocate.json
eventHandlers:
- event: AllocationSet(indexed address,indexed address,indexed uint256,uint256)
handler: handleAllocationSet
```
As you can see, we have also imported our `veAllocate.json ABI` file into the project, added the contract events we want to handle, and created a mapping script `./src/mappings/veAllocate.ts` so we can handle all the vents for the Subgraph.
Note: This tutorial will not go into details of how to do this work. Someone can create a separate guide on how to handle internal logic, define GraphQL entities, and save records into GraphQL.
_Please review the PR associated with this README for more intuition on this_
### 4a. ocean-subgraph - run: `npm run codegen`
From the root folder run this command.
You'll have to do this again every time you change `schema.graphql`
### 4b. ocean-subgraph - run: `npm run create:local`
From the root folder run this command.
You'll have to do this again every time you run step 5a.
### 4c. ocean-subgraph - run: `npm run deploy:local`
From the root folder run this command.
You'll have to do this again when you write any new subgraph code (mappings, utils, etc...).
### 5. ocean-subgraph - restart docker
Restart docker containers via `docker-compose up`
### 6. df-py - Execute onchain events + query subgraph
You can now start performing your onchain + contract tests and see records inside of your local subgraph.
As an example, you may use the following command inside `dftools` to generate many onchain events for Ganache.
```
dftool manyrandom 8996
```

14
package-lock.json generated

@ -5,9 +5,11 @@
"requires": true,
"packages": {
"": {
"name": "ocean-subgraph",
"version": "2.0.3",
"license": "Apache-2.0",
"dependencies": {
"@oceanprotocol/contracts": "^1.1.3",
"@oceanprotocol/lib": "^1.1.8",
"cross-fetch": "^3.1.4"
},
@ -858,9 +860,9 @@
}
},
"node_modules/@oceanprotocol/contracts": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/@oceanprotocol/contracts/-/contracts-1.0.0.tgz",
"integrity": "sha512-rDCIooe1WHipLejuGhx2Wv/88SB7bWrN3+XHCWxXyPKTmmSQsgxKZPPzbIVBQ0ESChQZqGSBBJyqErqwwW4eBw=="
"version": "1.1.3",
"resolved": "https://registry.npmjs.org/@oceanprotocol/contracts/-/contracts-1.1.3.tgz",
"integrity": "sha512-pn0rm4QKF8sVfDeJVlt18TV4Qj5oGgR/qQNO7O0GO2DQ3q8KHXRS15uRjmLTr5wW1kGcCHcTqEndXEEC7Elzkw=="
},
"node_modules/@oceanprotocol/lib": {
"version": "1.1.8",
@ -15275,9 +15277,9 @@
}
},
"@oceanprotocol/contracts": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/@oceanprotocol/contracts/-/contracts-1.0.0.tgz",
"integrity": "sha512-rDCIooe1WHipLejuGhx2Wv/88SB7bWrN3+XHCWxXyPKTmmSQsgxKZPPzbIVBQ0ESChQZqGSBBJyqErqwwW4eBw=="
"version": "1.1.3",
"resolved": "https://registry.npmjs.org/@oceanprotocol/contracts/-/contracts-1.1.3.tgz",
"integrity": "sha512-pn0rm4QKF8sVfDeJVlt18TV4Qj5oGgR/qQNO7O0GO2DQ3q8KHXRS15uRjmLTr5wW1kGcCHcTqEndXEEC7Elzkw=="
},
"@oceanprotocol/lib": {
"version": "1.1.8",

@ -64,6 +64,7 @@
"typescript": "^4.8.2"
},
"dependencies": {
"@oceanprotocol/contracts": "^1.1.3",
"@oceanprotocol/lib": "^1.1.8",
"cross-fetch": "^3.1.4"
},

@ -360,7 +360,6 @@ type NftUpdate @entity {
tx: String!
}
type Template @entity{
id: ID!
fixedRateTemplates: [String!]
@ -368,4 +367,98 @@ type Template @entity{
ssTemplates: [String!]
}
# Not tracking allocationToId or idToAllocation
type VeAllocateUser @entity{
"id = {user}"
id: ID!
veAllocation: [VeAllocation!] @derivedFrom(field: "allocationUser")
allocatedTotal: BigDecimal!
block: Int!
firstContact: Int!
lastContact: Int!
tx: String!
}
type VeAllocateId @entity{
"id = {DataNFT Address}-{chain id}"
id: ID!
veAllocation: [VeAllocation!] @derivedFrom(field: "allocationId")
allocatedTotal: BigDecimal!
block: Int!
firstContact: Int!
lastContact: Int!
tx: String!
}
# we need to track allocation of user to id
type VeAllocation @entity {
"id = {user}-{DataNFT Address}-{chain id}"
id: ID!
allocationUser: VeAllocateUser!
allocationId: VeAllocateId!
updates: [VeAllocationUpdate!] @derivedFrom(field: "veAllocation")
allocated: BigDecimal!
chainId: BigInt!
nftAddress: String!
block: Int!
firstContact: Int!
lastContact: Int!
tx: String!
}
enum veAllocationUpdateType {
SET,
REMOVED
}
type VeAllocationUpdate @entity {
"{tx}-{VeAllocation id}"
id: ID!
veAllocation: VeAllocation!
type: veAllocationUpdateType!
allocatedTotal: BigDecimal!
block: Int!
timestamp: Int!
tx: String!
}
type VeDelegation @entity {
"id = tokenId"
id: ID!
delegator: VeOCEAN!
receiver: VeOCEAN!
tokenId: BigInt!
amount: BigInt!
cancelTime: BigInt!
expireTime: BigInt!
block: Int!
}
type VeOCEAN @entity {
"id = {user address}"
id: ID!
lockedAmount: BigDecimal!
unlockTime: BigInt!
delegation: [VeDelegation!] @derivedFrom(field: "delegator")
delegates: [VeDelegation!] @derivedFrom(field: "receiver")
block: Int!
}
type VeDeposit @entity {
"id = {user address}-{timestamp}"
id: ID!
provider:String!
value: BigDecimal!
unlockTime: BigInt!
type:BigInt!
timestamp: BigInt!
}

@ -20,6 +20,14 @@ async function replaceContractAddresses() {
}
console.log('Creating subgraph.yaml for ' + network)
let subgraph = fs.readFileSync('./subgraph.template.yaml', 'utf8')
const subgraphVe = fs.readFileSync('./subgraph_ve.template.yaml', 'utf8')
if (addresses[network].veOCEAN) {
// fix identation , due to vs auto format (subgraph_ve.template is moved to left)
const lines = subgraphVe.split('\n')
for (let line = 0; line < lines.length; line++) {
subgraph += ' ' + lines[line] + '\n'
}
}
subgraph = subgraph.replace(/__NETWORK__/g, network)
subgraph = subgraph.replace(
@ -34,6 +42,26 @@ async function replaceContractAddresses() {
/__FACTORYROUTERADDRESS__/g,
"'" + addresses[network].Router + "'"
)
subgraph = subgraph.replace(
/__VEALLOCATEADDRESS__/g,
"'" + addresses[network].veAllocate + "'"
)
subgraph = subgraph.replace(
/__VEOCEANADDRESS__/g,
"'" + addresses[network].veOCEAN + "'"
)
subgraph = subgraph.replace(
/__VEDELEGATIONADDRESS__/g,
"'" + addresses[network].veDelegation + "'"
)
subgraph = subgraph.replace(
/__DFREWARDSADDRESS__/g,
"'" + addresses[network].DFRewards + "'"
)
fs.writeFileSync('subgraph.yaml', subgraph, 'utf8')
}
}

@ -28,3 +28,8 @@ export namespace NftUpdateType {
export const STATE_UPDATED = 'STATE_UPDATED'
export const TOKENURI_UPDATED = 'TOKENURI_UPDATED'
}
export namespace veAllocationUpdateType {
export const SET = 'SET'
export const REMOVED = 'REMOVED'
}

@ -0,0 +1,194 @@
import { BigDecimal, ethereum, BigInt } from '@graphprotocol/graph-ts'
import {
VeAllocateUser,
VeAllocateId,
VeAllocation,
VeAllocationUpdate,
VeDelegation,
VeOCEAN,
VeDeposit
} from '../../@types/schema'
import { veAllocationUpdateType } from './constants'
export function getveAllocateUser(
event: ethereum.Event,
sender: string
): VeAllocateUser {
let allocateUser = VeAllocateUser.load(sender)
if (allocateUser === null) {
allocateUser = new VeAllocateUser(sender)
allocateUser.allocatedTotal = BigDecimal.zero()
allocateUser.firstContact = event.block.timestamp.toI32()
allocateUser.tx = event.transaction.hash.toHex()
allocateUser.block = event.block.number.toI32()
allocateUser.lastContact = 0
allocateUser.save()
}
return allocateUser
}
export function getveAllocateId(
event: ethereum.Event,
id: string
): VeAllocateId {
let allocateId = VeAllocateId.load(id)
if (allocateId === null) {
allocateId = new VeAllocateId(id)
allocateId.allocatedTotal = BigDecimal.zero()
allocateId.firstContact = event.block.timestamp.toI32()
allocateId.tx = event.transaction.hash.toHex()
allocateId.block = event.block.number.toI32()
allocateId.lastContact = 0
allocateId.save()
}
return allocateId
}
export function getveAllocation(
event: ethereum.Event,
sender: string,
id: string
): VeAllocation {
let veAllocation = VeAllocation.load(sender + '-' + id)
if (veAllocation === null) {
veAllocation = new VeAllocation(sender + '-' + id)
veAllocation.allocationUser = getveAllocateUser(event, sender).id
veAllocation.allocationId = getveAllocateId(event, id).id
veAllocation.allocated = BigDecimal.zero()
veAllocation.chainId = BigInt.zero()
veAllocation.nftAddress = ''
veAllocation.firstContact = event.block.timestamp.toI32()
veAllocation.tx = event.transaction.hash.toHex()
veAllocation.block = event.block.number.toI32()
veAllocation.lastContact = 0
veAllocation.save()
}
return veAllocation
}
// Pass veAllocation being updated
export function writeveAllocationUpdate(
event: ethereum.Event,
veAllocationId: string,
allocationType: string,
amount: BigDecimal
): VeAllocationUpdate {
const tx = event.transaction.hash.toHex()
let allocationUpdate = VeAllocationUpdate.load(tx + '-' + veAllocationId)
if (allocationUpdate === null) {
allocationUpdate = new VeAllocationUpdate(tx + '-' + veAllocationId)
allocationUpdate.veAllocation = veAllocationId
allocationUpdate.type = allocationType
allocationUpdate.allocatedTotal = amount
allocationUpdate.timestamp = event.block.timestamp.toI32()
allocationUpdate.tx = event.transaction.hash.toHex()
allocationUpdate.block = event.block.number.toI32()
allocationUpdate.save()
}
return allocationUpdate
}
export function getveDelegation(id: string): VeDelegation {
let veDelegation = VeDelegation.load(id)
if (veDelegation === null) {
veDelegation = new VeDelegation(id)
veDelegation.cancelTime = BigInt.zero()
veDelegation.expireTime = BigInt.zero()
veDelegation.tokenId = BigInt.zero()
veDelegation.amount = BigInt.zero()
veDelegation.receiver = ''
veDelegation.delegator = ''
veDelegation.block = 0
veDelegation.save()
}
return veDelegation
}
export function getveOCEAN(id: string): VeOCEAN {
let ve = VeOCEAN.load(id)
if (ve === null) {
ve = new VeOCEAN(id)
ve.unlockTime = BigInt.zero()
ve.lockedAmount = BigDecimal.zero()
ve.block = 0
ve.save()
}
return ve
}
export function getDeposit(id: string): VeDeposit {
let deposit = VeDeposit.load(id)
if (deposit === null) {
deposit = new VeDeposit(id)
deposit.provider = ''
deposit.value = BigDecimal.zero()
deposit.unlockTime = BigInt.zero()
deposit.type = BigInt.zero()
deposit.timestamp = BigInt.zero()
deposit.save()
}
return deposit
}
export function handleOneAllocation(
eventSender: string,
nftAddress: string,
chainId: BigInt,
allocationAmount: BigDecimal,
event: ethereum.Event
): void {
const eventId = nftAddress + '-' + chainId.toString()
const allocateUser = getveAllocateUser(event, eventSender)
const allocateId = getveAllocateId(event, eventId)
const veAllocation = getveAllocation(event, eventSender, eventId)
// Update user allocation
const newUserAllocation = allocateUser.allocatedTotal.minus(
veAllocation.allocated
)
allocateUser.allocatedTotal = newUserAllocation.plus(allocationAmount)
// Update id allocation
const newIdAllocation = allocateId.allocatedTotal.minus(
veAllocation.allocated
)
allocateId.allocatedTotal = newIdAllocation.plus(allocationAmount)
veAllocation.allocated = allocationAmount
veAllocation.chainId = chainId
veAllocation.nftAddress = nftAddress
allocateUser.lastContact = event.block.timestamp.toI32()
allocateId.lastContact = event.block.timestamp.toI32()
veAllocation.lastContact = event.block.timestamp.toI32()
// register allocation update event
writeveAllocationUpdate(
event,
veAllocation.id,
veAllocationUpdateType.SET,
allocationAmount
)
// save entities
allocateUser.save()
allocateId.save()
veAllocation.save()
}

@ -0,0 +1,35 @@
import {
AllocationSet,
AllocationSetMultiple
} from '../@types/veAllocate/veAllocate'
import { handleOneAllocation } from './utils/veUtils'
export function handleAllocationSet(event: AllocationSet): void {
// get allocation entities
const eventSender = event.params.sender.toHexString()
const nftAddress = event.params.nft.toHexString()
const chainId = event.params.chainId
const allocationAmount = event.params.amount.toBigDecimal()
handleOneAllocation(eventSender, nftAddress, chainId, allocationAmount, event)
}
export function handleAllocationSetMultiple(
event: AllocationSetMultiple
): void {
// loop
for (let i = 0; i < event.params.nft.length; i++) {
const eventSender = event.params.sender.toHexString()
const nftAddress = event.params.nft[i].toHexString()
const chainId = event.params.chainId[i]
const allocationAmount = event.params.amount[i].toBigDecimal()
handleOneAllocation(
eventSender,
nftAddress,
chainId,
allocationAmount,
event
)
}
}

@ -0,0 +1,63 @@
import { BigInt } from '@graphprotocol/graph-ts'
import {
BurnBoost,
DelegateBoost,
ExtendBoost,
TransferBoost
} from '../@types/veDelegation/veDelegation'
import { getveDelegation, getveOCEAN } from './utils/veUtils'
export function handleDelegation(event: DelegateBoost): void {
const _delegator = event.params._delegator.toHex()
const _receiver = event.params._receiver.toHex()
const _tokenId = event.params._token_id
const _amount = event.params._amount
const _cancelTime = event.params._cancel_time
const _expireTime = event.params._expire_time
const veDelegation = getveDelegation(_tokenId.toHex())
veDelegation.delegator = _delegator
getveOCEAN(_receiver)
veDelegation.receiver = _receiver
veDelegation.tokenId = _tokenId
veDelegation.amount = _amount
veDelegation.cancelTime = _cancelTime
veDelegation.expireTime = _expireTime
veDelegation.block = event.block.number.toI32()
veDelegation.save()
}
export function handleExtendBoost(event: ExtendBoost): void {
const _delegator = event.params._delegator.toHex()
const _receiver = event.params._receiver.toHex()
const _tokenId = event.params._token_id
const _amount = event.params._amount
const _cancelTime = event.params._cancel_time
const _expireTime = event.params._expire_time
const veDelegation = getveDelegation(_tokenId.toHex())
veDelegation.delegator = _delegator
veDelegation.receiver = _receiver
veDelegation.tokenId = _tokenId
veDelegation.amount = _amount
veDelegation.cancelTime = _cancelTime
veDelegation.expireTime = _expireTime
veDelegation.save()
}
export function handleTransferBoost(event: TransferBoost): void {
// TODO not sure if we need this
// --------------------------------
// const _from = event.params._from
// const _to = event.params._to
// const _tokenId = event.params._token_id
// const _amount = event.params._amount
// const _expireTime = event.params._expire_time
}
export function handleBurnBoost(event: BurnBoost): void {
const _tokenId = event.params._token_id
// delete
const veDelegation = getveDelegation(_tokenId.toHex())
veDelegation.amount = BigInt.zero()
}

@ -0,0 +1,30 @@
import { Deposit, Supply, Withdraw } from '../@types/veOCEAN/veOCEAN'
import { weiToDecimal } from './utils/generic'
import { getDeposit, getveOCEAN } from './utils/veUtils'
export function handleDeposit(event: Deposit): void {
const provider = event.params.provider
const value = event.params.value
const locktime = event.params.locktime
const type = event.params.type
const ts = event.params.ts
// Create new Deposit entity
const deposit = getDeposit(provider.toHex() + '-' + locktime.toString())
deposit.provider = provider.toHex()
deposit.value = weiToDecimal(value.toBigDecimal(), 18)
deposit.unlockTime = locktime
deposit.type = type
deposit.timestamp = ts
deposit.save()
// --------------------------------------------
const veOCEAN = getveOCEAN(provider.toHex())
const lockedAmount = weiToDecimal(value.toBigDecimal(), 18)
veOCEAN.unlockTime = locktime
veOCEAN.lockedAmount = veOCEAN.lockedAmount.plus(lockedAmount)
veOCEAN.block = event.block.number.toI32()
veOCEAN.save()
}
export function handleSupply(event: Supply): void {}
export function handleWithdraw(event: Withdraw): void {}

@ -3,71 +3,6 @@ description: Ocean provides data sharing through IDOs
repository: https://github.com/oceanprotocol/ocean-subgraph
schema:
file: ./schema.graphql
dataSources:
- kind: ethereum/contract
name: ERC721Factory
network: __NETWORK__
source:
address: __ERC721FACTORYADDRESS__
abi: ERC721Factory
startBlock: __STARTBLOCK__
mapping:
kind: ethereum/events
apiVersion: 0.0.6
language: wasm/assemblyscript
file: ./src/mappings/erc721Factory.ts
entities:
- ERC721Factory
abis:
- name: ERC721Factory
file: ./node_modules/@oceanprotocol/contracts/artifacts/contracts/ERC721Factory.sol/ERC721Factory.json
- name: ERC20
file: ./abis/ERC20.json
eventHandlers:
- event: NFTCreated(address,indexed address,string,indexed address,string,string,bool,indexed address)
handler: handleNftCreated
- event: TokenCreated(indexed address,indexed address,string,string,uint256,address)
handler: handleNewToken
- kind: ethereum/contract
name: FactoryRouter
network: __NETWORK__
source:
address: __FACTORYROUTERADDRESS__
abi: FactoryRouter
startBlock: __STARTBLOCK__
mapping:
kind: ethereum/events
apiVersion: 0.0.6
language: wasm/assemblyscript
file: ./src/mappings/factoryRouter.ts
entities:
- FactoryRouter
abis:
- name: FactoryRouter
file: ./node_modules/@oceanprotocol/contracts/artifacts/contracts/pools/FactoryRouter.sol/FactoryRouter.json
- name: ERC20
file: ./abis/ERC20.json
eventHandlers:
- event: TokenAdded(indexed address,indexed address)
handler: handleTokenAdded
- event: TokenRemoved(indexed address,indexed address)
handler: handleTokenRemoved
- event: OPCFeeChanged(indexed address,uint256,uint256,uint256,uint256)
handler: handleOPCFeeChanged
- event: SSContractAdded(indexed address,indexed address)
handler: handleSSContractAdded
- event: SSContractRemoved(indexed address,indexed address)
handler: handleSSContractRemoved
- event: FixedRateContractAdded(indexed address,indexed address)
handler: handleFixedRateContractAdded
- event: FixedRateContractRemoved(indexed address,indexed address)
handler: handleFixedRateContractRemoved
- event: DispenserContractAdded(indexed address,indexed address)
handler: handleDispenserContractAdded
- event: DispenserContractRemoved(indexed address,indexed address)
handler: handleDispenserContractRemoved
templates:
- name: ERC20Template
kind: ethereum/contract
@ -230,3 +165,68 @@ templates:
handler: handlePublishMarketFeeChanged
- event: TokenCollected(indexed bytes32,indexed address,indexed address,uint256)
handler: handleTokenCollected
dataSources:
- kind: ethereum/contract
name: ERC721Factory
network: __NETWORK__
source:
address: __ERC721FACTORYADDRESS__
abi: ERC721Factory
startBlock: __STARTBLOCK__
mapping:
kind: ethereum/events
apiVersion: 0.0.6
language: wasm/assemblyscript
file: ./src/mappings/erc721Factory.ts
entities:
- ERC721Factory
abis:
- name: ERC721Factory
file: ./node_modules/@oceanprotocol/contracts/artifacts/contracts/ERC721Factory.sol/ERC721Factory.json
- name: ERC20
file: ./abis/ERC20.json
eventHandlers:
- event: NFTCreated(address,indexed address,string,indexed address,string,string,bool,indexed address)
handler: handleNftCreated
- event: TokenCreated(indexed address,indexed address,string,string,uint256,address)
handler: handleNewToken
- kind: ethereum/contract
name: FactoryRouter
network: __NETWORK__
source:
address: __FACTORYROUTERADDRESS__
abi: FactoryRouter
startBlock: __STARTBLOCK__
mapping:
kind: ethereum/events
apiVersion: 0.0.6
language: wasm/assemblyscript
file: ./src/mappings/factoryRouter.ts
entities:
- FactoryRouter
abis:
- name: FactoryRouter
file: ./node_modules/@oceanprotocol/contracts/artifacts/contracts/pools/FactoryRouter.sol/FactoryRouter.json
- name: ERC20
file: ./abis/ERC20.json
eventHandlers:
- event: TokenAdded(indexed address,indexed address)
handler: handleTokenAdded
- event: TokenRemoved(indexed address,indexed address)
handler: handleTokenRemoved
- event: OPCFeeChanged(indexed address,uint256,uint256,uint256,uint256)
handler: handleOPCFeeChanged
- event: SSContractAdded(indexed address,indexed address)
handler: handleSSContractAdded
- event: SSContractRemoved(indexed address,indexed address)
handler: handleSSContractRemoved
- event: FixedRateContractAdded(indexed address,indexed address)
handler: handleFixedRateContractAdded
- event: FixedRateContractRemoved(indexed address,indexed address)
handler: handleFixedRateContractRemoved
- event: DispenserContractAdded(indexed address,indexed address)
handler: handleDispenserContractAdded
- event: DispenserContractRemoved(indexed address,indexed address)
handler: handleDispenserContractRemoved

@ -0,0 +1,68 @@
- name: veAllocate
kind: ethereum/contract
network: __NETWORK__
source:
abi: veAllocate
address: __VEALLOCATEADDRESS__
startBlock: __STARTBLOCK__
mapping:
kind: ethereum/events
apiVersion: 0.0.6
language: wasm/assemblyscript
file: ./src/mappings/veAllocate.ts
entities:
- veAllocate
abis:
- name: veAllocate
file: ./node_modules/@oceanprotocol/contracts/artifacts/contracts/ve/veAllocate.sol/veAllocate.json
eventHandlers:
- event: AllocationSet(indexed address,indexed address,indexed uint256,uint256)
handler: handleAllocationSet
- event: AllocationSetMultiple(indexed address,address[],uint256[],uint256[])
handler: handleAllocationSetMultiple
- name: veOCEAN
kind: ethereum/contract
network: __NETWORK__
source:
abi: veOCEAN
address: __VEOCEANADDRESS__
startBlock: __STARTBLOCK__
mapping:
kind: ethereum/events
apiVersion: 0.0.6
language: wasm/assemblyscript
file: ./src/mappings/veOCEAN.ts
entities:
- veOCEAN
abis:
- name: veOCEAN
file: ./node_modules/@oceanprotocol/contracts/artifacts/contracts/ve/veOCEAN.vy/veOCEAN.json
eventHandlers:
- event: Deposit(indexed address,uint256,indexed uint256,int128,uint256)
handler: handleDeposit
- event: Withdraw(indexed address,uint256,uint256)
handler: handleSupply
- event: Supply(uint256,uint256)
handler: handleWithdraw
- name: veDelegation
kind: ethereum/contract
network: __NETWORK__
source:
abi: veDelegation
address: __VEDELEGATIONADDRESS__
startBlock: __STARTBLOCK__
mapping:
kind: ethereum/events
apiVersion: 0.0.6
language: wasm/assemblyscript
file: ./src/mappings/veDelegation.ts
entities:
- veDelegation
abis:
- name: veDelegation
file: ./node_modules/@oceanprotocol/contracts/artifacts/contracts/ve/veDelegation.vy/veDelegation.json
eventHandlers:
- event: DelegateBoost(indexed address,indexed address,indexed uint256,uint256,uint256,uint256)
handler: handleDelegation

@ -0,0 +1,124 @@
import {
Erc20CreateParams,
Nft,
NftFactory,
NftCreateData,
sleep
} from '@oceanprotocol/lib'
import { assert } from 'chai'
import Web3 from 'web3'
import { homedir } from 'os'
import fs from 'fs'
import { fetch } from 'cross-fetch'
const data = JSON.parse(
fs.readFileSync(
process.env.ADDRESS_FILE ||
`${homedir}/.ocean/ocean-contracts/artifacts/address.json`,
'utf8'
)
)
const addresses = data.development
const web3 = new Web3('http://127.0.0.1:8545')
const subgraphUrl =
'http://127.0.0.1:9000/subgraphs/name/oceanprotocol/ocean-subgraph'
describe('Tests coverage without provider/aquarius', async () => {
let nft: Nft
let Factory: NftFactory
let accounts: string[]
let publisherAccount: string
let newOwnerAccount: string
before(async () => {
nft = new Nft(web3)
Factory = new NftFactory(addresses.ERC721Factory, web3)
accounts = await web3.eth.getAccounts()
publisherAccount = accounts[0]
newOwnerAccount = accounts[1].toLowerCase()
})
it('should publish a dataset (create NFT + ERC20)', async () => {
const nftParams: NftCreateData = {
name: 'testNFT',
symbol: 'TST',
templateIndex: 1,
tokenURI: '',
transferable: true,
owner: publisherAccount
}
const erc20Params: Erc20CreateParams = {
templateIndex: 1,
cap: '100000',
feeAmount: '0',
paymentCollector: '0x0000000000000000000000000000000000000000',
feeToken: '0x0000000000000000000000000000000000000000',
minter: publisherAccount,
mpFeeAddress: '0x0000000000000000000000000000000000000000'
}
const result = await Factory.createNftWithErc20(
publisherAccount,
nftParams,
erc20Params
)
const erc721Address = result.events.NFTCreated.returnValues[0]
// graph tests here
await sleep(2000)
const graphNftToken = erc721Address.toLowerCase()
const query = {
query: `query {
nft(id:"${graphNftToken}"){symbol,id}}`
}
const response = await fetch(subgraphUrl, {
method: 'POST',
body: JSON.stringify(query)
})
const queryResult = await response.json()
assert(queryResult.data.nft.id === graphNftToken)
})
it('should publish and transfer an NFT', async () => {
const nftParams: NftCreateData = {
name: 'testNFT',
symbol: 'TST',
templateIndex: 1,
tokenURI: '',
transferable: true,
owner: publisherAccount
}
const erc20Params: Erc20CreateParams = {
templateIndex: 1,
cap: '100000',
feeAmount: '0',
paymentCollector: '0x0000000000000000000000000000000000000000',
feeToken: '0x0000000000000000000000000000000000000000',
minter: publisherAccount,
mpFeeAddress: '0x0000000000000000000000000000000000000000'
}
const result = await Factory.createNftWithErc20(
publisherAccount,
nftParams,
erc20Params
)
await sleep(2000)
const erc721Address = result.events.NFTCreated.returnValues[0]
const graphNftToken = erc721Address.toLowerCase()
// Transfer the NFT
await nft.transferNft(graphNftToken, publisherAccount, newOwnerAccount)
await sleep(2000)
const query2 = {
query: `query {
nft(id:"${graphNftToken}"){symbol,id,owner, transferable}}`
}
const response = await fetch(subgraphUrl, {
method: 'POST',
body: JSON.stringify(query2)
})
const queryResult = await response.json()
assert(queryResult.data.nft.owner === newOwnerAccount)
})
})
Loading…
Cancel
Save