onlydustxyz / marketplace-frontend Goto Github PK

when fetching PR from github repository we should filter on PR that have actually changed since last time the repository was indexed

Description

The service requires some external components such as a database. We need to setup the Infra As Code resources and scripts.

Something is broken !

Desc

Description

Once we have completed a check and successfully invoked the smart contract, we need to update the database so that the next analysis starts from the correct checkpoint.

The nonce is not stored inside the starknet library nor inside the BE.
So, when sending 2 transactions at the same time (before the first one is accepted), they are noth sent with the same nonce.
The second transaction is always rejected.

3 options:

1. cache the nonce before the first call and increase it for each transaction
2. wait for each transaction to be accepted on L2 before sending the next one.

With option 1, if a transaction ever fails, it will make all subsequent transactions fail as well.

Option 2 will be implemented.
For performance reasins we will have to bulk the transactions.

Today, when dealing with multiple items to log, the logger will fail as soon as 1 item fails.
This is not convenient as we might want to upload a batch of PR and some will revert, some will succeed.
We should consolidate the errors instead of stopping at first failure.

The API route tests rely on dummy implementations of their dependencies, we should move them to mocks.
An example of such a test can be found here: https://github.com/onlydustxyz/marketplace-backend/blob/main/marketplace-core/src/routes/applications/list/tests.rs#L15

desc

when github returns 404/500/403/... ignore the error and enter best effort mode with not all of the data returned

desc

New daemon to:

• watch repositories and fetch PR since last exec
• log PR in DB
• log PR in smart contracts

Description

We need to identify new pull requests that have been merged since the last time we performed the check.

To improve error management, we should parse errors received from starknet client

In order to interact easily with multiple results from Fetcher API, we should use the Iterator trait.
This would allow to fetch data from github as the iterator moves instead of all at once.

Running:

curl --request GET \
  --url 'https://api.github.com/search/issues?q=repo%3Aod-mocks%2Fcool-repo-A%20is%3Apr%20is%3Amerged'

returns 1 issue instead of 2, as shown in https://github.com/od-mocks/cool-repo-A/pulls?q=is:pr+is:closed

Once the API is somehow fixed by Github, we should update our end to end test accordingly.

Test a full end-to-end flow:

1. The user registers its github handle
2. We add a repository to be watched in feeder DB
3. The PR are pushed to DB and smart contract
4. The data is available on chain

The API should expose a new route PATCH /contributions/{id} which only accepts a body with the gate property.

This route should be protected by the API key.

This route should call an UpdateContributionGate usecase in the application layer, which will call the ContributionService to update the contribution gate. There should thus be a new method in this service.

This method, when implemented by the starknet client, should call the smart contract method, then update the database using the ContributionRepository.

Prerequisite: onlydustxyz/marketplace-starknet#68

dfdf

contributor = author of a github PR
contribution = pull request
project = github repository
project_repository = github (offchain) / smart contract (on chain)
contribution_repository = github (offchain) / smart contract (on chain)
state = database

Great doc

Desc

For testing purposes

Description

Once we detected new contribution from a contributor, we need to invoke Death Note contribution contract to store the new contribution.

Acceptance Criteria

• Death Note contribution contract is invoked
• Error handling of smart contract errors is correctly done

test-swagger

Statuses should be:

• Open
• Assigned
• Completed
• Abandoned

in order to improve performances and avoid cloning String everywhere, we should use references whenever possible.

When called on a business method, the aggregate returns some events, but nothing ensures the events are applied.
This is a problem since we don't want the user of an aggregate to be responsible for keeping the current aggregate state up to date with the called methods.

When a new PR is merged for a registered user, we should be able to push the data on-chain.

Great doc

Small refactoring to use upsert feature (insert or update) when storing PR in database

test

test

asas

To increase availability, it would be nice to have our own JSON RPC node running on goerli so that we can target it for contract calls

desc

beware of github rate limiting
v0 alternative for #65