AirSafe

AirSafe is a decentralized multi-signature wallet solution specifically designed to operate within the AirDAO ecosystem. The project represents the integration of the widely-used Gnosis Safe wallet architecture, adapted for AirDAO’s community-centric and governance-focused Layer 1 blockchain. AirSafe is built with a vision to enable organizations, decentralized autonomous organizations (DAOs), and multi-participant entities to securely manage their digital assets and decision-making processes in a decentralized environment.

The project is focused on creating a seamless, trusted, and familiar user experience by leveraging the already established interface and features of Gnosis Safe while tailoring it for the unique infrastructure of AirDAO. By doing so, it ensures the adoption of a decentralized, multi-signature wallet without the need for users to learn a new system.

The project is composed of multiple repositories, each serving a critical function within the overall infrastructure. The five repositories that form the backbone of AirSafe are:

1. safe-eth-py

   • A Python library to work with Ethereum and related blockchain projects. It’s used to interface with the Ethereum network, manage assets, and handle smart contract interactions.

2. safe-smart-account

   • These are the main suite of contracts that allows secure management of blockchain assets via the Gnosis Safe multisig system.

3. safe-singleton-factory

   • A contract deployed on-chain that ensures only one instance of the singleton is deployed, saving gas and avoiding redundant contract deployments.

4. safe-wallet-web

   • This is the core web-based multisig wallet UI interface built using NextJS. It’s responsible for the front-end interactions of users with the wallet.

5. safe-transaction-service

   • A Django-based service that keeps track of all transactions executed via Safe contracts, including tracking Ether and ERC-20 token transfers.

Building AirSafe: The Process

1. Deploying Singleton Factory Contract

   • The singleton factory is the starting point of the project. It’s a contract that act as a factory of the singleton contract - a single instance of the Safe account, making deployment efficient and gas-saving.
   • By deploying this factory on the AirDAO network, it lays the groundwork for all safe smart account contracts deployment.

2. Deploying Safe Smart Account Contracts

   • After setting up the singleton factory, the next step is to deploy the Safe smart account contracts on AirDAO. These contracts are responsible for managing the actual multisig functionality, allowing multiple participants to approve transactions before they’re executed.
   • Upon deployment, these contracts generate important addresses (e.g., safe singleton, safe factory, etc), which I then structure into a chainInfo object. This is a crucial step, as the chainInfo object ensures that the front-end and back-end services know which contracts to interact with.

3. Web UI Modifications for AirDAO Integration

   • Integrating AirDAO into the safe-wallet-web (the front-end) was both a necessary and complex step. Since the Gnosis Safe UI is designed for Security, I had to modify the UI components to support the new AirDAO network

4. Updating the Transaction Service API for AirDAO

   • One of the more complex and “hacky” parts of the project involved modifying the safe-transaction-service to support AirDAO. This service tracks the transactions executed on Safe accounts and confirms them once the required number of approvals has been met.
   • The existing service was tightly coupled with another python dependencies, so I had to make significant changes to the service’s dependencies, configuring them to work with AirDAO’s transaction system.

5. Dockerization and Deployment

   • After making all these changes, the final step was to containerize the entire project. I had to build new Docker image for the transaction service API, ensuring all the modifications were captured in the build.
   • Using Docker Compose, I spun up the entire infrastructure locally to test that everything worked in harmony. This included verifying that the wallet UI, transaction service, and smart contract deployments interacted as expected on the AirDAO test network.

Challenges and Hacky Solutions

• Hacky Deployment Flow:
  • One of the most notable challenges in building AirSafe was that the deployment process isn’t straightforward. Given that the Gnosis Safe infrastructure was designed for Ethereum, I had to make several adjustments to the core components to ensure compatibility with AirDAO. This was particularly evident in the transaction service API, which required modification of not only API but also the dependencies.
• Complexity of Cloud Deployment:
  • Due to the complexity of running both the web UI and transaction service API, I initially deployed AirSafe locally. Cloud deployment requires further work, particularly in building a scalable and fault-tolerant architecture for the transaction service infrastructure. However, once the integration is fully tested and optimized, cloud deployment will allow for broader adoption and accessibility.

Why These Technologies?

The decision to use the Gnosis Safe framework (and its relevant technologies) was intentional due to its trusted reputation and robust security model. By using these existing, well-established libraries and services, I ensured that AirSafe inherits the same security guarantees and friendly user interface of Gnosis Safe.

The Conclusion

Building AirSafe involved integrating several existing technologies from the Gnosis Safe framework and modifying them to support the unique infrastructure of AirDAO. From deploying key contracts to updating the web UI and transaction service, every component was customized to ensure compatibility with the AirDAO ecosystem.

While the current version is running locally, I plan to fully deploy AirSafe in the cloud, making it available for DAOs and organizations worldwide. The result is a highly secure, multi-signature wallet tailored for the decentralized governance structures of AirDAO.