Created
March 7, 2023 14:28
-
-
Save muttoni/ab174fb7c17c6675ebf646abd9d08d9f to your computer and use it in GitHub Desktop.
flow-hack-project-challenges
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| So that first challenging part was to figure out the generating the dynamic certificates as per the collectors data and then issuer should be able to customize the certificates. Then the second challenge was to figure out the claiming part like when someone is opening the claim url so that particular collector should have only that claim url in which there will be certificates with his or her name. So the last challenge we faced is I had to link the token with the unique claim tokens so that claimer can claim the particular token so we were not able to get tokenIds which we were just minting. So after so many try we figured out and added the code for that and then we were able to get the tokenIds but again we were not able to get the latest one means when we are getting the tokenIds at that time transaction was not completed. Then we found the one way to call particular block of code once transaction is completed by adding one FCL function call. | |
| Our only challenge was selecting the most important product requirements that fit into the hackathon timelines! | |
| "While developing the SBT contract, one of the challenges we ran into involved minting on demand. SBTs can’t be pre-minted and transferred, so we needed a way to actually send SBTs to users directly without storing them as inventory. | |
| Another challenge we ran into involved installing collections for users. On Flow, users typically need to run a transaction to configure their account to hold NFTs from a particular collection. This extra step is oftentimes tedious for the end user and causes a handful of usability issues. To resolve this, we’ve designed our Cadence transactions to automatically install an SBT collection in the user’s account before they interact with our smart contracts. In this way, the process of onboarding a user becomes relatively seamless. | |
| One final challenge we ran into falls under the concept of multisig. We didn’t want to make the minting function on our SBT contract public for everyone to call, otherwise this could lead to spam and abuse. Instead we wanted to regulate minting such that the contract admin and the user both need to approve the transaction. To this end, we implemented a backend to facilitate the process of providing the admin signature on specific transactions. The backend will only provide the admin signature to the frontend application if the transaction of interest is whitelisted. This system allows us to ensure the privacy of the adm | |
| " | |
| "- Using the existing Crypto library in Cadence to implement verification of Ethereum signature standards. | |
| - Designed and integrated wallet tools for Flow and Ethereum wallet interactions. | |
| - Implemented domain name queries using limited open graph features and customized rendering based on domain name metadata. | |
| - Optimized caching of IPFS image resources. | |
| " | |
| "1.Since the Flow Native SDK is outdated and cannot run, we used a plug-in instead. | |
| 2.We were not familiar with writing Flow NFT contracts and encountered problems when distributing NFTs to users, but we were able to solve the problem. | |
| 3.We have achieved the display of NFTs on the Flow chain, but we have not yet realized the details of NFTs, transaction flows, and assets. However, we are currently writing server programs to collect the on-chain data." | |
| The biggest challenge was really around trying to get the TimelineJS running in React. It was built about 5 years ago and is no longer maintained, so I needed to try a few different approaches to get it running. I also needed to do some workarounds to enable an AutoPlay feature so users could just watch the Moment as soon as the page loaded, rather than needing to click on the moment to play it. | |
| "# Challenges that we faced | |
| ### Integration problem with wallet👜 | |
| Integration of wallet with application on mobile was challenging, we found out that flow wallets did not have flutter sdk , but our project was using flutter as the frontend frame work. | |
| - we solved this problem by using webview in the application itself which opens blocto and magic links for walletless authentication . and extracted the authenticated wallet into the app | |
| ### Interoperability Issues 😵 | |
| Transaction across different chains and currencies was challenge so we solved it by making use of the liquidity pool. Due to the frequent changes in prices of each token relatively there were conflicts from the sent amount , and the processed amount that recepient gets. | |
| - to remove this read write problem , we have kept a threshold of percentage change . and capped the volatility. | |
| ### User Experience📱 | |
| When the application was shown to shopkeepers and other customers they faced troubloe in accessing all the features it took time for them to get aquainted with the UI, | |
| - taking this as a motivation we reorganized the userinterface to make it accessible and understandable to common public " | |
| Writing the smart contract in the most clear and generic way, trying to make it as easy as possible for game/art creators to deploy their own versions by only modifying a few initialization parameters. | |
| "I had to learn cadence from the start, so that was a little challenging. But Flow makes it very easy and also there is great content online to learn. We also had to learn a great way to onboard users that have no idea about the blockchain. So we implemented a system that uploads their wallet to our database and thanks to Flow's Blockchain, we can simply fetch their NFTs running different scripts. It was a very fun week of learning this new language and thinking of new ways to make the experience better. | |
| Overall, I am beyond happy I found the Flow Blockchain. It will allow us to make DEBOOK a very accessible and scalable platform! " | |
| Cadence is new for me so learning quickly and building got some difficulties there and also for the integration of smart contract with the frontend. | |
| "1. The Public Key and signature format are different between Flow account and StrongBox Keymaster. I needed to dive into the encode style on the device and convert it to the format which Flow can understand. | |
| 2. StrongBox Keymaster relies on Biometrics authentication which is executed asynchronously. On the contrary, Flow JVM SDK assumes the sign function runs synchronously. Therefore, I needed to implement complicated co-routine handling | |
| 3. QR code cannot contain whole TX information because it's too big. TX needs to be shared by devices when multi-sig is used (imagine that you create a TX in 1st devce, then send it to 2nd device and sign it). Therefore, I decided to share minimum information like address, amount and referenced block ID and display them as a QR code. | |
| " | |
| We ran into challenges with minting NFTs from the admin side of things. The Flow documentation doesn't have strong support for server-side JavaScript usage. We decided to just use a server that executes shell scripts using the Flow CLI to get around this quickly. | |
| "During the development of my on-chain order book for Flow, I faced several challenges. | |
| Firstly, the project was built in Cadence, a resource-oriented programming language that is relatively new and complex. It took some time for me to become familiar with the language and its nuances. | |
| Secondly, due to the strict type system of Cadence, I encountered several bugs related to variable types. This issue required me to carefully review the code and perform rigorous testing to ensure that everything was functioning as intended. | |
| Finally, I faced time constraints that prevented me from implementing all of the features I wanted to include in the order book, such as multiple users putting in the same limit price and a transaction history. While these features are important, I decided to prioritize the core functionality of the order book in the limited time available. | |
| To overcome these challenges, I sought help from the Flow community and consulted various resources to improve my understanding of Cadence. I also conducted extensive testing to identify and fix any issues related to variable types. And for the features that I couldn't implement right away, I plan to work on them in the future and improve the order book's functionality over time." | |
| "The FLOW peer-to-peer mechanisms make things more difficult when you need to know the collection names you want to query. | |
| I struggled to load a user's public data generically, but eventually, I found the dapper maintained flow catalog list. By using this list, I could loop over known collections to load NFTs from a user's wallet. | |
| Additionally, large wallets were too much for the Cadence collection script I was using. It would hit resource limits for the query and timeout or return no results. | |
| I had to modify the cadence code to page through collections 15 at a time. This fixed the issue for the majority of wallets. | |
| I still think improvements can be made to more accurately target the collections a user has and I hope to add those in a future version." | |
| "- This was our first Flow blockchain project, so learning Cadence and FCL library | |
| - Understanding the login, config and other details regarding flow blockchain to integrate with frontend. | |
| - Understanding the NFT standard and Metadataviews for our NFT collection | |
| - We had just few hours to complete this hack | |
| - Ensuring that the platform was user-friendly and intuitive, so that anyone could easily create and mint their own NFTs without technical expertise." | |
| "Some challenges included: | |
| - Learning how to use the fcl-swift library to integrate with the Blocto wallet | |
| - Building the entire backend/data storage on-chain was tough and I would move some of this off-chain with more time, but it was fun writing more Cadence code | |
| - The fc-swift library was missing some functionality I needed, so I opened a PR and got it merged and released - https://github.com/portto/fcl-swift/pull/35 | |
| - Building a functional mobile app in a short period of time is hard :) it was fun learning more about mobile development and building a fuly functional mvp/demo from scratch " | |
| I'm currently experiencing difficulties querying the historical transactions and prices of NFTs on the Marketplace. To work around this, I'm currently crawling data from LaLiga Golazos Marketplace. However, in the future, I plan to build a backend system that listens to events and captures the price and historical transaction data more efficiently. | |
| Learn Cadence. New paradigm from objects to resources. Set up things to send txs in Flow. Use public NFT Flow projects API | |
| "It was my first time to create a Prettier Plugin and VSCode Extension, and I had never worked with abstract syntax trees before, so that was a challenge for me. | |
| Since there were no comprehensive articles on the subject, I looked for solutions one by one. | |
| Also, when I actually started development, I could not easily get the latest version of Prettier's library to run because it was still provided in CommonJS, while the Parser automatically generated by ANTLR was in ES Module. Eventually I decided to drop one middle version of ANTLR and adopt the version output in CommonJS." | |
| I'm new Flow blockchain, so have to learn a lot. | |
| I faced a lot of difficulties while building the project as I was a beginner to FLOW blockchain. | |
| The biggest hurdle that I faced when I enrolled in this hackathon was learning a completely new language Cadence and also learning how the Flow blockchain worked. The amazing documentation provided by the Flow team really helped me get over this hurdle easily and by using the Flow Playground, I was able to easily understand the concepts of Cadence and build this amazing project. | |
| I was facing issues connecting my app with the Niftory's API, and I solved it by referring Niftory's Docs. That helped a lot | |
| "During the development of this project, we faced several challenges related to decentralization. One of the main hurdles was finding a business model that could support both decentralization and sustainability in the long term, while also being competitive with traditional companies. | |
| Another significant challenge was communication and coordination between the different hubs of the project. We encountered operational difficulties in managing this, which required significant effort to overcome. | |
| One of the key bugs we encountered was related to our communication and coordination system. The initial version of the system was not efficient enough, leading to delays and misunderstandings between the different hubs. To overcome this, we spent a significant amount of time and resources developing and testing a new version of the system, which eventually proved successful. | |
| Additionally, we faced obstacles in finding investors who believed in our decentralized model and were willing to provide funding. Many traditional business leaders were skeptical about the viability of a decentralized organization, which made it challenging to secure financial support. | |
| To overcome these challenges, we remained determined and persistent in our mission to promote decentralization. We sought out investors who shared our vision and offered unique value propositions to demonstrate the benefits of our approach. We also invested heavily in developing and refining our communication and coordination system, as well as building a supportive structure for other decentralized projects. | |
| In the end, we were able to establish a successful decentralized organization that offers transparency and autonomy within project hubs, ultimately leading to more efficient decision-making. We also created a platform for other decentralized projects to receive support and encouragement, leading to a more democratic business landscape." | |
| Our biggest challenge was not a technical one, it was refining our idea and problem statement. We first integrated the Flow NFT catalog into Flutter, and with that functionality we gradually discussed and landed on a concept that we feel can go beyond the hackathon. | |
| "I had difficulties while trying to integrate Flowty marketplace as they used their own custom marketplace contract which was a modified version of the NFTStorefrontV2 contract. Cadence currently does not support named imports which made it diffcult for me to use both Flowty's NFTStorefrontV2 and the original NFTStorefrontV2 contracts in the same contract. | |
| I found a workaround to the issue by deploying an additional helper contract called FlowtyStorefront which imports Flowty's NFTStorefrontV2 contract and essentially acts as an interface for getting the storefront reference. Having this additional contract with a different name enabled me to avoid the conflict in importing the contracts." | |
| I don't know Cadence or async JavaScript very well, and I had never used FCL before, so it was a nice learning experience on the basics of those. bluesign.find was a huge help in the Flow Discord by providing a client-side only vanilla version of FCL JS. | |
| "Creating generic queries that work for all projects is a challenge (especially for those not using the NFTstorefront conventions) so added a backend to add new cadence query scripts via a UI to make it easy to add new projects and new cadence scripts without having to do server updates. | |
| Determining and dealing with the terminology of bought vs minted needs further clarification NFT's can be minted and not bought, similarly confirming changes in ""staking"" needs more thought. Additional granularity around triggers based on all ""service events"" will be added. | |
| In the first POC I've been polling to look for changes, however in the next phase I'll be using graffle.io to simplify queries and use their Live Stream feature to ""listen for indexed changes"". | |
| Current implementations are crude due to the time to create the POC. Adding REST APIs and GRAPHQL are planned in the coming weeks and months. | |
| " | |
| "In order to demonstrate the features of TGS, we decided to use a game engine which has only limited network features to build the demo game Space Crisis. We've occurred lots of issues that are caused by the outdated and obsolete network functions shipped with the engine. | |
| The architecture and the concept of TGS aim to be a universal service that can be customized to adapt to different types of network communication with lower development efforts. We've tweaked the serverless APIs and overcome the problem caused by the engine." | |
| Because the minter's on-chain DNA is 'etched' into the transaction itself, I wanted to save the transaction ID from the minting of a STRANDS NFT onto the NFT, but I couldn't find a way to do this. I have some ideas on how to achieve it via other processes/actions, but for the hackathon I had to table the idea. Also, I made wireframe mockups of the app and still I iterated on the design so much as I built it that that resource was mostly a waste of time. I went through about three different UI schemes while building, which was very time consuming. Even the project name is something I changed, initially starting with Flow DNA, then landing on something more simple ("STRANDS"). Also, I spent a large number of hours in building this and also doing my project with Matheus (for The Beyonders team), which slightly (but I'm sure temporarily) damaged my health. If people love what I made then it'll be worth it! | |
| "During the development of Flow Quest, we encountered a significant hurdle while conducting research on traditional businesses such as retail, events, restaurant chains, and travel agencies. We found that getting insights from these businesses was more challenging than we initially anticipated. | |
| To overcome this challenge, we implemented a multi-faceted approach that involved reaching out to businesses directly, conducting surveys, and partnering with industry experts. By leveraging these different strategies, we were able to gather valuable insights and optimize our products accordingly. | |
| The second hurdle is to design the UI/UX of our platform. It was challenging to create a user-friendly interface that catered to the needs of a wide range of users, from beginners to experienced blockchain enthusiasts. | |
| To overcome this challenge, we invested a significant amount of time and effort into conducting user testing and gathering feedback. We consulted with our target audience and incorporated their suggestions into the design process. We also worked closely with our development team to ensure that the UI/UX was not only aesthetically pleasing but also functional and easy to navigate. | |
| The biggest hurdle is to implement anti-cheating mechanisms. It was crucial to ensure that our platform was fair for all users and prevented any unethical behavior. We invested considerable time and effort into designing and testing our anti-cheating protocols, but we encountered some bugs during the process. | |
| To overcome this issue, we conducted extensive research into the best practices for implementing anti-cheating mechanisms. We consulted with industry experts and reviewed case studies to gain insights into effective solutions. We also conducted thorough testing to identify and fix any bugs that were causing issues with the implementation." | |
| Difficulty integrating Flow module in Vanilla javascript, no example or tutorials found. | |
| "## Challenges Faced | |
| * Abstraction of roles in the content industry, including films, anime, and games. | |
| * Abstraction of the method for distributing rewards using public blockchain contracts. | |
| * Establishing an implementation method for end credit NFTs using blockchain technology. | |
| ## Other | |
| By building the following steps on the Flow blockchain, we can learn the methodology while implementing it: | |
| * Prepare a Flow contract. | |
| * Register creators. | |
| * Issue NFTs. | |
| * Send tips." | |
| Using cadence for the first time | |
| "Mixing new data into an existing project. I didn't want to ""wrap"" someone else's project, so I thought I would use a loose coupling to reference one resource from the other. However if this were done by a account+path+id pointer it would break whenever the account or path changed. Jacob from Emerald City pointed me to the experimental release for attachments and that became core to my project. | |
| Also more generally, just learning cadence. This was my first real project since completing the Emerald City beginner class last summer, so I was rusty and had never tried to build a full dApp. I looked to trusted examples like Flovatar and found support in the Flow, Emerald City and .find discords. Many thanks to all of those helpful community members!" | |
| "While building the proiect there were 2 error: | |
| #### 1. Flow CLI Not Insalling | |
| Due to some DNS issue, I was not able to download flow-cli from the official documentation. Earlier I thought it was issue from flow backend, so I contacted them on git hub and got to learn about the above state problem. | |
| As the problem was now know, I just changed the DNS to google local DNS and used my mobile hotpost as an added security and it was solved. | |
| #### 2. Know Error For `flow config add contract` | |
| As we know, on flow we need to link our contract to account address, hence I used the command `flow config add contract` command, but little later ran into 'panic runtime error'. So I contacted the team and learnt about this is a known bug for **windows and linux**. | |
| I fixed the error by manually adding the flow.json file according to needs, as suggested by my friends." | |
| frontend | |
| integrating fractional NFT contract with main marketplace is our main challenge, unfortunatly we ran out time and can't finished this part but we our working to solve it and connect backend with frontend. | |
| i started it from scratch | |
| The problem we faced is that no wallet support the flow testnet tokens, so it was hurdle so we tested it using your own tokens for the sake of this project but it would be better if more wallets started to suppor the flow testnet tokens. | |
| "Undertaking a project is never a straightforward task, and it often comes with a range of challenges and obstacles that can make the process difficult. These challenges can vary from project to project, but they can often include issues with communication, resource allocation, time management, and unexpected setbacks. Overcoming these challenges is crucial to the success of any project, and it requires a combination of effective planning, collaboration, and problem-solving skills. The creation of FLOW DOJO was not an exception to the rule. | |
| The setbacks started with the vague communication about how the program was going to be structured for the app to be created. The program needed to be laid out in a way that could be coded within a week and still function. We figured out a path forward after having a few meetings to discuss the design of the app and jiu-jitsu program so both sides were happy. | |
| We then had artistic differences with the artwork being designed for the NFT portion of the project. We went through 6 different iterations of the artwork finally settling on the final product which the gym owner and artist are equally happy with. | |
| The biggest hurdle we had was with the in-app minting process. There were issues with calling the contract based on the user’s wallet. The Dapp continued to have error after error trying to figure out the permissions of the contract to the wallet owners. After many attempts, message boards, GitHub samples, and hours of work, our incredible developers figured out the problem and have IN-APP minting ready to go. | |
| Time management was an issue simply because of the tight window of opportunity of the hackathon. We were able to have 5 different meetings during the course of the last week and were able to communicate effectively despite the tight window. We used discord and zoom to their fullest potential. | |
| " | |
| "We had issues with running own instance of Kitty Items DApp on testnet and we had to spend a lot of time optimizing it. | |
| Another issue we encountered was how to display the different social account logins to user. For this, we used the native FCL autodiscovery functionality and basically hacked in 4 social accounts as wallet providers. In production version this would require a single social accounts login button on the wallet selection modal, which would further expand into all social login options. | |
| Other than that, the implementation was pretty straightforward." | |
| "Eventhough we have successfully onboarded users walletlessly, Allowing the end users to claim ownership of those child accounts was a challenge., We had to go through flow tutorials and multiple sample github projects to figure it out. Finally we were able to develop ""Claim Child Account"" feature & implemented hybrid custodial revokking mechanism as well successfully. | |
| Certificates are generated as PDF files., But we think PDF is good for documents/contracts type NFTs only and for certificates., it is better to generate as an image file instead PDF. So that an image preview looks better when shared on social networking sites. | |
| (TBD: To be developed) | |
| For documents/contracts type NFTs, We are exploring ways to store private (protected) information. 1. Encrypt and store on IPFS and decrypt upon successful FCL auth, 2. Encrypt and store in Internet Computer (Dfinity) and reterive upon successful FCL auth. (we may need to write a bridge between FCL and ICP canister read operation). 3. Encrypt and store in a cloud (on-premise of institutions or certifily's infrastructure & reterive)" | |
| There was no proper public dev docs for any of the sponsor bounties. | |
| "When integrating IncrementFi it turned out that their LendingPools test contracts hadn't been updated in a long time. When we asked them about this, they responded very quickly and updated them, which is very cool! | |
| Also, it was a surprise that IncrementFi lending doesn't have pool tokens. We manage to solve this with our wrapper | |
| Otherwise, development on Flow has a very good DX" | |
| "- Integrating the **Kotlin FCL SDK** with **Unity3d**: | |
| - We created our own Kotlin library that utilizes the **FCL Kotlin library**. Check out our different library functions which help **Unity3D** code retrieve and mutate the state: [Code](https://github.com/ssd39/dempire/blob/main/Dempire-fcl-kotlin/src/main/java/com/ob/flow/dempire.kt). | |
| - We are using complex data structures such as **""{UInt: [[Fix64]]}?""**. Building a **Json-Cadence** for it was difficult. | |
| - We have three different contracts: **DEmpire**, **DEToken**, and **DEAssets**. Making secure coordination between these three contracts was challenging." | |
| "1. We struggled for almost 2 days to fetch NBA Top Shot Moments data using cadence scripts and also using Graphql queries. We cant get the required data for our app using cadence queries, so we tried to fetch using graphql. Then we got CORS errors from Graphql public end point. We tried different methods, but none of them worked. Then we created a proxy node server to call graphql queries which ultimately worked. | |
| 2. Cadence vscode extension is not working in Windows Machine. Also, Flow CLI is not working as expected in Windows machine. So struggled for hours in fixing the issue then finally switched to MAC to do coding of contract." | |
| "Many thanks to the Flow community at Discord. When I was about to give up learning Cadence, I got comprehensive answers to all my questions and fully understood how Flow blockchain works. | |
| I liked the Flow blockchain architecture and the Cadence programming language design. | |
| " | |
| The biggest challenge was that Cadence was a new language for us , it took some time to wrap our minds around its syntax , and various concepts like resouces and to successfully be able to write contracts in cadence . We had to look up various tutorials , documentations , and youtube videos . We would like to thank flow's official amazing developers's guide / documentation , learnWeb3Dao and buildspace for resources on how to build a dapp in flow blockchain . | |
| "Flow access nodes were causing errors. | |
| Wallet providers were causing authentication error. | |
| Historical data couldn't be fetched from the API (more than few months old)." | |
| integrating wallet to flow cli | |
| "I had a hard time catching up on the use of AuthAccount's Capabilities and the recently discussed Super Account. | |
| I initially investigated the possibility of using AuthAccount's Capability to make Cadence's smart contract itself an NFT, but found that it could only be used if it was tied to some resource, so I ultimately decided not to use it. | |
| I researched and considered how to send transactions in wallet-less onboarding, but felt that the implementation would be complicated with the current fcl. | |
| The goal I wanted to achieve, which was to create an art platform that had never existed before, did not necessarily align with the theme of this hackathon. I recognize the importance of walletless onboarding, but I felt that I had to first create a wallet-based application before I could do so." | |
| "1) Dart FCL client response wasn't decoded correctly. We couldn't serialize the json into a dart model. Workaround - Moved these components to AWS as services that the mobile app could call. | |
| 2) Couldn't find a non-custodial wallet SDK in the Flow ecosystem to support transfer of custody to the user. Ended by stubbing the part were the user could provide account details from the wallet with entry of public key. | |
| 3) Couldn't get the Flow KMS repo scripts working. Ended up deploying a non-KMS custodial solution for now. | |
| " | |
| The hardest part was to gather resources and ti deploy projects on the testnet | |
| It was a real challenge for us to align the variables behind our math model with the data points extracted from the Flow chain. | |
| "Javascript is not type safe, and apps shipped without type validation can be easy to break. | |
| The FCL SDK does not provide TS support, and I also wanted a better solution for integration with React. We found a non-published use-flow package by Maggo. The library is still under development, but it is almost finished. We forked the library and published it to npm to be able to use it in the project with its typed hooks. | |
| We need to connect the backend to the frontend seamlessly. To achieve that, we used typescript with tRPC. We used DB to authenticate the user, but we also need to make transactions with our contract and fetch data from the blockchain with the FCL SDK. | |
| Terminology. There are terms that are confusing, such as ""collection,"" which doesn't refer to NFT collections but to the NFT held by an account. In Ethereum, the structure of how to fetch is also different.I needed to first understand the glossary and how each term related to the others. I used Dapper Docs to figure out what script I could use to retrieve data from the blockchain. Calling the script to see what the returned objects looked like was a very manual process. flow-view-source helped a lot in understanding what is returning. | |
| Cadence is a new language to me. It does not need to be built. We use the cadence to query and make transactions in the frontend. I just learned a lot during the hackathon about how it works by using scaffolds. Looking at open-source projects reading official documentation, dev.to articles, and watching Youtube tutorials." | |
| "Coming from the Web2 domain, initially understanding the working of the Flow Blockchain was a stammer. Still, it became straightforward thanks to the beautifully crafted tutorials/videos/codes understanding. In no time, we were able to write Cadence scripts and queries which enabled our app to power. | |
| Initially we also found it hard to understand how the fcl-js library would integrate with the code since we were using it on the backend on our nodejs app, but we found tutorials teaching us exactly what we wanted" | |
| "We have built the project in Unity fully so wanted to integrate the flow SDK for wallet connection functionality. Unfortunately, we didn’t get clear documentation of the unity SDK and a bug free sample project as well. We downloaded the project that was available and followed the instructions to establish a test environment but the project was very unstable and kept crashing. In the interest of time for the hackathon, we decided to just simulate the wallet connection as the core functionality of our project is the AR experience showcase. | |
| As a comparable, chainsafe SDK for unity has good documentation and works well. " | |
| "As first time Flow developer biggest challenge we ran into is getting used to of the ecosystem. My app works perfectly fine to testnet but not on emulator or vice versa. I faced challenges while deploying the app on vercel too. One thing which I missed in Flow ecosystem is a native social graph protocol. We might end up building that to support more projects like ours. | |
| Deploying the app on vercel with testnet credentials was something we could not completely figure out during this time. Pls reach out in case you fail to use the app from the vercel link. We can give a live demo in dev mode. Although I have recorded and uploaded the video of me using the app in dev. " | |
| "While developing the Escape Room game for Flow Beats, we ran into a bug where the game wouldis not loading and giving major errors. We discovered that the problem was actually caused by some minor bug issues that we ignored initially.We implemented a series of browser-specific workarounds to ensure that the game would load and run smoothly across all supported platforms.This involved making changes to the game's code and assets, as well as updating our deployment process to include additional browser testing and compatibility checks | |
| As a whole we faced :- | |
| 1. Integration with Niftory's walletless onboarding API. | |
| 2. GraphQL schemas. | |
| 3. Several game development bugs. | |
| 4. Interacting with Flow Blockchain. | |
| As we introduce more features, it will get complicated but our whole mission is to simplifying gaming and introducing P2E NFT Model to it so we are ready to face it." | |
| "Many bugs comes from: | |
| - Poor explained documentation about how to proper use flow.json and aliases for testnet deployment; | |
| - How to update and existing contract on testnet, changing variables type; | |
| - Some core bugs from emulator which increase effort on debugging, such as stop&start of pm2 and redeploy a contract;" | |
| Working with cadence was a little bit challenging, I just got to learn about cadence about a week ago, and it's the first resource-oriented language I have worked with. The access base capability model was also strange to me, i was actively looking for a type of msg.sender functionality to work with. I also had a problem listening to events using the flow client liberty, I had to listened for changes on the block chain by sending requests every 5 seconds | |
| "One of the biggest challenges was creating an NFT contract that accepted the specific metadata that we needed for our aiSports NFTs. | |
| One other challenge was creating a minter function and allowing users on our site to mint (with access) from the aiSportsMinter contract that was deployed to another (authorizer) account. We had to create a serverAuthorization object and supply our private keys in order to do this. This was a bit tricky given the current documentation. " | |
| "While developping this system we had to think of a good infrastructure that would be highly scalable, cheap but also would leave full control to both applications and the applications users. We read a few documentation about the walletless implementation and thought that the system was already existing but we learned the hard way over the week that it was not fully operational :p. | |
| We knew there was a lot to build but understanding cadence concept and bringing the requirement of data sharing with certified openID connect server didn't leave us a lot of time. We dealt with cadence contract mostly using the emulator and we are running a bit out of time to fully integrate it in the backend services as the documentation was a bit lacking for some part. | |
| Digging around the different documentation and questions on discord helped us uncovered more nice feature of flow blockchain and is comforting us in the choice of this blockchain as a base to provide users with their data sovereignty but 5 days and just 48 hours more is not enough at all to be able to build a decent good contract. We copied a lot of the current child template existing in order to build ours but we don't feel that it's good enough right now. I can't classify this as a bug but we know we need more time to really build that link and unlink experience for the end users | |
| Also in order to keep the backend light and fast we decided to use markojs and not react which gave us a lot of trouble to get fcl working on the front end but also wagmi (this isn't part of flow but it did make us lose a lot of time xD)" | |
| "- Took a long time to figure out the Cadence language - it is more verbose than the average language, making it difficult to decipher | |
| - Wanted a self-custodial wallet solution for our solution but could not find it in Niftory's walletless API | |
| - I am the only dev in the team and my laptop couldn't be switched on after working on the project halfway. Though I have already created a FLOW account for Stamps and completed the necessary research to figure out how to deploy a collection, I am unable to do so because of this hardware problem." | |
| We wanted to walletless on-boarding with Niftory but Niftory API is not supported custom transaction and smart contract. So, we had to change our codes and design | |
| "Designing the overall tokenomics/smart contract architecture. | |
| - Coming up with a sound and fair model for reward token distribution considering the peculiarities of Flow staking. | |
| Solution: Rewards come with a delay, unstaking isn't instant either. | |
| - Figuring out how to withdraw Flow staked in the smart contract back to the user's account. | |
| Solution: migrating the whole delegation vs de-staking and then withdrawing flow directly | |
| Emulating staking on the emulator for the sake of testing. | |
| " | |
| "- Setting up our project with the Flow emulator | |
| - Knowledge about Flow and cadence language features (e.g. Contracts, Capabilities, Resources, Structs) | |
| - Debugging the compilation errors | |
| How we got over it: | |
| - Cadence documentation | |
| - Monster Maker repo | |
| - Jacob Tucker's video's on youtube " | |
| Was facing some issues while building the Smart Contract and integrating it but Thanks to the amazing folks at Buildstation who helped me out. | |
| Adding a feature to print pdf in nextjs, and working with NFT standard on flow playground. | |
| "I think one of the most challenging things was configuring the smart contract import resolution. It wasn't quite clear to us how to use the new import resolution (introduced in flow super commands) in combination with the older import resolution (at least for non-project contracts). | |
| We solved this problem/struggle by looking at the setup of projects like .find." | |
| "Both of us were new to the Flow Ecosystem but we went from 0 to Hero in just some days by overtaking every obstacle. | |
| It was not easy , building on a new blockchain. We had less time to explore. But Niftory solved some of our problems and then we coded day and night to achieve this. | |
| We are very happy to present you to our Project - Flow Estate ." | |
| "We initially struggled to comprehend the mechanics of the Flow Blockchain. But the workshops helped a lot and We quickly became proficient in writing Cadence scripts and queries. | |
| We lost half a day in integrating card payment method using USDC. It feels good to have finally succeeded but we hope the team works on to provide concise and to the point documentation. | |
| Another challenge faced was the poor documentation available for implementing a custom wallet authentication function. | |
| We also encountered difficulties when it came to integrating the fcl-js library with our code, as we were using it on the backend of our nodejs app. Nevertheless, the dev support team came to the rescue and now its working fine! | |
| Challenges we're dealing with as we scale: | |
| 1. Addressing regulatory compliance: FutureFlows is in talks with legal experts to ensure compliance with relevant regulations and laws, such as securities laws and AML requirements. | |
| 2. Building trust with users: FutureFlows will take steps to increase transparency and communicate openly with users, providing reports on trading activity and platform performance. | |
| We are developing an independent website called Futurescan that tracks trades on FutureFlows. | |
| 3. Providing sufficient liquidity: FutureFlows will incentivize liquidity providers to join the platform by offering rewards or other benefits, and could also work to attract more traders to increase trading volume. We're integrating 'IncrementFi' to shoot the overall liquidity. | |
| 4. Addressing technical challenges: FutureFlows is looking for more Flow developers and experts in the field to address technical challenges, such as implementing security measures, improving transaction throughput, and optimizing smart contract code for efficiency in general." | |
| Nope. It was very fun, and I became happier while writing the cadence codes since I'm improving the Cadence skills. | |
| The API of Flow Python SDK is not as frienfly as fcl-js. We had to dive into its source code. | |
| "The demo demonstrates the purchase of a FLOAT NFT priced for 1 FLOW with card on testnet. This required many processes put together to implement a working solution on testnet in a short amount of time including: | |
| - Using the FLOATs contract by Emerald City DAO to demonstrate the solution https://testnet.floats.city/0xad6aa3b3eb3a0dd3/event/136396920 | |
| - Retrieving live FLOW to USD prices | |
| - Displaying all fees at checkout (in the spirit of transparency) | |
| - Ensuring valid flow wallet addresses and .find wallet addresses entered | |
| - Ensuring only one FLOAT per address, and each wallet already has the storage/public path for FLOATs | |
| - Implemented a USDC treasury | |
| - Implemented exchange of USDC to FLOW using a USDC - FLOW swap (increment.fi) | |
| - Stripe integration for fiat payment | |
| - Ensured the original smart contract creators receive royalties | |
| - Minting of the NFT and transfer to the provided wallet address | |
| - Proving a link to the transaction on testnet using flowscan | |
| We had time constraints and could not implement everything we wanted. | |
| We had many more edge case scenarios that still need to be considered. | |
| We also had some challenges customising Stripe UI as per our initial workflow. | |
| " | |
| Figuring out how to use the Flow network was such a huge pain. Majorly because we are first-time users, who have never worked with Cadence, or the Flow chain. | |
| Learning curve of technology | |
| "One of the challenges that we encountered was the generation of a random number in order to select the winner of the lottery. | |
| We managed using the pseudo random number generator deployed on testnet by justjoolz. | |
| Even if the generator works well it’s stil not completely safe from attacks. | |
| Another problem was my cat sitting over the keyboard when I left the desk." | |
| "We ran out of time and into many challenges deploying the project mostly knowledge gaps within the developer documentation. However we was able to form a concrete MVP proposal. | |
| " | |
| "When working on this sprint, we had 2 main hurdles to overcome. | |
| ## Integrating Niftory into our bot | |
| Their API offers many handy features which we wanted to use, but they have a lack of documentation for some features, which made it difficult for us to navigate the platform. We had to explore and reach out to their support team on Discord for assistance. | |
| Despite these challenges, we found the support team to be very responsive and helpful. We also encountered some difficulties with the platform's hierarchy, particularly with regards to the ""Set, NFT Model, and Mint NFT Model"" system. We learned that a set is a collection, NFT models are models of the NFT, and that multiple identical NFTs can be minted from a single NFT model. | |
| Additionally, we discovered a few bugs with the platform's GraphQL API, but were able to work with their team to reproduce and troubleshoot them. | |
| Overall, while we encountered some challenges, we were impressed with the platform and appreciated the support we received from their team. We look forward to continuing to work with them in the future. | |
| ## Solving Stable Diffusion API and tuning | |
| Our partner Scenario.gg is a platform to train, use and host SD models with API. | |
| We got the first access to beta for this project (!) and so we had the challenge of working with a new, untested API. | |
| Florian spent hours working to test generations for the right settings, which have many layers of complexity to get right generations. | |
| In parallel, I was fine-tuning the AI model for our 3D pipeline. For this hackathon we wanted to make something FLOW themed, so our model is for collectibles that use your vibrant colour pallet, flowing design and cute character aesthetic. (Cryptokitties, Doodles, Flovatar). Using our 'Art Toy' model as a base we fine tuned a model using flow branding, colours and designs and after 5 iterations, we now have a Flowaii, Shadow Flow & Headz model, made just for you! | |
| " | |
| During the development of our project, we faced several challenges that required us to think creatively and adapt our approach. One of the main challenges we encountered was the complexity of integrating blockchain technology with social media accounts. This required us to develop new protocols and tools to ensure that profiles could be securely and efficiently transferred between accounts. | |
| "Seems older projects used a different metadata standard, currently out of the box we only support projects that use the the NFT MetadataView Contract. | |
| After creating the Tamagotchi mini-game we realised it would take too long to create a meaningful POC. So We integrated with a bunch of games we worked on previously as well as some open-source games and micro games from code pens (Links to credits & attributions in github link) Current integrations are super hacky using iframes and parent post messaging to track game state and scores. Over time we plan to create our own bespoke minigames and collaborate with the project owners on ""Boosters"" and game elements. | |
| Due to the nature of the project mobile optimisation for casual gamers is a must, all the mini-games work on mobile. However we ran out of time to make ""Tamagotchi Mode"" mobile-friendly in fact it bugs out on screens less than 14"" :-( | |
| " | |
| "Reworking Listing on Niftory to show Metadata and details. | |
| integrating the sponsors- will add later.." | |
| My biggest challenge is time. I came across the hackathon about 2 weeks ago. I don't have much experience with smart contracts. I work a 9 to 5 job that limits how much time I could dedicate during the week. I soaked in as much knowledge as I could. I watched many video tutorials and listened in on flow hackathon discusions where I could. I have many attempts at starting a prototype but still need more basic experience with developing a dapp. | |
| "As a typical web developer, I had high praise for Flow, such as ""it's easy to get into,"" ""it's user-friendly,"" and ""Cadence is similar to TypeScript,"" and I must say these aren't false. However, there's a ""but."" When you only have one week to learn how to use the Flow CLI, the FCL, and to code using Cadence, things get tricky. That said, it's a fun learning curve. | |
| The most challenging part for me was integrating a seamless wallet creation process. I had to figure out a way to ensure that the user's eSignature would be safe and owned by itself only, while the documents would remain available even if the user's wallet got lost. | |
| This issue brought up many questions. When do you create the wallet? Do you tell the user about the blockchain side of things? Do you store the user's wallet in case they lose it? In the end, I opted for a different method than what you might see in a traditional Web3 dApp and tried to get as close as possible to the Web2 flow without compromising the layer of security that the blockchain adds. | |
| Here's what I did and how I did it: | |
| 1. The user creates a typical Web2 account using an email/password. The goal was to make it seem like a traditional SaaS, as I don't think people are entirely ready to move into Web3. | |
| 2. There's an onboarding flow. This is where the user learns about the ""Safe,"" or what you would call a wallet. The wallet is then linked to the user account and can never be changed. This ensures that the signature remains assigned to this account. | |
| 3. Lastly, the user creates their eSignature. In this final step, the user links their eSignature with the newly created wallet. | |
| With all that, the user is aware that the eSignature is in their own hands, that the app can only recover their documents, and that their eSignature can't be easily stolen since it is not directly exposed in the sending process." | |
| "When creating MinterSpace, we faced several challenges that needed to be addressed. The first challenge was integrating the Stable Diffusion UI Gradio with the flow-py-sdk library. We discovered that editing both Gradio and flow-py-sdk was a difficult and inflexible process. | |
| In our initial attempt at minting NFTs, we tried doing it on the server-side, but we quickly realized that the process was too complex. As a result, we had to explore other solutions that could simplify the process of minting NFTs. | |
| Next, we set up Stable Diffusion on our own server, but we encountered a lot of challenges in the process. We then proceeded to code the user login and image minting processes using the Flow FCL library. However, this process was also not without its challenges. | |
| We later discovered the Niftory Web3 integration, which made the login and minting process much easier. This integration allowed us to streamline the user experience and simplify the overall process. | |
| Another significant challenge we faced was loading the AI model into memory and performing image generation while managing the model on consumer GPUs and commodity hardware. This required a great deal of optimization and customization to ensure that the system could handle image generation at scale. | |
| In summary, the challenges we faced when creating MinterSpace were numerous and required a great deal of technical expertise and creativity to overcome. However, through perseverance and collaboration, we were able to develop a system that simplifies the process of generating AI art and minting NFTs on the Flow blockchain. " | |
| "* Although NFTrivia is a web app, I wanted it to run quickly and feel as ""native"" as possible. To that end I stuck with vanilla ES6 JavaScript, avoiding bloat and unnecessary packages. The end result is a very lightweight web application (9KB zipped) that runs smoothly. | |
| * Maximizing the screen real estate, especially for smaller devices, required a bit of math to calculate the ideal grid for display. | |
| * Although the web application is lightweight, some of the IPFS images referenced in the metadata are high resolution and not ideal for mobile. In some cases these images are large (3MB+ for some UFC Strike). I would like to build a generic IPFS resizer/cache to improve performance, but that is beyond the current scope for this hackathon. | |
| * While fetching NFT metadata from Flow is fairly simple, the subtle (yet frustrating) variations in metadata between Dapper Sports products introduced a variety of changes in trying to standard fields. For example, getting the player/athlete name from the metadata should be trivial, yet all store this information differently: | |
| UFC Strike: athlete_name | |
| NBA Top Shot: FirstName and LastName | |
| LaLiga Golazos: PlayerFirstName and PlayerLastName | |
| NFL All Day: playerFirstName and playerLastName (notice that case is different vs Golazos) | |
| * In rare instances, fetching NFT collections for larger accounts needed to be broken up into multiple Cadence calls." | |
| "- We are new to the Flow ecosystem and had to spend a significant amount of time learning Cadence, transactions, scripts, and fcl. | |
| - Attending sessions and workshops aided us in completing this learning journey. | |
| - We explored our ideas in the NFT domain and wanted to build solutions to address some of the flow community's pain points. | |
| - As a new NFT marketplace, we wanted to maintain our UI appealing while remaining basic, which we believe we accomplished in this time frame. | |
| - We encountered numerous challenges while deploying smart contracts via flow-cli, the most significant of which being the inability to use update-contract via flow-cli on testnet. | |
| - A lot of engineering went into building the Pack Smart Contract and providing a Pack Proof Token to provide users the experience of purchasing and opening packets on chain that is akin to an off-chain experience. | |
| - We were integrating the Niftory walletless API, however, we couldn't find a good use case because NIftory doesn't yet enable manual smart contracts. | |
| Our platform would not have been possible without the assistance of Flow ecosystem initiatives such as - | |
| 💡Smart Contract DSS Protocol by Dapper Sports Studios | |
| 🎁Premium Membership airdrops by Puddle | |
| 👱♂️Name Resolver By Flowns | |
| 🌐Wallet Providers - Lilico and Blocto | |
| ✅Walletless Google Sign-in By Niftory | |
| 🏢Business Model | |
| - For each resale of the Moments, we will collect a small royalty fee (Currently 15%). | |
| - The funds raised will be used to self-sustain the platform. | |
| ⌛Future Scope | |
| - Connecting the tools to other NFT marketplaces like NBA Top Shot and NFL All Day. | |
| - Pack Expected Value Estimator | |
| - Community Ratings for each Moment" | |
| "The API slowed down debugging so we cached the responses: | |
| $moment_flow_ids = Flow::script('./scripts/momentFlowId.cdc')->argAddress($wallet)->run(); | |
| $moment_flow_ids = json_decode($moment_flow_ids); | |
| file_put_contents($cache_flow_ids, serialize($aMoments), LOCK_EX);" | |
| "Repeated lesson bug found and killed! JS and its asynchronicity... we finally found a Stack Overflow post that solved the thing. We also mainly had challenges developing a frontend and not having enough time to make a fully running application. We didn't have enough time to get over these hurdles. Overall, time was definitely the biggest challenge. | |
| Additionally, there was a experience gap regarding programing with asynchronous languages, such as Javascript. The React framework is powerful but very tricky to use in Ricardo's opinion. We could have also had one or two more members to share the load of developing, finding members initially was a challenge; this was an issue with event organization. | |
| Lastly, the objectives of the Flow Hackthon were very broad, so we have no idea if we did a good or bad job. We just had to work through these last challenges and hope for the best. " | |
| For scanning user wallet address I have to add QR scanner in the project for that I used react-qr-reader node package but its latest beta version not supporting blocto wallet QR code, to overcome this issue I go with the 2.2.1 version. | |
| "Our team faced a significant challenge while building this project: we did not have a Cadence developer among us. Since our project relied heavily on Cadence, we were initially worried that we wouldn't be able to make much progress. | |
| However, we decided to focus on what we could do well and make the most of our strengths. As a team with a strong background in UX design, we put all our efforts into designing an intuitive, user-friendly interface for our platform. | |
| Throughout the design process, we encountered a number of hurdles, such as navigating the complexities of the project's underlying architecture and finding ways to optimize the user experience. But by working collaboratively and drawing on each other's expertise, we were able to overcome these challenges and produce a polished, well-designed interface. | |
| Although we didn't write any code for this project, we are proud of the work we have done on the UX side of things. By taking a user-centric approach and focusing on design, we believe that we have created a platform that is both functional and easy to use. While we faced significant obstacles along the way, we are proud of what we have accomplished and excited to see where this project goes in the future." | |
| "## Implementation of Walletless Onboarding | |
| A big challenge has been to learn the walletless onboarding approach in a short time and implement a complete backend service, including key management, account generation, account linking, and integration with third-party services. This process requires implementing many things we have never tried before, which is challenging, but the walletless onboarding approach is very innovative, making the whole process also interesting. | |
| ## FlowSDK Unity | |
| Another challenge is the lack of documentation for FlowSDK Unity. We didn't even know how to use variables correctly, but luckily, the Flow Words and Flow Sample examples were very helpful. Special thanks to Ash Muller and Matthew, who helped us a lot to understand and better grasp the principles of FlowSDK!" | |
| "Everything we are building in flow is quite new and learning and building our concept of POS took some time also if we had more time we would have added to the Ipad POS application itself, but so far only able to complete the web prototype only. | |
| ## Goals | |
| The goal of the project is to provide a user-friendly interface for merchants and customers making cross-chain payments on the POS, we are already building an iPad POS on Solana and polygon, and this prototype gave us an idea to support flow in the POS app https://twitter.com/JezeroPay." | |
| "runned out of time, many error on the contracts , first time using Cadence, had a blast and wish i finished , this was the plan | |
| Plan: | |
| The development of the dapp will be divided into several phases: | |
| Phase 1: Design and Development of Smart Contracts | |
| The first phase will involve the design and development of smart contracts using Cadence. The smart contracts will handle the creation of NFTs, minting, and storing metadata related to the purchase. | |
| Phase 2: Integration with Online Shop System | |
| The second phase will involve integrating the dapp with an online shop system. This will allow buyers to purchase fashion items using either traditional payment methods or Flow Token | |
| Phase 3: Testing and Deployment | |
| the dapp will be deployed on the Flow blockchain. | |
| Technical Overview: | |
| The dapp will be built using Cadence, a resource-oriented programming language used for developing smart contracts on the Flow blockchain. The smart contracts will be divided into several modules, each responsible for a specific function. The modules will include: | |
| NFT Module: This module will be responsible for creating and managing NFTs on the Flow blockchain. It will handle the minting of NFTs, assigning unique IDs, and storing metadata related to the purchase. | |
| Payment Module: This module will be responsible for handling payments made using cryptocurrency. It will interface with cryptocurrency wallets and handle the transfer of cryptocurrency from buyers to sellers. | |
| Claim Module: This module will be responsible for handling claims made by buyers for getting their purchased products manufactured. It will verify the ownership of the NFT and trigger the manufacturing process. | |
| Resale Module: This module will be responsible for handling the resale of products. It will allow owners to transfer ownership of their NFTs to new owners. | |
| " | |
| The biggest challenge was just that we had personal life obligations like work and moving so time was our limiting factor. Our backend routes are all done. Frontend calling it but just didn't have all the time to call every backend route that we wrote and tested. We just didn't have enough time and also had to onboard other devs that weren't familiar with crypto on how crypto worked and that took some time as had to code for the experience of a crypto user. | |
| "while running the project, Its get successfully compiled but After click the login button it shows localhost error still we | |
| facing this issuse sometime" | |
| "Time has been the biggest difficulty in this process. Interflow is an app with an immersive 3D experience. We wanted to bring many more features and examples of what is possible for the user, and we had to limit ourselves and illustrate our ideas in a short way. | |
| Nevertheless, we managed to make great progress! | |
| On the technical side, we had problems using FCL natively. We wanted to offer a hybrid interflow wallet account with another wallet flow provider, but we could not get the transaction signatures to work... | |
| We had a breakthrough and were able to do full native authentication by modifying the fcl package locally, but it only worked perfectly for Blocto Wallet. | |
| Within the app it is possible to authenticate with Dapper Wallet, but we did a little hack. | |
| 3D | |
| In the 3D space, we encountered a significant obstacle while implementing the React Three Fiber library into a native app. This is because the documentation for a native implementation was minimal. Our primary challenge was loading GLB/GLTF models, but we overcame this by understanding how the react-native loader works. | |
| Avatar Animations. | |
| The import of the Avatar emotes and movements were difficult and then the engine that powers the movement across the Interspace and games were a big challenge because the engine has to transition smoothly into the right animation. | |
| Avatar Configurator UI | |
| Our Avatar Configurator UI features a basic WheelMenuComponent, it provides the user a seamless and intuitive experience. Achieving this level of functionality needed to ensure the correct alignment of items and accurate animation of the wheel upon user drag gesture. To accomplish this, we had to gain a solid understanding of trigonometry to properly align the items, as well as learn about the PanResponder class from React-native to enable animation of the wheel in response to user drag gesture. | |
| And finally the development and design of the infrastructure that connects all those modules was an incredible challenge." | |
| "The Flow Unity SDK is still early in its development and hence currently only supports a dev wallet. | |
| By incorporating Niftory, creating an NFT collection using their admin tools was incredibly straightforward for the non-developer in the team to do. | |
| By using the GraphQL api from Unity, querying and minting the assets was mostly straight forward. Better support for OAuth2 login from Unity and integration with Unity’s Authentication flow would make this a very powerful solution." | |
| We faced a problem with the user sale nft id which was returning nothing. | |
| We ran into some challenges at the end of the hackathon development period where some test cases were failing. We are new to Cadence so with a little more time, we would have been able to resolve these bugs. One specific bug that we couldn't handle when developing was working with capabilities and understanding how collections worked as a whole to introduce different permissions for various users. We got over it by looking at numerous contracts that other projects have deployed on flow to understand what exactly is going on rather than trying to take apart the documentation to understand it. Additionally, with a couple of runtime errors here and there, and an ongoing bug with dealing with multiple iterations of our contracts, we were able to get rid of most of our bugs and create a somewhat working demo/prototype. | |
| Cadence has its unique syntax and structure, which took some time to understand for developers. However, Flow has an excellent documentation system, including guides and tutorials, which helped us to learn the language and start building on the platform. | |
| The concluding days of the hackathon were the most difficult aspect, as it required bringing all the individual components together. This is precisely the reason why we developed our service. | |
| "During the project, we faced a number of challenges, including limited time and a small team of only two members. One of the biggest hurdles was our lack of familiarity with the programming language we were using. However, we overcame this obstacle by focusing on the most critical aspects of the project and leveraging online resources, such as tutorials and forums, to quickly learn the new language. We also prioritized effective communication and teamwork to ensure that we were making the most of our limited time and resources. | |
| Although we were not initially aware of Niftory, we overcame this hurdle by creating our own Walletless Onboarding as a Service and integrating it with more databases to customize it to our needs. We successfully deployed it in AWS and plan to open-source it for the community. Github is on the Link! | |
| At first, we developed the mobile UI/UX using Flutter due to its smooth performance. We successfully integrated Google Authenticator for login and created a custodial wallet using our service. However, we later encountered difficulties with Flutter's UI/UX, prompting us to switch to React Native, a language we are more familiar with, resulting in a faster interface. Despite the change, we will still open source the Login Code we developed on Flutter for other developers to use. | |
| Adapting to Flow's SmartContract Cadence posed challenges for us. Notably, the difference lies in how the resource is stored in the user account and how to utilize the optional feature. Throughout our journey, we encountered multiple bugs but managed to resolve them gradually with the help of the available documentation. | |
| " | |
| All of our team members were new to the Flow ecosystem and this was our very first project with Flow. We had to spend some significant time in order to gain an understanding of how Flow works and learn the Cadence programming language. There were also certain limitations for the Flow Unity SDK and Dev Wallet. But needless to say, the Flow documentation, tutorials and the community were incredibly helpful to bring our project to completion, and we couldnt be more thankful! | |
| "Cadence provides great resouce-level access control. However, within one-week hackathon, we didn't find solutions providing more granular control to prevent incautious transactions from mutating the non-related resource fields through the capabilities. | |
| In Buzzflow's case, we want the delegate accounts to interface different social platforms' metrics (say subscribers). When updating a particular NFT's fields, we don't want Tictok's delegate account to change this NFT's Twitter subscriber number. But if without further design, an incautious transaction could easily breach it. | |
| Therefore, we proposed **AccessManager** as a solution/pattern to reduce such risks. A more detailed discussion is [HERE](https://github.com/dprat0821/buzzflow/blob/main/AccessManager%20-%20A%20Granular%20Resource%20Access%20Control%20Solution%20.md), along with a [Playground](https://play.flow.com/87a940a4-33cb-41e3-94c1-80cb71c35bfe) to explain the idea. | |
| > **Note**: With our limited understanding to Cadence/Flow so far, it's technically impossible to prevent intentional field-level access breaches (I could be wrong). Therefore, the intent of designing AccessManager is to provide a countermeasure for just incautious transactions, with the trust of all public accounts behave with good will. - Although this could be another serious topic to discuss" | |
| We were unsure how to implement the Dapper wallet into our system. After some research, we discovered that it is not available by default. However, the documentation is excellent, and as a result, we were able to overcome this issue. | |
| "We have faced many challenges like creating wallets ,source code error and creating the app. | |
| We have overcome all this by using niftory application and meetdapper for resolving issues of app creation | |
| We have also realized thatthis industry is very confusing | |
| " | |
| It can be slow to mint + transfer assets. I was making the nft collection initialization call before every spin of the gumball machine but that can be moved to login. Either way, making a call to initialize the NFT collection can be prohibitive, especially on prod, we'll have to seed the account with some flow tokens after the user makes his first purchase if we are to make this scale. Otherwise no major blockers. We do have plans to productionalize this. | |
| "While building first challenge was to change the architecture of our codebase, since we already had ethereum, solana and NEAR, we overcame that. | |
| And second challenge was listing flow projects, so we found a website on flow, flowverse.io, and we manually uploaded the projects we found relevant over there" | |
| It has been a challenge to participate in this hackathon, as much of the flow documentation is in English, with very little updated content and poorly organized. Many of the tutorials I tried to follow in order to replicate things in my development environment did not execute correctly. I was only able to write the code for my contract, but I never knew how to deploy it, add functions, or interact with it. Learning all of that in such a short time has been a real challenge, but there is a need for more resources that one can use to develop properly. | |
| None | |
| UI/UX was a challenge integration with Niftory API was easy and made whole process easier. | |
| Being noob in flow blockchain...deployment was the most challening :) | |
| Learning an entirely new blockchain was more difficult than we thought. Even though it is well structured, it took time for us. Even at the end, we couldn't finish the backend and integration completely. We mainly finished the frontend and the basic functionalities of the project. We previously worked well enough with Kotlin, but due to the lack of documentation on Kotlin, we were unable to go through that. We got some http module errors due to the version of modules we installed that were really difficult to solve. | |
| Oddly enough we were having a really hard time creating Flow Accounts/Wallets due to the sparse documentation for how this is done in Javascript. We ended up creating wallets programatically (for testnet only, in production we would do this in a more robust manner) by using the node:child_process node module to install and use the flow cli from within our backend cloud architeture. This allowed us to generate the required key pairs and create the wallets. | |
| Excited to be one of the first Unity devs to use Flow Unity SDK! | |
| Generation of AI img to getting it through tghe transaction at puddle. | |
| "- One challenge was in creating an NFT collection on the Flow blockchain and understanding the resource-oriented approach that the platform uses, which was difficult to understand as I am not much familiar with account-based models. | |
| - Another challenge is integrating the Flow contract with the front end of the application, which can be complex and require significant technical expertise." | |
| music timing and dealing with multiple state of audio | |
| Time constaraints as started late in the hackathon. Learning the new paradigm of smart contract in the Cadence, which is resource oriented. Building alongisde while learning all things about the language and how assets are stored in the accounts on flow blockchain. | |
| It was my first project on flow. Deployment was the toughest part. | |
| Just the setup for the project and compatibility of the plugin | |
| "* We had to make a custom Cloud Function that helps all the users of a particular community to exchange their Room ID randomly and then video/voice chat with each other. | |
| * Creating a fully functional mobile application within a short timeframe can be quite challenging. However, the experience of delving deeper into mobile development and successfully building an MVP/demo from scratch was certainly an enjoyable learning opportunity. | |
| * Acquiring the skill set to seamlessly integrate with the Blocto wallet using the flow library has been an enlightening experience." | |
| We ran into several problems with the time we can spend developing the solution but besides that, we think the only problem was the tradeoff between being a mainstream ecosystem or using all the capabilities and power of web 3.0. We choose a hybrid model but we can improve what we build in order to explode all the potential of both worlds | |
| "One of the first few devs using the Flow Unity SDK. | |
| During the development of our 3D metaverse game, we encountered several challenges, including difficulties with networking | |
| and learning a new programming language. | |
| Networking was a major hurdle for us as we had to ensure that the game could handle multiple players simultaneously while also keeping the gameplay smooth and enjoyable. We encountered several bugs related to syncing players' movements, animations, and inventory, which resulted in a poor player experience. | |
| In addition to networking, we also faced challenges related to learning the Cadence programming language, which we used for smart contract development. As we were new to this language, it took us some time to understand its syntax, data types, and data structures. We had to consult the documentation and online resources extensively to overcome this challenge. | |
| Finally, as we were new to game development, we faced several obstacles related to game mechanics, graphics, and sound design. We had to learn various game development tools and software to create the game assets and environments. | |
| Despite these challenges, we were able to overcome them by collaborating closely as a team, seeking help from online communities, and conducting thorough testing and debugging. We also kept our focus on our end goal, which was to create an engaging and immersive 3D metaverse game that would provide a unique and enjoyable experience for our players. | |
| " | |
| "UX Pov : | |
| We ran into problems when defining the UX because such an experience is fairly new, the combination of NFTS with AR and also with secondary selling. The app needs to be fun and not too tiring for the user to navigate around. The colors used tried to ease the tension but as we move ahead we continue to use jargon they are familiar with and make it a point to make it more fun for them! | |
| Tech Pov: | |
| We have created a mobile-first web experience keeping in mind how a web-first experience can help in mass adoption. The website is built using NextJs, it was hard integrating so many moving parts into a Nextjs project. Getting the camera view working on all devices took some debugging. | |
| Flow blockchain's unique architecture and features make it well-suited for handling the high transaction volume and scalability required for a mass-adoption app centered around NFTs. We leverage the Niftory APIs to create a seamless wallet-less onboarding experience where the user is given a social login option and we create a wallet for them on the fly. Niftory APIs are also used to mint and transfer NFTs to the user’s wallet. Integrating Niftory's graphQL APIs was very challenging as we have never worked with graphQL before | |
| We are using nested NFTs on the unique network to create geo-tagged NFTs. Every parent NFT has nested child NFTs, these child NFTs are associated with the benefits that every brand provides. Once these benefits have been claimed these child NFTs are marked as claimed. Showing this in the UI and then connecting this back to the NFT was also a challenge | |
| " | |
| "Building on Flow for the first time | |
| - Finally figured out to write my first contract in Cadence, and deploy it using Flow Playground on the emulator | |
| - Later I used FLC (Flow Client Library) to deploy my own smart contract to the testnet using the entire software suite. | |
| - Problems associated with minting Fungible tokens to the wallet while connecting chests and problem solving using React | |
| - Designing sprite animations on Aseprite and understanding key concepts of Phaser for game development. | |
| - Figured out Flow installation and CLI usage using tutorials from Learn Web3 DAO, and integrated with the mini game in a span of 6 days, thanks to the time extension. | |
| ## Deck | |
| [Our Deck](https://docs.google.com/presentation/d/1zcl30uEqFLAtTQzhljQW6FsUZz4NWrSGGWt02Fmj9PE/edit?usp=sharing) | |
| # Future Plan | |
| - Introduce Game Token | |
| - Allow players to create and uplaod their own storylines and characters to the platform with DAO token incentives | |
| - Stake and Battle modes | |
| - In game DEX on Flow Blockchain | |
| # How to run ? | |
| In the project root: | |
| `yarn && yarn start` | |
| In `blockchain/src/components/App.js`, please verify the flow client library config | |
| ` | |
| fcl.config() | |
| .put(""app.detail.title"", ""My Flow NFT DApp"") | |
| .put(""accessNode.api"", ""https://rest-testnet.onflow.org"") | |
| .put(""discovery.wallet"", ""https://fcl-discovery.onflow.org/testnet/authn"") | |
| ` | |
| Block explorer: `https://testnet.flowscan.org/` | |
| # To deploy contract | |
| - `flow init` | |
| - `flow accounts create` | |
| Fund Wallet with TEST FLOW Tokens: [https://testnet-faucet.onflow.org/fund-account](https://testnet-faucet.onflow.org/fund-account) | |
| - `flow accounts add-contract <CONTRACT-NAME> <CONTRACT-NAME>.cdc -n testnet --signer <ACCOUNTNAME>` | |
|  | |
|  | |
| " | |
| "- While making the smart contract in cadence we ran into a lot of challenges again. Things became too complicated and we faced many major errors which took more than two days to resolve. | |
| - We ran into quite a lot of challenges starting off with the front end, we faced several issues while making the front end durable to our backend thing took quite a lot of time to figure out and turn things out correctly. | |
| - Then we faced a series of issues and errors while making the backend and making it meet the requirement of the contracts. | |
| It took a lot of research and resources to solve those. | |
| - After that when we came to integrating everything it took two to three days to get everything in line and working with absolutely no errors and everything worked just as per planned. | |
| - It took days and nights of hard work to make this project we’ve gone through multiple sleepless nights, just working through this project to give it all we had and here we are full and finally complete for submission." | |
| "Creating a betting platform that utilizes NFTs on the blockchain within a very short timeline of 2-3 days presents several challenges. Below are some of the challenges we faced during the development of the BetNFT platform. | |
| Limited Timeframe: The timeline for creating the platform was very tight, which meant that we had to work quickly and efficiently. This required us to prioritize tasks and focus on the most critical components of the platform to ensure that we could launch the MVP within the given timeframe. | |
| Technical Challenges: Building a platform that utilizes NFTs on the blockchain for betting purposes requires a deep understanding of the technology. Additionally, we needed to integrate smart contracts to manage the funds within the NFT marketplace, which posed technical challenges. | |
| Managing Funds: Creating a platform that involves betting requires an innovative approach to manage the funds of the platform within an NFT marketplace. We had to come up with creative ideas to manage funds such as accepting the sellers' margin as a listing fee, which presented several challenges. | |
| Adapting Existing Code: To meet the tight timeline, we had to adopt an existing generic NFT marketplace code quickly. Adapting existing code to fit the requirements of our project requires deep knowledge of the code and the ability to modify it quickly and accurately. | |
| Despite these challenges, we were able to overcome them and create a betting platform that uses NFTs on the blockchain. We developed creative solutions for managing funds within the platform, and we adapted existing code to fit the needs of our project. The result was the BetNFT platform, which offers users an innovative way to engage in betting using NFTs on the blockchain. | |
| " | |
| "The successful implementation of the Flow SDK proved challenging due to a bug, but the issue was resolved in a subsequent update. Developing the point tracking and exchange systems also presented challenges, which were successfully overcome. Although a functional Dapper wallet was not secured until late in the development process, we have since obtained one and intend to integrate it into the final release. Our goal is to make Eat The Beat available on a variety of platforms, including mobile devices, Web3 WebGL platforms, and established platforms such as Monaverse, Spatial, and VR Chat. While we plan to incorporate the Dapper Wallet for the Flow Mainnet into our future builds, we will use the Blocto wallet to interact with the Flow Blockchain if necessary. | |
| The game is currently in a functional state and can be downloaded from the GitHub Repository. We are still working to finalize certain aspects of the game before its release, but we encourage interested parties to download and play the game. Please note that a known bug currently exists, which results in the points counter displaying only ""Points."" To resolve this issue, users should navigate to Assets\Dance Game\Scripts\Visual\Counter HUD and Counter HUD 1, open the script graph, and change the ""Points"" value from float to integer on both Counter HUD and Counter HUD 1. We are actively working to address this issue and anticipate that it will be resolved within the coming weeks." | |
| We ran into issues getting the private CloudKit database and iCloud keychain to sync properly, but by far the biggest challenge was re-writing a majority of the swift transactions for varies services on the Flow Blockchain we are integrating (Find, Float, NFT Catalog, etc). The decoder in the Flow-Swift library has never handled dictionaries verry well and requires re-write (almost) any cadence script that return a dictionary so that it return an array instead. This alone prevented us from completing the project on time | |
| "Creating a shared account can be difficult because it requires coordination between multiple parties, who must agree on the terms of access and use of the account. Designing a signature scheme that satisfies all parties' security requirements can also be challenging, as different parties may have different security needs or preferences. Additionally, getting signatures from the wallets can be tricky, as it may require the use of hacky methods to access the necessary keys. | |
| Notifying the other account holder that there is a pending transaction can also be a challenge, especially if the parties are in different time zones or use different communication channels. Finally, calculating the exact transaction time can be difficult, as it depends on factors such as network congestion and the order in which signatures are received. All of these difficulties highlight the need for careful planning and coordination when setting up shared accounts and multi-signature schemes. | |
| " | |
| - Enable web2 services to web3 with less code changes | |
| Cadence and resource storage is a whole paradigm shift. | |
| The challenges faced were IPFS being very slow; we used a pinning service pinata which pinned the IPFS and loaded it much faster. And for the NFT collection, we needed the info of all the NFTs minted but were not able to get it; we found a blockchain indexer can do the job. And threejs load problem which we fixed using instancedMesh. | |
| "Developing a mobile application from scratch is never an easy task, and when it comes to blockchain technology, there is even more complexity involved. | |
| One of the main challenges was the lack of resources available for Flutter and blockchain, as the technology is relatively new to the mobile app market. We had to do a lot of research and development in order to ensure that our project would be successful. | |
| Another problem we ran into was creating a user-friendly, elegant, and simple UI. This took a lot of creative effort and trial and error, but we eventually managed to come up with a solution that was satisfactory. | |
| Finally, we had to manually configure many aspects of Flow Chain due to the limited API and SDK resources available." | |
| "Although there was relevant documentation, I felt like it was scattered across multiple locations. | |
| But I had a very good experience with Flow Playground. It really made it very easy to build the contracts and transactions and test them out and demo them very easily. | |
| I'm full time working professional, and I hacked this project last weekend (over a span of 2 days). It was only possible because of the Flow Playground. Great job on that!! " | |
| The biggest challenge was to try and use the flow test js framework for smart contracts. I still didn't solve this. Blocto was challenging for me to get to work. But I tested around with accessNode.api and it ended up working. Uploading to IPFS was very new to me and I had some challenges with it but it was also a good learning experience on how distributed storage works. | |
| "1. ""We started off with a bit of a disadvantage, as we joined the project a bit later and had to catch up with all the tutorials during the prototype development phase."" | |
| 2. ""As this was our first smart contract project, we had to learn both how to create a smart contract and how to do it using the Cadence language."" | |
| 3. ""The hackathon was scheduled during the week, so we had to manage the development while juggling our day jobs."" | |
| 4. ""Initially, we started developing the app using Flutter. However, since the SDK was not available on Flutter, we had to switch to Swift."" | |
| 5. ""We encountered some challenges with the Swift library, particularly with the use of Combine, which we were not familiar with. We sought help from the community and other members of Flow, and had to learn how to implement it.""" | |
| "Building both a game from scratch as well as a web3 solution in a single week was a monumental task for only two people, we used an AI art assistant to ease the burden of raw output (notably with character illustrations which were then touched up by our artist) so that it was possible to meet the hackathon deadline, this was important because collecting characters is the core mechanic of all mainstream appeal mobile gacha games. | |
| To efficiently make the best use of our time between both game and Flow contract development we chose to get the game to bare MVP functionality, the core gameplay is there but outside of that a lot of extended functionality including multiplayer is currently missing but planned. | |
| We did this because we didn't have any prior experience building on Flow or writing Cadence and wanted to make sure we could integrate our game into Flow within the time limit, there was a learning curve as most documentation was in the form of video tutorials or articles and it was difficult to find technical reference. | |
| We chose Unity as our game engine due to it having the Flow SDK ready to go, as well as it being the most familiar for prototyping mobile games, but we also found near the end of the sprint we were unable to test anything live because the Flow-Unity SDK only supports emulation for blockchain testing " | |
| "### Function No.1 | |
| This bag is available without all the complex terms or procedures | |
| that you NORMALLY need for Wallet. | |
| Creating a bag account can be done with a few clicks | |
| with your SNS account or email address. | |
| You don't have to remember a spare password or mnemonic. | |
| The security is guaranteed by a secret key | |
| using Magic Auth by Magic Labs, | |
| and it will be safely encrypted by using Cloud HSM. | |
| ### Function No.2 | |
| There is a Japanese real-world culture | |
| that fans decorate their bags with merch, | |
| which is known as “Ita-bag”. | |
| Not only can our bag store NFTs, | |
| but also decoratable with NFTs, | |
| just like you would customize your own bag in real life. | |
| On our demo version, merch are materialized in 3D space | |
| and can be placed anywhere in any way you like | |
| on your smartphone or PC browser using WebGL. | |
| ### Function No.3 | |
| Users can make multiple bags, | |
| so it's possible to have different bags | |
| for different genres of digital merch. | |
| In addition to a bag used as Wallet, | |
| a collection to store digital merch is also available as a NFT, | |
| and all of those are what we call “BAG”. | |
| Users can present bags to each other together | |
| with the digital merch inside, | |
| and this is how we offer the unique composability of the Flow blockchain. " | |
| "As part of the Flow hackathon's development process, I encountered the following challenges during the project build process. | |
| **Flow blockchain setup**: During this process, connecting the front end with capabilities and calling specific functions was one of the biggest challenges. Building flow capabilities that call specific contract features caused several back and forth in my design decisions. Building logic to update contract-specific needed to be clarified, and took time to figure out when interacting between NFT, Collection, and other resources. | |
| **Minting resources that own other resources**: I needed to save the main Quest resource and add additional resources for Quest Actions. I was able to get one to one relationship, but I need to get one quest to many Quest Actions. | |
| **Time Management**: I needed more time; although I had a good start to an idea attempting to implement all the functions and capabilities during a 2 week sprint proved challenging. It was a combination of learning and executing to build each feature. It came down to building a proof of concept highlighting idea concepts." | |
| "First time using React and Vercel. First time trying to develop in web3. | |
| Solo hacking with fulltime work." | |
| "- As a web2 mobile developer, I am always eager to develop user-friendly mobile products in the web3 field as well. While participating in the Flow Hackathon, I chose the Android platform among hybrid, iOS, and aOS as I was only given a short period of time. The first challenge was that there was no Android SDK to refer to. Even the most basic login for all apps was not easy. It took me a while to realize that the officially supported SDK from Flow was quite outdated, and it wasn't documented anywhere, but rather annotated by a random developer like me in the code. That’s why I spent a long time thinking about things I wish I had known beforehand. Not just the wallet integration but putting social login took some time as well. | |
| In addition, there were very few mobile native SDKs supported, so I wish more diverse SDKs can be supported in the future, including third parties. For iOS, there was a sample code, but the app crashed immediately after I booted, so it wasn't really helpful. So the challenge was that there was no reference at all. | |
| - When trying to connect the wallet with the app, at first, I tried to do wallet discovery and transaction signing in a webpage like I used to do in Ethereum development, but it was a new challenge for me as a developer to see the flow's unique wallet less onboarding and implement hybrid custody auth-based on it, and to use FCL.js for the wallet linking part to connect the user's wallet. Since it was a new approach, it took a lot of research time in the beginning, but in the end, it was a good hackathon experience because I was able to develop a final product that is secure and convenient user experience in terms of UX." | |
| Nothing specific, but bugs in general... | |
| "The biggest hurdle we faced was figuring out how to reserve collectibles. Our initial idea was to create a simple skill-based game called ""Book Cricket"" which users would play. On scoring the required number of runs, they would be eligible to buy a CryptoCricketer NFT. We went down a rabbit hole figuring out reservations, expiry, scoring algorithms, price points, and a host of other product related issues. | |
| From a technical standpoint, we were able to solve for a onboarding users using social login and on successful registration, we created a custodial wallet leveraging the Flow Custodial Wallet. We further wrote smart contracts and exposed a REST interface by storing cadence scripts in the database and loading them dynamically. The scripts interacted with the smart contract to create an account, mint NFT, transfer NFT, and fetch all NFTs associated with a collection. We further formatted the metadata returned in a consumable format similar to Alchemy APIs. | |
| We had the most fun expanding on the work done in the Flow Wallet API by automatically polling for transaction completion and notifying the caller via a webhook or pub-sub mechanism. This feature will allow us to know when a transaction status and charge the payment method successfully. | |
| A last minute feature which we rushed to complete was allowing users to create a digital collectible and mint it from within the app with a UX similar to TikTok. " | |
| We had to build a backend infra to call the smart contract to build the mobile app. | |
| No such bugs. | |
| "### Challenges | |
| Building a dapp on Flow chain was an exciting but challenging task for our team. It was our first time writing smart contracts in Cadence, and it was overwhelming at first. We spent a significant amount of time studying the documentation, learning the syntax, and experimenting with different approaches to ensure we had a solid understanding of the language. Despite the initial difficulties, we persisted, and eventually, we were able to write efficient and robust smart contracts for our decentralized blogging infrastructure. | |
| - One of the biggest hurdles we encountered was that none of the event indexers we tried were working correctly. This was a problem as we needed to store and retrieve data efficiently. To address this, we decided to build a custom backend that could support our specific needs. This proved to be a challenging task, but our team was up to the challenge, and we were able to create a scalable and reliable solution that met our requirements. | |
| - Additionally, we faced a tight deadline. With only eight to nine days to complete the project, it seemed like an insurmountable task. We also had prior commitments that delayed our start, so we were left with only a few days to build the entire product from scratch. Despite these challenges, we remained focused and determined, working long hours to ensure we met the deadline. | |
| Overall, we're proud of what we have accomplished, and we're confident that our solution will revolutionize the way creators publish and monetize their content. Our team has demonstrated our ability to tackle complex problems and deliver innovative solutions in a tight timeline. We look forward to continuing our journey and contributing to the growth and evolution of the decentralized web. | |
| " | |
| "## Relatively short hackathon period | |
| Thanks for extending 48 hours more. It helped to get things together to make it on time for this submission. | |
| ## Over-scoping | |
| Over-scoping of project has caused more anxiety for us. We calmed ourselves down to focus on the most impactful featureset to build | |
| ## Contract development | |
| We were at first scared about contract development, assuming it would be challenging like other chains in addition to picking up a new contract language. We kept on spending time to learn however, the key to conquering our fear is to actually start writing Cadence. The dev UX has been a lot better than other chains. So don't fear too much, just get started." | |
| Fetching data | |
| "* Custodial wallets in Blockchain are not easy to use for lots of Web2 people | |
| * Billions of dollars have been lost from hot wallets every year and there is no way a user can recover the amount. | |
| * Lots of user's wallets got compromised in making a transaction and interacting with suspicious websites | |
| * 70% of them fear that their wallet will be compromised | |
| * A web2-like easy-to-use interface by providing maximum security to use wallet. | |
| * Last but not least, awesome mobile-centric UI/UX makes Flux wallet more awesome. | |
| * Everyone can not get cold wallets as a user will need to buy around $50 to $200. | |
| * Users usually keep only 10-15% of their portfolio on web-based wallets because they don’t find them safe. | |
| Implementation of Flow Wallet API | |
| At first, I was trying to build the wallet implementation using Flow Wallet API. I faced lots of difficulty in implementing the account creation on the docker setup it provided. I have struggled for weeks to implement it. The codebase of Flow Wallet API is in Go programming language and I never coded on Go (so it is quite tough for me to make changes there). | |
| Implementation of Niftory API | |
| Recently I got to know about Niftory for wallet creation and I faced some difficulty in setting up the GraphQL server. But finally, I solved the issue and set up the server. | |
| Sending Transactions | |
| I have faced difficulty in implementing wallet transactions after wallet creation in sending Flow Token using flow API. | |
| " | |
| "Although we wanted to support DALL-E 2, unfortunately, it is not currently open source and OpenAI has not yet released an API for it. While we explored potential workarounds, we ultimately decided to prioritize our commitment to complying with all relevant terms of service. Instead, we doubled down on Stable Diffusion, which is entirely open source, to provide our users with the best experience possible. | |
| " | |
| "Being a newbie to smart contracts, Cadence has an excellent user experience and apps like PlayGround help a lot. | |
| One of the problems that took me longer than one thinks, was giving closure to the MVP. Being able to separate what is necessary for the Core Flow of the app and not waste time on things that can be improved in the future." | |
| ✅Trying to query data from graphQL because there was not much documentation about this, however, after further research it was more straightforward. | |
| "The main challenge we ran into during the project was the inability to properly utilize a users TopShot collection within our application. Our app was only connected to our local blockchain so there was no way to pull the users mainnet TopShot collection. I believe a workaround could have been importing the TopShot contracts onto the local blockchain and creating the collections that way but for times sake we refrained from doing so. Our workaround was to first connect our app to the Flow mainnet, then using the publicly available TopShot scripts, we logged in with our Dapper Wallet and called the script to get all the IDs of a users collection. We took that information and stored it in a static json file so that we could load it seamlessly when developing. Ideally, we would have liked to get it working with the users collection but we felt this was the easiest route for now. We also wanted to use the NFT IDs that we stored to display an image of the TopShot moment but ran into some issues with load times so we decided against using it. | |
| There were a few features missing that we would have liked to add namely a payment feature for joining a league. The idea was that the league creator could also add an entry fee and in order to join the league, the entry fee would have to be paid along with submitting a team to compete with in that league. The payment would have been in FLOW or FUSD as those would have been the two simplest to implement. We didn't work around this, instead we just let joining a league be free. | |
| We also wanted to tokenize the League resource in our cadence smart contract. The plan was that the user who was deemed to be the winner at the end of the week would then become the owner of the League resource granting them complete access to it. Tokenizing the league is something we were really high on as it could have been an extra incentive for competing and winning the league. | |
| We Love Flow and We Will Continue to Build!" | |
| We have a completely async architecture so we rely on Graffle to update us with smart contract event data, since it is super slow, some of the interaction in our app may seem very delayed. This can be solved by using a personal access node and eventlistener or by going to mainnet (Graffle is ususally faster there). | |
| "During the development of our project, we encountered several challenges. As a team, we were new to Flow and Cadence, which resulted in a steep learning curve for us as we worked to develop the app. We also had to spend a significant amount of time understanding the Flow SDKs and how to integrate them into our project. | |
| Another challenge we faced was developing an intuitive design and user interface for our app. We wanted to ensure that the app was easy to use and navigate, which required a lot of time and effort. | |
| One of the major challenges was accessing and filtering the relevant data for LaLiga Golazos NFTs, which required us to explore various APIs and data sources to ensure we had access to the latest and most relevant information. Initially, we tried accessing the data through the Flipside Crypto provider, but it only supported Top Shots and NFT All Day. So we had to write custom cadence scripts to fetch the data, understand it, and present it in the UI. Despite these challenges, we remained committed to delivering a high-quality and user-friendly app." | |
| "Onboarding end-user, like listeners and fans, is the most struggle part. Even though we did streamline podcasters’ process of converting their audio content into NFT, released it on Primary Marketplace, post on news media, it is still hard to carry a large number of non-blockchain users to join in one night. To overcome this, we must emphasize every meaningful interaction between podcasters and fans. For example, stan’s avatar will show in the podcaster’s 3D space in Mindtrix Verse. Also, the podcasters’ show and link will appear on the map as a launchpad journey, and fans can free claim a POAP of the launchpad event. Therefore, Mindtrix Verse is our undergoing solution to improve engagements. | |
| For development, Walletless Onboarding is the tough one for new Web3 developers like us. We separate the building process into parts: getting SSO info from the front end, generating key pairs, multisign from the backend, and sending transactions of creating a child account with the emulator. Though we successfully connected the individual parts, we still suffer from the last one: getting the created child account’s address. We are yet to develop a feature to get the real-time on-chain address from the off-chain service as soon as the child account is created. Currently, we deploy a webhook to receive event indexing, and the user will wait for 10 sec to fetch their child account info. Furthermore, we understand Walletless Onboarding aims to abstract payment flow; however, it’s difficult for us to find an online credit card payment provider for NFT purchasing without KYC. A possible way we may try to sell an IRL product and then mint the NFT to users as a digital receipt. For now, we recommend the user utilize Credit Card Payment with Dapper Wallet." | |
| "The contract functionality and the learning curve on The Flow environment took us longer but we were able to learn a lot and enjoy the process. We will continue working and learning with the Flow Network. | |
| " | |
| "I'm new in the Flow blockchain, so have to learn a lot during building & IRL Sessions. | |
| " | |
| The main challenge for the app has been quickly learning how Flow works and how to interact with the chain using CLI and JavaScript. Although it took a couple of days to learn the technology behind both Circle and Flow, it is clear that the combination of both has incredible potential and a bright future for digital collectibles. | |
| "- Understanding the Flow of Smart contract | |
| We implement the basic dynamic NFT system on Flow Chain. | |
| - Work with Flow Unity SDK | |
| We make it work on the emulator. | |
| - Hybrid Custody | |
| We do not have enough time to solve Social Login using Hybrid Custody of Flow Blockchain. | |
| " | |
| "# Challenges | |
| This was my first time building for native iOS using Swift. I was hoping to do React Native but FCL doesn't have a React Native SDK at the time of writing. Learning Swift and iOS was a major task. Learning Flow and Cadence was also a challenge. I referenced the Monster Maker sample project and the LearnWeb3 flow course to assist, but it wasn't a lot of time to get super well versed. | |
| # Limitations | |
| Certain functionalities in the app are limited, which I would have loved to extend if I had more time. | |
| 1. We wanted to integrate with all Dapper Sports projects, but were only able to integrate with NBA TopShot. After a long thread in the Flow Discord, someone from the Flowty team hooked me up with an official testnet TopShot moment but did not have any of the other projects' NFTs available. However, they should all be similar to integrate. | |
| 2. Messages are currently stored on Firebase in a centralized database. In the future, I'd like to expand this to something like Arweave, IPFS, or Ceramic Network to have a decentralized data store for messages. | |
| 3. Since it was my first time building using Swift, certain functionalities are definitely a bit hacky, but I have been able to learn a lot of SwiftUI over the last week or so, and can work on making it better. | |
| 4. There are some UI issues that I haven't been able to resolve - messages sometime don't properly align to left/right directions properly and it's probably a mistake with some conditional statements somewhere." | |
| Implementing Walletless-onboarding, signing transactions from our server with an authorization function brought up weird errors with Flow's access node API. Generating images from text. | |
| HELLO WORLD | |
| Understanding new mechanism like storage, resources. Principals of borrowing, lending, destruction of resources and understanding of new language principals in general. Short time frame and some casual debugging situations regarding applications builds. | |
| "We are new to the Flow Block chain are so we ran into some issues while the duration of this project, | |
| It took major time to resolve erros in cadence due to lack of proper error messages and documentation regarding the errors. | |
| Flow Playground - We also faced problems with the flow playground as it puts a limit on the number of contracts that can be deployed at once. This posed problems when we wanted to interact with existing contracts provided by increment.fi | |
| Wallets - We had to spend much of our initial time to find a suitable wallet, as most wallets did not provide private keys. We required private keys to deploy contract to testnet. | |
| Flow CLI - The documentation for the flow cli was confusing and it did not provide any information or examples for testnet. | |
| Increment.Fi - The increment.fi contracts are not documented for its cadence functions to use easily. - We face major issue to do the swap transaction while passing an argument requiring the unix timestamp. Due to this swapping the tokens were not working." | |
| As web developers we found it hard to adopt to the web3 enviroinment,and as newbies to web3 we started it off with solidity and we faced difficulty in shifting to flow through cadence. | |
| ... | |
| I'm new to front end so building the React portion has been difficult. Dependencies are really hard to keep track! I low Cadence and I'm learning so much right now. The issue I run into is finding CSS that works well for my designs. CSS is hard! I also ran into challenges with my front end minting button for Ai for Kids, but still working on it! | |
| The web3 sign-in functionality got broken all of a sudden due to the external dependency issues with Webpack 5 Polyfills and because of this, we couldn't even demonstrate the functionality at its fullest in the MVP. | |
| "Parity between SDKs. FCL does not support executing a script on a specific block ID / height, while the Go SDK does. Had we known this, we would have chosen the Go SDK, for the indexer module. | |
| LaligaGolazos does not have an easy way to correlate an NFT ID with its edition and serial number. There is an event however, which includes all these three numerical values. | |
| Querying events from past sporks is not trivial. This is often needed in cases such as above, where some knowledge base can only be built using events." | |
| As a solo hacker, I needed more time to team up, so I had to work alone. I was totally out of resources, so I had to be efficient as possible. When learning about the new concept, I needed to become more familiar with Flow blockchain as I am only used to solidity. However, after deep diving into various developer docs released by the team and developers within the ecosystem, it was helpful to learn about Cadence quickly. Despite of different account structures of Ethereum, I am happy that I could finish making a demo of the new authentication system to better the previous user's experience. | |
| Building Smart Contracts on Cadence was quite difficult coming from a Solidity background. We initially thought of building a Wallet Manager App but realized there is a learning curve for new devs coming to Cadence & Flow. So we built Gandalf to make lives of devs easier who want to build Dapps who need to store data securely with traceable & verifiable encryption methods. |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment