Vaulidity (former Solide: Solidity Database)

TRON Hackathon Hackathon Season 6
41

Oh wow :astonished:
Using bytecode available on any EVM-based chain to give smart contract information appears interesting.
So, given the vast range of blockchain ecosystems available, how does the Solide Project prioritize which chains to integrate and support within the Solide IDE?

3 Likes
42

Sure, Iā€™ve updated the post to provide more information on how the Database works. Essentially, we store the contract metadata on BTFS and then utilize that data to store it in a smart contract on TRON. This approach effectively reduces the amount stored on-chain, saving gas and contract space, as we only store the CID from BTFS. Hence the primary information about the smart contract will be stored with BTFS, including the source code, compiler, etc., while the output is stored as a lookup in a smart contract on the TRON network.

This makes it very effective for nearly all smart contracts, whether verified or unverified. For verified smart contracts, the Solidity Database is not necessary. However, since most smart contracts are unverified, this Database provides a transparent feature that allows developers or users to access information about unverified smart contracts that they otherwise would not have access to. As for accessibility, you can read Solide - Solidity Database - #41 by manfred_jr,

2 Likes
43

Thank you! Glad I can participate in the hackathon. :heart:

3 Likes
44

We try to cover a wide range of chains, from the most established (Ethereum, TRON, etc) to the emerging ones. You can find the full list in the docs, we continuously add new ones to ensure coverage. As for prioritization, we believe in community-driven decision making. Therefore, we encourage our users to contribute by either creating an issue to request a chain or submitting a PR.

3 Likes
45

Hi, welcome to s6 and want to know that is this project is ready ? as all details are up to date.

3 Likes
46

Hi, Thanks for the welcome. The project is nearing completion. We have deployed everything and the information is a draft of whatā€™s to be complete for the hackathon submission. Iā€™ll be slower adding many missing features, and UI changes to make the explorer more simple and also add a bit more explanation to the explorer in to the post.

3 Likes
47

Welcome to hackaTRONs6 ! What I understand from your submission is with Solide developer can find understand and work with smart contract. I am looking forward to see a demo video for this project to understand how it works better. Good luck to you !

4 Likes
48

Hi, Thanks for the welcome. Iā€™m nearly completion of the project and if you like, Iā€™ve uploaded a short demo video, showing the capabilities of the Solidity Database and its general use case for developers.

6 Likes
49

Welcome to hackaTron S6.
I will like to know if there is a way your project will be interoperable with other blockchain platforms or systems.

2 Likes
50

Hey there! Iā€™m curious about how the Solide IDE connects with the Solidity Database. Could you walk me through how developers, like myself, can access smart contract sources, even those that arenā€™t verified? Iā€™m really interested in understanding how this integration makes it easier for developers to explore and work with smart contracts directly within the IDE environment. :nerd_face: :man_student:

2 Likes
51

Sure, so most EVM chains generate bytecode and metadata when compiling smart contracts, which is then deployed and stored on-chain. By using Solidity DB as a universal database for source code, one can easily query this database to check if there is matching contract metadata for a given contract on any EVM chain. This means that any platform utilizing an EVM blockchain can access information about a smart contract if itā€™s available.

The scalability of this database will improve with more integrations. Currently, we have implemented this as a use case within the Solidity IDE so there might not be much source code stored on the registry. We use the compiled and deployed contract information from the Solidity IDE and store it in the database. However, this can be easily integrated into more known system say Remix or Foundry. In those frameworks or platforms, users can also upload similar information when a contract is deployed on their platform.

2 Likes
52

Hello friend good day. We are too participating this season with our QuestArcade project in the Artistry category.

Solide is such a clean and good quality work that we were amazed and are now following it closely. What kind of milestones do you plan to determine after the voting? What are your future plans?

2 Likes
53

I hope that my video gave you a practical understanding of how Solidity DB works within the Solide IDE. But technically, the flow involves several steps: when a user clicks ā€œdeployā€ and successfully creates a contract, the IDE sends information including the source code, ABI (Application Binary Interface), and compiler settings to the backend. The backend then uploads this metadata to BTFS (BitTorrent File System) and stores the resulting content identifier (CID) in the smart contract registry on TRON.

Subsequently, anyone can utilize the registry to query this information. In the case of the Solide IDE, it first queries the on-chain for the verified source code. If this doesnā€™t exist, it falls back to the Solidity Database, where the bytecode might contain the contract metadata. Itā€™s important to note that this metadata might not be present if the contract hasnā€™t been deployed via the Solide IDE or another platform that integrates with Solidity DB. However, even if the contract is not verified, we can still ā€œfallbackā€ to Solidity DB to retrieve the information, provided it has been registered to the smart contract. There should be enough information to allow for loading, compilation, interaction, and deployment of the contract within an application.

2 Likes
54

Hi, I appreciate your kind comment!

Regarding future milestones and plans, we aim to further involve ourselves in integration with other protocols or projects (if possible) that could benefit from a decentralized smart contract solution. Additionally, for the project itself, we are considering implementing a sharing feature that would enable users or developers to share smart contract implementations or code snippets using Solidity Database as an open-source and interactive platform for web3 development.

3 Likes
55

Thank you for this insightful explanation on the possibilities of Integrating this project with other networks. This now leads me to another question on how you planned to address potential scalability challenges as more integrations are added into the system

3 Likes
56

No problems. However, if we are questioning the scalability of the Solidity database, we are essentially questioning the scalability and design of TRON and BTFS, which are decentralized technologies integrated for storing and retrieving information. For more information on how this integration aligns with scalability, you can refer to a similar discussion here.

3 Likes
57

Hello @SovaSniper , SimbadMarino from Trondao here :slight_smile: by checking your github repos I could not find a Readme on how to build your project locally to test it out. Would you please help to update it?
I have some questions:

  • I tried to create a new project /smart contract but could not find a way to do it for testing purposes in you website. Iā€™d like to test the whole life cycle of your solution which I assume is as follows (please correct me if Iā€™m wrong). Would you please help on how to achieve this?:
  1. ā€œBobā€ creates a new project in your IDE (Solide)
  2. Bob compiles and deploys the contract to the chain
  3. Solide automatically uploads the SC to BTFS and store the CID and abi into the explorer database for users to use later.

  • I assume you have to run a local BTFS node to upload the .sol files? Please elaborate more on how you are managing the BTFS side of it. :slight_smile:

  • Have you considered trying to integrate your idea with tronide (similar IDE as Remix) and/or tronbox (similar to foundry)?

Kudos for opensourcing your project !
Looking forward to test it myself locally or being able to create a new project myself so I can provide further feedback.

Keep building ! :raised_hands:

6 Likes
58

Hi, this is a long reply so I hope Iā€™ve covered everything you need. Setting up the IDE will require some API Key setup and request for the service to be fully functional, but I hope the process is simple enough for you. The flow is correct, if youā€™re using the the deployed Solide IDE. Itā€™ll also work locally, except youā€™ll need to whitelist a TRON wallet so that it can add smart contracts to the Solidity DB smart contract.

I tried to create a new project /smart contract but could not find a way to do it for testing purposes in you website. Iā€™d like to test the whole life cycle of your solution which I assume is as follows (please correct me if Iā€™m wrong). Would you please help on how to achieve this?:

Iā€™ve updated the README.md and hopefully clarifies the setup process for the IDE. You can find it here: Solide README. Please note that youā€™ll need to checkout the solidity-db branch, as itā€™s intended for the TRON hackathon.

Additionally, feel free to shoot me an email to request that your TRON wallet be whitelisted to contribute to the Solidity DB. We restrict access to ensure only trusted services can use the registry, thus preventing bad actors. Youā€™ll need to provide the private key as an environment variable for the IDE, as itā€™s used to interact with and store contract information.

Lastly, I want to clarify that the Solide IDE isnā€™t part of this hackathon submission. We need a use case for the Solidity DB, and the integration of Solide IDE was just an idea we had while conceptualizing the Solidity project for the TRON Hackathon.

For a summarized overview of the lifecycle (Read Project Test Instructions), the Solide IDE currently only supports loading smart contracts on-chain or from open-source repositories on GitHub. For example, you can load a smart contract by referencing a contract on GitHub and appending the Solide IDE URL (https://solide0x.tech/?url=) before it. Here are some examples of smart contracts:

To load on Solide:

https://solide0x.tech/?url= + [GitHub Link Solidity ile]

If you encounter difficulties, you can refer to the Solide Smart Contract Hub, where weā€™ve provided a library of smart contracts specifically tailored for use with the Solide IDE.

Similar to an IDE, you can modify compiler versions, settings, compile, and deploy onto a network using tools like Metamask or TronLink. Once the contract is deployed, its metadata information should be stored on-chain to assist with the deployment of new, unverified contracts.

You can load that contract into Solide by providing its address via:

https://solide0x.tech/address/{chainID}/{contractAddress}
  • For TRON, the ChainID is tron
    • TRON Nile: tron_nile
    • TRON Shasta: tron_shasta
  • Contract addresses are in Ethereum (0x...) or Tron (t...) format.

This should allow you to load the contracts, even though they are unverified.

I assume you have to run a local BTFS node to upload the .sol files? Please elaborate more on how you are managing the BTFS side of it.

Currently, our approach involves utilizing a public BTFS (BitTorrent File System) node and leveraging a public BTFS gateway to upload files. We specifically store a JSON file containing the contractā€™s content, rather than the raw .sol files themselves. This JSON file serves as a reference to the contractā€™s details.

When retrieving the contractā€™s content, we utilize a BTFS gateway provided by BTFS, specifically the https://gateway.btfs.io/ endpoint. This gateway allows us to access and fetch the stored content efficiently.

However, our future plan involves establishing and running our own local BTFS node as we further develop and solidify the project. This strategy will enable greater control and autonomy over the storage and retrieval process, ensuring enhanced reliability and scalability as our project evolves.

Have you considered trying to integrate your idea with tronide (similar IDE as Remix) and/or tronbox (similar to foundry)?

Yes, thatā€™s sort of a future goal ā€” to plan to integrate with Tronide to Remix, if its acceptable and that Solidity DB get far. I havenā€™t looked a Tronbox, but thatā€™s a possibility as well. Itā€™ll similar a similar method, where these services call the rpc for the contract bytecode and call the Solidity Registry smart contract to get the cid and if the cid exist, then call BTFS gateway to get the content of the cid which should be the metadata of the requested contract. As so long as the service can connect to a chain and an API request to a BTFS gateway.

5 Likes
59

Thank you for the detailed answer! And also for updating the README :slight_smile: This will help me and others willing to test or collaborate on Solide.

Letā€™s keep building!

2 Likes
60

This is another amazing project! Iā€™m definitely going follow this :smile:

2 Likes