Dapper Labs, the company behind CryptoKitties, NBA Top Shot, NFL All Day, UFC Strike and the Flow blockchain, uses blockchain technology to bring NFTs and new forms of digital engagement to fans around the world, paving the way to a more open and inclusive digital world starting with games and entertainment. Since it was founded in 2018, Dapper Labs has given consumer enthusiasts a real stake in the game by bringing them closer to the brands they love, building engaged and exciting communities for them to contribute to, and producing new pathways for them to become creators themselves. Dapper Labs' current studio partners include the NBA, NBPA, WNBA, WNBPA, LaLiga, NFL, NFLPA, Warner Music Group, Ubisoft, Genies, and UFC. We have raised over $600M from leading and notable investors including Andreessen Horowitz, Coatue, Union Square Ventures, Venrock, Google Ventures (GV), Samsung, and the founders of Dreamworks, Reddit, Coinbase, Zynga, and AngelList, among others. Dapper Labs is accelerating the move to Web3 by building new apps and platforms that enable great user experiences while being accessible to hundreds of millions of fans of organizations like the NBA and NFL, for example. We’re ready to empower even more to bring mainstream-ready user experiences and scale to web3 applications.

Dapper Labs

In this article, we outline the evolution of Dapper Labs, from just a simple NFT project to one of the leaders in the web3 space. Roham Gharegozlou, the Co-Founder and CEO of Dapper Labs, has developed one of the most noteworthy blockchain-based companies by creating an NFT game called in 2017 to now running NFT projects with some of the biggest brands in the world. Cryptokitties Cryptokitties started as a project by Axiom Zen, a Software Development Company. Unlike many other popular projects today, Cryptokitties is not an NFT collection that consists of a limited number of digital art. NFT Cryptokitties is a game-type setting where users can purchase NFTs in the form of virtual cats. They can use their cats to breed new ones and possibly sell them to other players in the game. This presented some unique challenges to Roham and the other developers who wanted to scale Cryptokitties. Ethereum posed some significant challenges to the growth of the game. As Cryptokitties scaled, the transactions became increasingly difficult to execute quickly. As traffic increased, so did the Ethereum Gas prices. The slower speed and high cost of Cryptokitties resulted in the loss of players. To scale projects like Cryptokitties, an excellent User Experience was essential. The team behind Cryptokitties realized they would need to create a blockchain that reduces energy consumption with a more elevated speed to ensure the User Experience is great for their future projects. Flow is a blockchain that came into being due to issues in the Ethereum blockchain. Ethereum, like Bitcoin, currently uses a consensus protocol called Proof of Work. It is a protocol that uses a tremendous amount of energy, and it only increases as more people join in. For a platform like Cryptokitties, which used 10 percent of Ethereum’s traffic at one point, the Proof of Work protocol had become unfeasible for players. Moreover, Ethereum’s smart contracts are immutable. Dapper Labs realized that smart contracts should be changeable to build the kind of projects they wanted to. Flow blockchain was built upon an alternative consensus protocol, Proof of Stake. Proof of Stake is a cheaper alternative when scaling NFT game projects like Cryptokitties and NBA Top Shot. Proof of Stake does not require validators to purchase specialized equipment or use large amounts of energy. Moreover, smart contracts in Flow (unlike Ethereum) are changeable. These changes were essential to building projects like NBA Top Shot and NFL All Day. Flow has now become the default blockchain for all Dapper Labs’ projects. Today, Dapper’s with NBA, NFL, UFC, and other external projects are built on Flow. These projects attracted a considerable amount of attention from investors. These smart contracts can continue to change as needed. Today, Dapper Labs is backed by the likes of Coinbase Ventures, Warner Music Group, and Samsung Next. It will be interesting to see how Dapper Labs will continue to develop its projects in this space and how external developers embrace Flow blockchain. NFT projects This article was first published on the metaverse insider by Wazarat Ali Hussain

A Brief History of Dapper Labs

Here is a story that we all know, CryptoKitties caused a viral sensation in 2017 and sent prices for some kittens well into the six figures. What’s more, the game clogged up the entire Ethereum Network delaying transactions and causing a pile-up of unprocessed transactions. As such, the developers behind CryptoKitties, Dapper Labs, created a new blockchain specifically designed for blockchain-based games and digital collectibles (also known as a non-fungible token, NFT). With NFT, every asset on the blockchain is unique and is therefore not replicable. This unique aspect is written inside the metadata of the token itself and can be seen as a permanent, unalterable certificate of authenticity. NFT can solve the unfair status quo that game companies control access to digital items. Imagine this: you buy character skins and emojis from the world’s most popular game, Fortnite, but you do not really own these items. If you get banned for whatever reasons, the company can drive you off the platform and take your items and account away from you. Dapper Labs has teamed up with NBA (National Basketball Association) and NBPA (National Basketball Players Association) to create NBA Top Shot, a fully-licensed NBA experience for collectors and gamers. For the first time ever, NBA fans can truly own a piece of the action and trade with friends in a new kind of hoops economy. Roham Gharegozlou, CEO of Flow, believes that just like the PC era, entertainment and games are also leading the large-scale popularization and application of blockchain technology. This was the original intention of Dapper Labs when it developed CryptoKitties on Ethereum. At the end of 2017, CryptoKitties became the top-selling DApp, with a total sales volume of 40 million U.S. dollars. The Flow-based NBA Top Shot absorbed the experience from CryptoKtties and got rid of its limitations on the Ethereum Network. In just 3 months, NBA Top Shot’s transactions between users have exceeded 21 million US dollars, and the user retention rate is as high as 75%. In addition to the NBA Top Shot, Flow hopes to support more applications to succeed. Therefore, it is promoting a healthy and prosperous ecosystem built by developers, creators, FLOW token holders, and network operators. In addition to Flow, it has a lot of development tools and libraries, such as Flow Playground, Flow SDK, VS Code Extension, etc. More importantly, Flow’s smart contracts can be upgraded, and developers do not need to completely abandon the old contracts. The nature of blockchain is established on a foundation of trust and permissionless. Creators, developers, and users do not need anyone’s approval to do their own things. This means that one can unleash their talents without any restriction. In the world of user-generated content (UGC), Dapper Lab and its Flow project create a blockchain ecosystem with a solid foundation, cutting-edge concepts, and user-friendly experiences. It narrows the gap between real-world use cases and blockchain technology to provide more users with convenient and friendly ways to use decentralized applications. Also published at https://medium.com/block-insight/to-flow-or-not-to-flow-a6ff0a4ffd26

The Developers Behind CryptoKitties Create Dapper Labs to Change The Gaming Industry & Blockchain

The ascent of Web3 as the next frontier in internet development has become a consensus, and the question now arises: how will these traditional Web2 giants play with NFTs, the cornerstone of Web3? Web3 has seen an influx of new players, with many brands that once battled in the Web2 arena now strategically positioning themselves in Web3. These seasoned Web2 brands, with their extensive experience, bring forth innovative marketing strategies upon entering Web3. The Increasing Trend of Web2 Brands Entering Web3 Can Be Attributed to Several Factors: Rising Consumer Expectations for Personalization Modern consumers are no longer satisfied with traditional goods and services; they seek personalized and unique experiences. NFTs, as representatives of digital assets, offer brands an excellent tool to achieve this level of personalization. Building Genuine, Multidimensional Business Experiences through Ownership Web3, built on blockchain technology, provides users with true ownership. This decentralized characteristic fosters diverse and highly interactive business experiences, deeply engaging users in a multidimensional manner. Acknowledging Web3 as the upcoming trend in internet development, Web2 brands understand the necessity of seizing this opportunity. Web3 presents a unique chance for these brands to evolve and stay relevant in the ever-changing digital landscape. Entering Web3 often starts with taking the first step, and for many, the preferred choice is through NFTs. Web3 Gateway: NFT NFT, as a crucial component of Web3 development, is considered the primary channel and vehicle for the future of the Web3 world. Several renowned brands have chosen NFT as the gateway to enter Web3, demonstrating its significance in this domain: Disney: Disney Pinnacle In November 2023, Disney announced a collaboration with NFT IP development company Dapper Labs to launch the NFT platform "Disney Pinnacle." Iconic characters from Star Wars and Pixar studios will be presented in the form of NFTs. Starbucks: Odyssey Program Starbucks launched the "Odyssey" initiative, utilizing NFTs to reshape its membership system and strengthen brand influence. Trip: Trekki NFT Project Backed by Trip, the NFT project Trekki signifies not only owning a digital travel companion but also enjoying Trip coins, premium memberships, travel AI assistants, and other benefits. From the current entry of Web2 brands into the news, it is evident that companies in the fast-moving consumer goods, content culture, and service sectors are actively embracing Web3 with a rapid response. Brands with native philosophies and audience alignment with Web3 culture, particularly those using NFT as an entry point, are more readily accepted. Ownership & Membership System Establishment Granting users true ownership of digital assets, brands leverage NFTs to authenticate and safeguard their digital content or offer exclusive services to users. The tangible form of NFTs makes it easy for brands to construct user identity and loyalty systems. Uniqueness and Scarcity The uniqueness and limited quantity of NFTs make users more receptive to and appreciative of these digital assets. This underscores and signifies the identity and status of each NFT holder, elevating user trust and a sense of belonging to the brand. Weak Financial Attributes of NFTs Compared to other cryptographic assets, NFTs primarily function as digital collectibles with relatively weak financial attributes. This characteristic avoids compliance issues, making NFTs more widely accepted by a diverse user base. Brand Innovation and Trend Embrace Introducing NFTs is not merely a business strategy but also a way for brands to demonstrate innovation and embrace new technologies and trends, showcasing their commitment to staying at the forefront of the industry. NFT Marketing Strategies Many industry giants have embraced Web3, starting with NFTs. How do they execute NFT marketing strategies? NFT & Philanthropy Integrating NFTs with philanthropy not only showcases a brand's social responsibility but also establishes a positive image, resonating with core values tied to charitable causes. Associating NFT projects with specific social issues helps attract target audiences, and philanthropic actions often gain widespread media attention. Importantly, philanthropic NFT projects tend to navigate regulatory scrutiny more compliantly, providing brands with a safer marketing space. Luxury skincare brand La Prairie collaborates with digital artist Carla Chan for its inaugural NFT art series, "Space Beyond." The NFTs, with 365+1 versions generated in real-time based on weather and population data, will be exhibited at FRIEZE in New York on May 18, with proceeds dedicated to glacier conservation worldwide. NFT & Metaverse The application of NFTs in the metaverse is a common strategy in NFT marketing. The metaverse offers a virtual world that provides brands with a broader display space, making NFT presentations more vivid. Social interactivity creates additional avenues for NFT sharing and promotion among users. Furthermore, the metaverse opens up innovative possibilities for brands, allowing them to expand NFT applications through virtual events, exhibitions, and other formats, bringing more creativity and imaginative space to digital marketing. Louis Vuitton introduces the commemorative game "Louis: The Game," featuring 30 NFT rewards, including 10 designs by digital artist Beeple. Cooperating with Native Web3 Entities From the above examples of NFT marketing, it can be observed that many major players prefer to collaborate with native Web3 entities when designing NFTs. These entities can be individual digital artists or projects. Trekki NFT, in order to expand its audience, launched a joint campaign with a Web3 growth platform. The benefits of collaborating with such platforms include: The channels are highly vertical, providing access to the Web3 market. Specialized Channels: Growth platforms have a substantial user base with a high level of awareness, reducing the need for extensive user education. Large User Base: Various gameplay options cover different stages of the user lifecycle, from acquiring users during the initial phase of the NFT project to user conversion and retention, accelerating the project's operational pace. Diverse Gameplay Across User Lifecycle: Trekki NFT, a project supported by a leading Web2 brand, has achieved tremendous success in the Web3 space, with a total issuance of 10,000 NFTs and a community subscription rate reaching 100%. Collaborating with Web3 projects in marketing strategies facilitates convenient user participation in the NFT market, fostering broader dissemination of NFTs. Brands can leverage the technological innovations of Web3 projects to enhance NFTs with unique features and gameplay, ultimately enriching the user experience. Challenges and Prospects While major players entering Web3 through NFTs have achieved initial success, deeper marketing efforts have exposed some issues: Limited Sustainability The NFT market is still in its early stages, lacking mature standards and regulations. Brands issuing NFTs often fail to implement long-term maintenance and empowerment plans, leading to the difficulty of sustaining the value and significance of NFTs. User interest and demand for NFTs may fluctuate over time, posing challenges to their circulation and usage. Reputation Challenges Brands emphasize the identity and cultural aspects of NFTs over their financial attributes, causing users to perceive NFTs as symbolic and virtual rather than practical. This perception diminishes the social value and influence of NFTs. While acknowledging the challenges in NFT marketing, it's undeniable that the strategies employed by Web2 brands entering Web3 have shown initial effectiveness. The integration of traditional brand marketing from the internet era with Web3 technology is gradually taking shape. Looking ahead, as more projects and users enter the space, the application scope of NFTs will expand, and initial marketing challenges will be addressed. In this evolving marketing battleground that combines Web3, brands, and projects deeply immersed in the field are actively exploring alternative marketing approaches to enhance market share. For projects outside this landscape, leveraging the marketing methods discussed earlier could be a strategic move, seizing opportunities before the marketing battlefield expands and securing a position. Also published here

Web3 Battle Heats Up: How Web2 Giants Will Change Their Marketing Strategies in This New Game

Flow is a permissionless layer-1 blockchain built to support the high-scale use cases of games, virtual worlds, and the digital assets that power them. The blockchain was created by the team behind Cryptokitties, Dapper Labs, and NBA Top Shot. One core attribute that differentiates Flow from the other blockchains is its way of providing to objects within the blockchain. Fine-grained access is a new method of providing access to users that follows the principle of least privilege. This makes it highly secure and fault-resistant. Flow is one of the unique blockchains to have this, as it is built on the fundamentals of Capability-based security. fine-grained permissions But how does this help you as a developer? If you’re writing smart contracts, then you likely have to regularly define access to objects and functions within your contract. Understanding the different types of access better will help you to define access types in code more accurately. This will allow you to write highly secure and efficient smart contracts. Let’s dive in. Understanding fine-grained permissions As opposed to Role-based access control (RBAC), where permissions are defined loosely for every role and not specifically for every individual, fine-grained permissions allow developers to define permissions for objects at the lowest level. This allows permissions to be defined for every object. This also allows you to add new permissions types, such as time-expiry and geography-based permissions. Let’s understand the core principle behind fine-grained permissions. The principle of least privilege The concept of least privilege means that in a computing environment, any module (such as a process, a user, or a programmer) only has the necessary access that it needs to do its specific job. Any other unnecessary permissions for its specific job are either revoked or unavailable. For example, a programmer whose job is to create backups does not need to make user data updates, so it should only have read permissions on the database of users. This principle is the core principle behind fine-grained permissions. Capability-based Security A capability is an unforgeable token of authority. In capability-based authorization, your identity does not matter. If you’ve been sent an access token by the owner/admin that grants you the capability to access a resource and you can execute that capability, then you will have access. Hence, at runtime, the application does not check what your identity is but only that you can access the requested resource. Thus, fine-grained access can be implemented on the foundations of capability-based security. History of fine-grained access In the 1980s, operating systems would define permissions on objects as “read”, “write”, and “execute”. This was called Access Control Lists. In the 1990s, Role-based Access Control was introduced, which allowed you to create groups and assign users to groups. Then, the concepts of attribute-based access control and capability-based access control arrived, which brought fine-grained access into the picture. In the world of blockchains, however, fine-grained access is new and brought by Cadence, the language used to write Flow smart contracts. Fine-grained access in Cadence Cadence, the language used to write flow smart contracts, has built-in special keywords to allow for fine-grained permissions to resources. Below, we dive into the common keywords and the usage of these keywords to provide fine-grained access. The access keywords Flow defines certain keywords, known as access keywords, with different parameters to define the access privileges of a certain resource. Below are the four primary keywords: Pub or access(all) Using this keyword means the declaration is accessible in all scopes. However, this also means that the declaration is not updatable except when you’re updating the value at an index of an array. Pub or access(all) are the least restrictive types of access and should generally be avoided. Below is an example of using the pub keyword: pub contract Car {    pub let carBrand: String    pub let carNameByBrand: {String: String}    pub fun returnCarBrand(): String {        return self.carBrand    }}} Following the above code example, if there’s an object called CarObject of type Car, then the statement below invocation is valid. CarObject.carBrand //Equals the value of greeting in the object The values with access type pub are generally not updatable except when updating the value at a certain index of an array. CarObject.carNameByBrand = {} //Not ValidCarObject.carNameByBrand[“Porsche”] = “Carrera” //Valid access(self) access(self) means that the declaration is only visible in the current and inner scopes. For example, an access(self) field can only be accessed by the functions of the type it is a part of. When using access(self), it is common practice to define setters and getter methods to allow other objects and contracts to access this field. This keyword makes the usage very safe but also restrictive. Below is an example of using access(self): pub contract Car {    access(self) let carBrand: String    access(self) let carNameByBrand: {String: String}    pub fun returnCarBrand(): String {        return self.carBrand    }    pub fun returnCarName(_ brand: String): String? {        return self.carNameByBrand[brand]    }}} access(contract) access(contract) means that the declaration is only accessible in the scope of the contract that defines it. Hence, functions defined in other contracts under the same account or functions defined in contracts under other accounts will not be able to access it. This keyword is unique to Cadence and comes in handy when you have any contract-specific variables you don’t want to expose to other contracts. Below is an example of using the access(contract) keyword: pub contract CarContract {    pub struct Car {        access(contract) var carBrand: String    }    pub fun returnCarBrand(_brand: Car): String {        return Car.carBrand    }}} In the above example, if you have a method in a different contract that has an object of the Car struct, you cannot get the carBrand variable directly. However, you can call the returnCarBrand function to get the value of carBrand. access(account) This keyword means that the declaration is only accessible inside the entire account owned by the current smart contract. Hence, other contracts in the same account can access a variable freely. This type of access is very powerful, allowing you to keep a variable private to your account. You are also able to deploy a smart contract that needs to use the variable in the future, if needed. This way, several contracts in the same account can share information seamlessly with one another, promoting the modularity of code. Below is an example of how to use it: pub contract CarContract {    pub struct Car {        access(account) var carBrand: String    }    pub fun returnCarBrand(_brand: Car): String {        return Car.carBrand    }}} In the above example, if you have a method in a different contract that has an object of the Car struct, you can get the carBrand variable directly. Conclusion The concept of least privilege and capability-based security play a significant role in Flow's precise permissions. The access keywords provide clear definitions of variable and function access, as we have covered in this article. One of the most noteworthy features that fundamentally strengthens the security of the Flow blockchain is its fine-grained access control. Blockchain technology has long been plagued by bugs and hacks, most of which occur because of ill-conceived access controls. However, fine-grained access control provides developers with a remarkable opportunity to effortlessly and smoothly secure their smart contracts. Ultimately, this is what sets Flow apart in the world of blockchain. On the topic of fine-grained permissions, hopefully you found this in-depth exploration valuable and helpful. For more information, refer to the . Or explore the and get some hands-on experience! official documentation Flow Docs

Better Smart Contracts with Fine-Grained Permissions using Cadence

Flow is a permissionless layer-1 blockchain built to support the high-scale use cases of games, virtual worlds, and the digital assets that power them. The blockchain was created by the team behind Cryptokitties, Dapper Labs, and NBA Top Shot. One core attribute that differentiates flow from the other blockchains is its usage of capability-based access control. At its core, capability-based access control creates tokens of authority to give stakeholders selective access to certain resources without sharing everything. But why is this important for you as a Flow developer? With capabilities, you can define a user’s granular-level access privileges. So, if you’re building a music app and want to give the capability to access top playlists to only premium users, you can control that very easily with the built-in capabilities functionality of Flow. ( ) Source What is Blockchain authorization? Blockchain authorization is the methodology by which access to information and execution permissions are granted on a blockchain system. Several operations that a user may need to perform within a blockchain may include the following: Creating new smart contracts Updating smart contract code Executing smart contract functions Being a validator node Updating smart contract data If the methodology used to manage the execute permissions of the above operations is not fault-tolerant, then it could be a huge security risk for the application. There are several major types of authorization that have the same objectives but slightly different implementations. Access Control Lists (ACLs) Access Control Lists (ACLs) refer to the authentication mechanism that works on maintaining individual lists for managing access to different objects. ACLs are like guest lists for a resource. Those participants that are on the guest list of a certain object are allowed to access, and others are not. Role-based access control (RBAC) Role-based access control refers to the idea of assigning permissions to network participants on the basis of their role within an organization. The access rules are mapped to the roles rather than the individual identities. This is the most common form of authorization used in popular products like AWS. Capability-based authorization A capability is an unforgeable token of authority. In Capability-based authorization, your identity does not matter. If you receive an access token from the owner/admin that grants you the capability to access a resource, and you are able to execute that capability, then you will have access. At runtime, the application does not check what your identity is but only that you have the capability to access the requested resource. ACLs versus Capability-based authorization There are certain drawbacks to implementing ACLs, especially in the context of decentralization, which we’ll discuss below. Ambient Authority problem Let’s say that, as a user, you have received several different types of access and privileges to an app on your operating system. At some point, you request the app to fetch certain data for you. You would want to make sure that the app fetches only the data that’s absolutely necessary and doesn’t access anything else. However, in the case of ACL systems, there is no way to make sure this happens since the app has “ambient” authority. This can only be solved by using capability-based security systems. Watch to learn more. this video Confused Deputy problem Let’s say there’s a program A requesting a program B to perform certain actions. There might be instances where only program B has access to perform some of those actions, but program A does not. Program B still performs them because it didn’t double-check. In this case, program B was tricked into misusing its privileges by program A. This can be solved by using capabilities. Watch to learn more. Here’s how the company 25 years ago. this video Tymshare faced this problem ACL attack vector Because ACL lists are usually maintained with a centralized owner, it is prone to malicious updates at any time. Using capabilities takes away the power of performing malicious updates from a centralized owner and hence makes the system secure from the large ACL attack vector. ( ) Source About Capabilities A capability (also known as the ‘key’) is a hash that designates both the resource and access to it. This is also the model implemented in Bitcoin, where “your key is your money,” and in Ethereum, where “your key is gas for EVM computations.” In the Flow blockchain, “your keys are your data,” and hence, data access is controlled directly by keys instead of identities. By tying access to the key, capability-based models push security to the edge, decentralizing large attack vectors. Capabilities also make it very easy to write code that defines security privileges in a granular fashion. There are two major types of capabilities in Flow blockchain: Public capabilities Public capabilities are created using public paths and hence have the domain “public”. After creation, users can access them with authorized accounts (“AuthAccount”) and public accounts (“PublicAccount”). Private capabilities Private capabilities are created using private paths and hence have the domain “private”. After creation, they can only be accessed by authorized accounts (“AuthAccount”) and not by public accounts (“PublicAccount”). 3 Tenets of Capability-based Security — Capability-based security always has an unforgeable key to go with a particular access. This means that just the identity of a participant is not enough to get access. Encryption-based — Capability-based security is totally decentralized. This means that the success of the security system is not dependent on a single owner. Decentralized — It is easier to define fine-grained access to data and resources using capability-based security. Granular Creating a capability in Cadence Cadence is the programming language used to create Flow contracts. Below, we’ll talk about the code used to create capabilities in Cadence. Creating capability using a link function The link function of an authorized account (“AuthAccount”) is used to create a capability. fun link<T: &Any>(_ newCapabilityPath: CapabilityPath, target: Path): Capability<T>? is the public or private path identifying the capability newCapabilityPath is any public, private, or storage path that leads to the object that will provide the function defined by this capability target is the type parameter for the capability type T The above function will: return nil if the link for a given capability path already exists return the capability link if the link doesn’t already exist Removing capability using the unlink function The unlink function of an authorized account (“AuthAccount”) is used to remove a capability. fun unlink(_ path: CapabilityPath) is the public or private path of the capability that should be removed path Other important functions getLinkTarget This function can be used to get the target path of a capability. fun getLinkTarget(_ path: CapabilityPath): Path? getCapability This function can be used to get the link to existing capabilities. fun getCapability<T>(_ at: CapabilityPath): Capability<T> check This function is used to check if the target currently exists and can be borrowed. fun check<T: &Any>(): Bool borrow This function is used to borrow the capability and get a reference to a stored object. fun borrow<T: &Any>(): T? Code examples of creating a capability with Cadence We will follow a simple example where: Step 1: We will create a smart contract with a function as a resource. Step 2: We will access the resource. Create a capability to access the resource in that smart contract. Create a reference to that capability using the borrow function. Execute the function resource. Step 1: Creating a car smart contract Explanations are in the comments below: pub contract Car {
    // Declare a resource that only includes one function.
    pub resource CarAsset {
        // A transaction can call this function to get the "Honk Honk!"
        // message from the resource.
        pub fun honkHorn(): String {
            return "Honk Horn!"
        }
    }
    // We're going to use the built-in create function to create a new instance
    // of the Car resource
    pub fun createCarAsset(): @CarAsset {
        return <-create CarAsset()
    }
    init() {
        log("Creating CarAsset")
    }
} Step 2: Accessing the honkHorn() function in the CarAsset resource of Car smart contract The code below includes all three steps: Creating the capability to access the resource from CarAsset Creating a reference by borrowing the capability Executing the HonkHorn function Explanations are in the comments below: import Car from 0x01

// This transaction creates a new capability
// for the CarAsset resource in storage
// and adds it to the account's public area.
//
// Other accounts and scripts can use this capability
// to create a reference to the private object to be able to
// access its fields and call its methods.

transaction {
  prepare(account: AuthAccount) {

    // Create a public capability by linking the capability to
    // a `target` object in account storage.
    // The capability allows access to the object through an
    // interface defined by the owner.
    // This does not check if the link is valid or if the target exists.
    // It just creates the capability.
    // The capability is created and stored at /public/CarAssetTutorial, and is
    // also returned from the function.
    let capability = account.link<&Car.CarAsset>(/public/CarAssetTutorial, target: /storage/CarAssetTutorial)

    // Use the capability's borrow method to create a new reference
    // to the object that the capability links to
    // We use optional chaining "??" to get the value because
    // result of the borrow could fail, so it is an optional.
    // If the optional is nil,
    // the panic will happen with a descriptive error message
    let CarReference = capability.borrow()
      ?? panic("Could not borrow a reference to the Car capability")

    // Call the honkHorn function using the reference
    // to the CarAsset resource.
    //
    log(CarReference.honkHorn())
  }
} If you execute the above function, you should see the message “Honk Honk!” in your console. Refer to to learn how to deploy a contract and execute Cadence code. this tutorial Conclusion In this article, we learned the types of blockchain authorization and the added advantage of using capabilities over other methods of authorization. We also learned how to create, execute, and transfer capabilities in Cadence, the smart contract language of Flow blockchain. These learnings will help you as a developer to write highly secure code when building on Flow. In essence, capabilities open up a new paradigm of blockchain authorization, making it very easy for developers to define access at a granular level. The fact that Flow blockchain uses this paradigm for data access makes it one of the most secure blockchain options out there. And as you probably noticed, it is super easy to create capabilities in Flow. I hope that you enjoyed this deep dive into capability-based security in Flow blockchain. You can refer to the on Capabilities to learn more. I also recommend that you get your hands dirty by going through and this . official docs page Flow Docs tutorial on Capabilities Also published . here

Moving to Capability-Based Security with Flow: A Critical Evolution in Blockchain Security

is a permissionless layer-1 blockchain built to support the high-scale use cases of games, virtual worlds, and the digital assets that power them. The blockchain was created by the team behind CryptoKitties, Dapper Labs, and NBA Top Shot. Flow One of the best features of Flow is that it supports the paradigm of resource-oriented programming. Resource-oriented is a new way of managing memory where resources are held “in-situ” by the resource owner instead of in a separate ledger. This is very relevant for managing scarce and unreplicable digital resources on the blockchain. programming In this article, I’ll do a deep dive into resource-oriented programming—and allow you to better manage your resources in your Flow smart contracts. What is resource-oriented programming? In resource-oriented programming, objects are labeled as “resources.” Resources are a collection of variables and functions that only have exactly one copy at a time. Resources provide better composability than EVM and WASM. When something is called a resource, there are very specific rules for interacting with it. The three rules that apply to resources in resource-oriented programming are as follows: Each resource exists in only one memory location - Resources cannot be duplicated. Ownership of a resource is defined by where it is stored - No central ledger that keeps track of ownership. Only the owner of the resource can access its methods. To explain this better; in the real world, if you claim to own a watch, that ownership is proven by the fact that you possess it yourself. There is no central ledger that people refer to check if you are the owner. However, in programming, when we think of ownership, we think of a mapping somewhere in a ledger of the object ID to the owner ID. For example, in the case of ERC721 smart contracts, the ownership of digital assets is stored in a ledger owned by the main smart contract. Flow changes this paradigm of ownership by storing “resources” in the memory location owned by the owner itself (see image below). This means that if you’re holding a digital asset on the Flow blockchain, it is stored in the memory location of the account that you own. This has several benefits, which we’ll talk about in the coming section. Resources in Cadence is the world’s first high-level resource-oriented programming language. , created for Facebook’s now-defunct Diem, is the only other language that is resource-oriented, but it is more low-level. Cadence Move In Cadence, resources are defined using the “resource” keyword. Within a resource, you can define the attributes of the resource, like variables and functions. This definition of a resource now becomes a type and can be used to create objects of that type.\ An example of creating a resource and creating an instance of that resource is shown below: // Declare a resource that only includes one function.    pub resource CarAsset { // A transaction can call this function to get the "Honk Honk!"        // message from the resource.        pub fun honkHorn(): String {            return "Honk Horn!"        }    } // We're going to use the built-in create function to create a new instance    // of the Car resource    pub fun createCarAsset(): @CarAsset {        return <-create CarAsset()    } Destroy function Resources in Cadence can be explicitly destroyed using the “destroy” keyword. The Move Operator (<-) To make the moves of a resource explicit, the Move operator, such as “<-” must be used when: Initializing the value of a constant or variable with a resource Moving resources to a different variable Moving resources to the argument of a function Returning it from a function Code Example of Creating a Resource in Cadence Below is an example of a Cadence script that creates a CryptoKitty collection as a resource and also stores individual Kitties as a resource. contract CryptoKitties {// Accounts store a collection in their account storage  resource KittyCollection {// Each collection has functions to// move stored resources in and out  fun withdraw(kittyId: int): CryptoKittyfun deposit(kitty: CryptoKitty)}  // The resource objects that can be stored in the collectionresource CryptoKitty {}} transaction(signer: Account) {// Removes the Kitty from signer's collection, and stores it// temporarily on the stack. let theKitty <- signer.kittyCollection.withdraw(kittyId: myKittyId) // Moves the Kitty into the receiver's accountlet receiver = getAccount(receiverAccountId)receiver.kittyCollection.deposit(kitty: <-theKitty)} In the above code, we create a KittyCollection resource that has several CryptoKitty sub-resources within it. We then do a transfer transaction to transfer a Kitty from one user account to another. Other things to keep in mind Resources must be created using the “create” keyword. At the end of a function with resources, the resources should either be moved or destroyed. Accessing a field or a function of a resource does not destroy it. When a resource is moved, the constant or variable currently holding the resource becomes invalid. To make a resource type explicit, the prefix @ must be used in type annotations. Comparison and Benefits Resource-oriented programming versus ledger-based systems A common comparison of the ownership structure in resource-oriented programming is with ledger-based ownership. In the ledger model, like in ERC721 smart contracts, every time you have to update ownership, you need to update the mapping of the ID in a shared ledger. In resource-oriented programming, resources are stored within the account of the owner itself, so transferring a digital asset only means moving the resource from the first party to the second. This does not require updating any ledgers. Resource-oriented programming is more suitable for blockchain use cases like digital assets than the traditional ledger system. Benefits of resource-oriented programming There are several benefits that resource-oriented programming brings to the table. Let’s look at some of them below. Makes capability-based security possible Resource types provide the foundation on which capability-based security can be established. Capabilities are one of the best methods to create highly secure blockchain authorization systems. This brings the utmost security to the Flow blockchain. Eliminates reentrancy attacks Reentrancy attacks are one of the most severe smart contract vulnerabilities often exploited by hackers. In a reentrancy attack, a hacker calls the withdraw function on a smart contract recursively. This way, they are able to drain the entire funds of a smart contract. Since methods within a resource cannot be accessed by anyone but the owner, there is no possibility of a reentrancy attack. Better pricing and cost management In Ethereum, the CryptoKitties contract has 2 million digital assets collectively taking up more than 100 MB of space, living rent-free on the Ethereum blockchain. In an ideal world, it should be possible to charge the owners of Kitties based on how much of this data belongs to them on-chain. In Flow, since the resource is directly stored in the account of the owner, it is clear who needs to pay the cost for that data. Conclusion Resource-oriented programming is a new and innovative programming paradigm that has been brought to the blockchain world by the Flow blockchain. It makes resource management very efficient, easy, and secure. It also helps provide a better cost-sharing model for running blockchain infrastructure. You can refer to the on Resources to learn more. I also recommend that you get your hands dirty by going through and this . official docs page Flow Docs tutorial on Resources

The Power of Resource-Oriented Programming in Flow/Cadence: A Deep Dive

My second hackathon was on the Flow chain. You might ask why I specifically chose Flow and not any other hackathon. The answer is quite simple. I was part of the community from the very beginning; during the ICO, when I first heard about the project, and invested in Flow at 60 cents per coin. It was a good deal, especially when Flow’s cost rose up to $40 per coin. At that time, all the coins were locked, making it impossible for ICO investors to sell any. I was only able to sell them at $17, which, in my opinion, was great. Since then, I’ve actively followed the community. I wanted to participate in Hackathon season 1 but was busy with several other projects. So, when I heard about the upcoming hackathon season 2, I was very excited to participate in it with my idea for a charity that had been sitting in my mind for a long time. Before diving any deeper, you can try the project yourself by visiting https://prayforua.com Flow: Cadence, FCL Official Guide Since it was my first time working with the Flow ecosystem, I decided to use the official guide to learn Cadence and , which we will talk about later. FCL - Flow Client Library The official guide helped me understand Cadence better, guiding me through the most common use cases. Although very useful, I found it a bit verbose, with many articles written so that readers could jump in at any point. This led to repetition and made it seem clunky. Other than that, it took me around 6-8 hours to finish, leading to a basic understanding of the language principles and architecture of blockchain projects using the Flow ecosystem. Both Cadence and FCL were developed by DapperLabs, providing a consistent developer experience. Their API also seemed mature to me, even tho It’s a new language and API might change in the future, covering almost everything a developer might need, it might ever work for an enterprise-sized project. My project was smaller, but it still required a lot of smart contracts, I’ll describe that in the Architecture section. Cadence Compared to Other Languages For those who don’t know, Cadence is a new programming language for smart contracts written by Dapper Labs. I was very curious to try Cadence, having heard about this language some time ago, with its resource-oriented nature akin to . I also wanted to compare it with the well-established Solidity that I’ve used. Rust Resource-Oriented Nature One of the standout features of Cadence is its resource-oriented nature, drawing parallels with the programming language Rust. Rust gained prominence for its efficient resource allocation mechanism, centered around borrowing and lending. Similarly, Cadence employs a similar principle: resources can exist in only one location at a time. This fundamental concept guarantees resource safety, particularly for tokens and other critical resources within the smart contract ecosystem. This design choice not only enhances security but also contributes to the predictability and reliability of smart contracts. Enhanced Security Cadence’s resource-oriented approach inherently addresses some of the security concerns that plagued Solidity-based contracts. By preventing resource duplication and enforcing strict ownership rules, Cadence minimizes the potential for vulnerabilities such as reentrancy attacks and unauthorized token transfers. This focus on security aligns with Dapper Lab’s vision of providing a robust platform for building decentralized applications without compromising on safety. On the other hand, Solidity’s design allowed for pitfalls such as reentrancy attacks, which posed a significant security threat. My Hackathon Project Let’s briefly examine the app architecture and the main concept of my hackathon project. Tooling For my own projects, Svelte is a no-brainer, so: for speed. pnmp as js framework. Svelte as an application framework. (For those unfamiliar with SvelteKit, you might think of it as similar to Next.js) SvelteKit - For quick prototyping. (TailwindCSS for styles and the Tailwind library of mixed styles DaisyUI for even more styles on top of tailwind shugar for basic components like buttons, ranges, etc.) TailwindCSS/DaisyUI //package.json
{
...,
"devDependencies": {
"@sveltejs/adapter-vercel": "^3.0.2",
"@sveltejs/kit": "^1.22.1",
"autoprefixer": "^10.4.14",
"daisyui": "^3.1.11",
"eslint": "^8.44.0",
"eslint-config-prettier": "^8.8.0",
"eslint-plugin-svelte": "^2.32.2",
"postcss": "^8.4.25",
"prettier": "^3.0.0",
"prettier-plugin-svelte": "^2.10.1",
"svelte": "^4.0.5",
"tailwindcss": "^3.3.2",
"vite": "^4.4.2"
},
"dependencies": {
"@onflow/fcl": "^1.4.1",
"firebase": "^10.0.0",
"nanoid": "^4.0.2",
"ramda": "^0.29.0"
}
} As you can see, I’m using 4 client libs: fcl - flow client api firebase - my user data storage solution + db real-time updates onSnapshot nanoid - gen random id ramda - like lodash, but functional style library of utilities (Ramda helped take advantage of utility functions like pipe, combine, etc.) Because Svelte is a in the first place, there is no real difference between devDependencies and dependencies, but I’m adding client libs as dependencies for the sake of concept separation, so it’s easier to read. compiler Svelte store firebase simplified implementation You might want to see simple svelte store firebase api wrapper with localStorage sync import {getFirestore, doc, setDoc, getDoc} from 'firebase/firestore';
import {initializeApp} from 'firebase/app';
import {writable} from 'svelte/store';
import {browser} from '$app/environment';
import {firebaseKeys} from '$lib/firebase/config';

const initialState = {};

function createDb(key) {
  const initialValue =
    browser && localStorage.getItem(key)
      ? JSON.parse(localStorage.getItem(key))
      : initialState;

  const {subscribe, set, update} = writable(initialValue);
  const ini = initializeApp(firebaseKeys);
  const db = getFirestore(ini);

  return {
    set,
    update,
    subscribe,
    getDbRef: () => db,
    getDoc: async (path, id) => {
      const docRef = doc(db, path, id);
      return await getDoc(docRef);
    },
    setDoc: async (path, id, payload) => {
      try {
        const docRef = doc(db, path, id);
        await setDoc(docRef, {...payload}, {merge: true});
        console.warn('Document added to Firestore:', document);
      } catch (error) {
        console.error('Error adding document to Firestore:', error);
      }
    },
    useLocalStorage: () => {
      subscribe((current) => {
        if (browser) {
          localStorage.setItem(key, JSON.stringify(current));
        }
      });
    }
  };
}

export const db = createDb('app-db'); I wrote this wrapper to simplify the usage of Firebase API across the app. The might look a bit complex, but the logic is similar to zustand. Project store Svelte and cadence integration One aspect I love the most is the ability to integrate smart contract transactions and scripts using FCL, very handy for creating a serverless app. For example, transfering tokens be like: ...
export const transferFlow = async (amount, addr, cid) => {
  let transactionId = false;
  initTransactionState();

  try {
    transactionId = await fcl.mutate({
      cadence: `
        import FungibleToken from 0x9a0766d93b6608b7
        import FlowToken from 0x7e60df042a9c0868

        transaction(amount: UFix64, to: Address) {

           // The Vault resource that holds the tokens that are being transferred
           let sentVault: @FungibleToken.Vault

           prepare(signer: AuthAccount) {

               // Get a reference to the signer's stored vault
               let vaultRef = signer.borrow<&FlowToken.Vault>(from: /storage/flowTokenVault)
            ?? panic("Could not borrow reference to the owner's Vault!")

               // Withdraw tokens from the signer's stored vault
               self.sentVault <- vaultRef.withdraw(amount: amount)
           }

           execute {

               // Get a reference to the recipient's Receiver
               let receiverRef =  getAccount(to)
                   .getCapability(/public/flowTokenReceiver)
                   .borrow<&{FungibleToken.Receiver}>()
                    ?? panic("Could not borrow receiver reference to the recipient's Vault")

               // Deposit the withdrawn tokens in the recipient's receiver
               receiverRef.deposit(from: <-self.sentVault)
           }
        }
      `,
      args: (arg, t) => [arg(amount, t.UFix64), arg(addr, t.Address)],
      payer: fcl.authz,
      proposer: fcl.authz,
      authorizations: [fcl.authz],
      limit: 50
    });

    // store method
    txId.set(transactionId);

    // subscribe to svelte transactions
    fcl.tx(transactionId).subscribe((res) => {
      transactionStatus.set(res.status);
      if (res.status) {
        if (res.status === 4) {
          getAccountBalance(addr, cid);
          auth.addFlowTransaction({
            txId: transactionId,
            event: `${amount} Flow transferred to ${addr} at`,
            status: res.status,
            timestamp: new Date().getTime()
          });
          setTimeout(() => transactionInProgress.set(false), 2000);
        }
      }
    });
  } catch (e) {
    transactionStatus.set(99);
    console.warn(e);
  }
};
... Here method receiving an object with key and value will be valid cadence code, and this way you can write transactions and scripts easily from your js files. See more examples of flc actions in github. fcl.mutate cadence Conclusion Even tho I didn’t win, the Flow ecosystem fullstack development was an interesting experience. It seems more concise and simplified to work with when compared to the Ethereum ecosystem, which is not bad at all but I definitely like cadence more than solidity. However, to be fair, the last time I used the Solidity ecosystem was more than three years ago, so things might have changed, although I doubt it. 🥲 Outro I appreciate your engagement thus far. 🙏 Whether you’re a startup or an established enterprise, I’m here to help you build and enhance your digital products by offering my services. You can reach me by email at or find more contact information at glazer.nicholas@gmail.com https://nicholasglazer.com/man/ng Also published here.

My Journey With Flow: From ICO to Blockchain Hackathon Season 2

When starting a new project, it’s important to make the right choices about the blockchain and smart contract language. These choices can significantly impact the overall success of your project as well as your success as a developer. web3 In this article, we'll compare three popular smart contract programming languages: Solidity: used in Ethereum and other EVM-based platforms Cadence: used in the Flow blockchain Move: used in the Sui/Aptos blockchain We'll explain the concepts and characteristics of each language in simple terms, making it easier for beginners to understand. Let’s dive in. Solidity: The Foundation of Ethereum Smart Contracts is a high-level, object-oriented language used to build smart contracts in platforms like Ethereum. Initially, Solidity aimed to be user-friendly, attracting developers by resembling JavaScript and simplifying learning. While it still values user-friendliness, its focus has shifted to enhancing security. Currently, Solidity . Solidity has quite a few security pitfalls developers need to be aware of Some Solidity features include: Solidity uses clear, explicit code with a syntax similar to JavaScript, prioritizing ease of understanding for developers. Syntax and Simplicity: Solidity emphasizes secure coding practices and highlights risky constructs like gas usage. Security Focus: The language enforces data type declarations for variables and functions. Statically Typed: Solidity supports features like inheritance, libraries, and complex user-defined types. Inheritance and Libraries: Cadence: Empowering Digital Assets on Flow is designed by Flow, a blockchain known for helping to make web3 mainstream and working with major brands like Disney and the NBA. It ensures secure, clear, and approachable smart contract development. Cadence Some Cadence features include: The language enforces strict type-checking to prevent common errors. Type Safety: **Resource-oriented Programming:**Resources are unique types that can only move between accounts. They can’t be copied or discarded. If a function fails to store a Resource obtained from an account in the function scope during development, then semantic checks will show an error. The run-time enforces the same rules in terms of allowed operations. Contract functions that don’t handle Resources properly in scope before exiting will stop. These Resource features make them perfect for representing both fungible and non-fungible tokens. Ownership is tracked according to where they are stored, and the assets can’t be duplicated or lost since the language enforces correctness. If one person wants to access another person's stored items, the first person needs a permission called a . Using Capabilities allows you to let others access your stored items remotely. There are two types of Capabilities: public and private. If someone wants to allow everyone to access their items, they can share a public Capability. For example, an account can use a public Capability to accept tokens from anyone. On the other hand, someone can give private Capabilities to certain people, allowing them to access only certain features. For example, in a project with unique digital items, the project owner might grant an "administrator Capability" that lets those users create new items. Capability-based Security: Capability Functions have predefined conditions for safer execution. Built-in Pre- and Post-Conditions: Cadence's focus on resource-oriented programming makes it ideal for managing digital assets in areas such as onchain games. Optimized for Digital Assets: To grasp the importance of these new ideas, let's take a quick look at some history. In 2018, the Dapper Labs team began working on Cadence as a new programming language. They faced challenges with Solidity because of its limitations. The main frustration in building decentralized apps came from the way contracts were accessed using addresses, making it difficult to combine contracts. Freedom from msg.sender: Composability in Web3 Now, imagine contracts as Lego building blocks. Composability in web3 means one contract can be used as a foundation for others, adding their features together. For instance, if a contract records game results on a blockchain, another contract can be built to show the best players. Another one could go even further and use past game results to predict future game odds for betting. But here's the catch: Because of how Solidity works, contracts can only talk to one another if the first contract has permission to access the second one, even if users can access both. In Solidity, who can do what is controlled by protected functions in contracts. This means contracts know and check who is trying to access their protected areas. Cadence changes how access works. Instead of using the old way where contracts need permission, it uses Capabilities. When you have a Capability, you can use it to get to a protected item such as a function or resource. This means the contract no longer has to define who's allowed access. You can only get to the protected item if you have a Capability, which you can use with "borrow()." So, the old "msg.sender" way isn't needed anymore! The effects of composability are important. When contracts don't need to know beforehand who they're interacting with, users can easily interact with multiple contracts and their functions during a transaction if they have the right permissions (Capabilities). This also allows contracts to interact with one another directly without needing special permissions or preparations. The only condition is that the calling contract must have the required Capabilities. Move: Safeguarding Digital Assets on Sui/Aptos , used in the , addresses challenges posed by established languages like Solidity. It ensures scarcity and access control for digital assets. Move Sui/Aptos blockchain Move’s features include: : Move prevents the creation or use of assets more than once, ensuring robust blockchain applications. Preventing Double-spending : Developers have precise control over ownership and associated rights. Ownership and Rights Control : In Move, a smart contract is called a module, emphasizing modularity and organization. Module Structure : Move employs static analysis to reject invalid bytecode, enhancing security. Bytecode Verifier : Move includes a standard library for common transaction scripts. Standard Library Creating Smart Contracts Let's illustrate the differences by comparing a simple smart contract that increments a value in Cadence, Solidity, and Move. Solidity Example In Solidity, creating a contract that increments a value involves defining a contract, specifying the count variable, and creating functions to manipulate it. It uses explicit syntax for variable visibility and function declarations. // SPDC-License-Identifier: MIT pragma solidity ^0.8.17; contract Counter { uint public count; // function to get the current count function get() public view returns (uint) { return count; } // function to increment count by 1 function inc() public { count += 1; } // function to decrement count by 1 function dec() public { count -=1; } } Cadence Example Cadence's approach to incrementing a value is similar but emphasizes clarity. It utilizes a resource-oriented structure and straightforward syntax, making it easier for developers to create and manage digital assets. pub contract Counter { pub var count: Int // function to increment count by 1 pub fun increment() { self.count = self.count +1 } // function to decrement count by 1 pub fun decrement() { self.count = self.count – 1 } pub fun get(): Int { return self.count } init() { self.count = 0 } } Solidity versus Cadence Syntax Differences In Solidity, the visibility keyword comes before or after variable/function names, whereas Cadence consistently follows the visibility-type-name sequence. Scalability and Upgradability Flow's network boasts higher transaction throughput than Ethereum, making Cadence more scalable. Additionally, Flow's support for contract updates enhances development. Move Example Move introduces new concepts like modules, resources, and ownership control. A Move module creates an Incrementer resource, requiring the owner's signature for operations. module incrementer_addr::increment {

 

use aptos_framework::account;

use std::signer;

       struct Incrementer has key {

                  count: u64,

       }

 

       public entry fun increment(account: &signer) acquires Incrementer {

                  let signer_address = signer::address_of(account);

                  let c_ref = &mut borrow_global_mut<Incrementer>(signer_address).count;

                  *c_ref = *c_ref +1

       }

 

       public entry fun create_incrementer(account: &signer){

            let incrementer = Incrementer {

                  count: 0

            };

            move_to(account, incrementer);

       }

} Composite Types and Turing Completeness All three languages support composite types, allowing complex types from simpler ones. All are Turing complete, meaning they can handle any computation given enough resources. Resource-Oriented versus Object-Oriented While Solidity and Move require compilation, Cadence is interpreted. Cadence and Move employ a resource-oriented approach, securing digital ownership in one location. Conclusion: Choosing the Right Programming Language When selecting a programming language like Solidity, Cadence, or Move, consider the needs of your project. Solidity is commonly used, but it might not be very easy to work with. Developers need to be careful of the security pitfalls and understand best practices. Solidity: Mainly used for digital assets, Cadence is a newer language that focuses on security, is easy to understand, and provides developers with a superior experience. Cadence: Move is , a more complex language. Rust can be more difficult to learn and understand. Move is a new language, and it doesn't have many tools, resources, or a big community. Move: based on Rust Ultimately, your choice will impact your project's success, so make an informed decision and enjoy your ! journey as a web3 developer Also published . here

DAPPER LABS

dapperlabs.com

501-1K employees

Since 2018

COMPANY RANKING

DAPPER LABS

EVERGREEN INDEX #2857

Representing this company? Click here to claim and customize this page!

Dapper Labs WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

DAPPER LABS

dapperlabs.com

501-1K employees

Since 2018

COMPANY RANKING

DAPPER LABS

EVERGREEN INDEX #2857

RELATED COMPANIESRANK

STORIES ABOUT DAPPER LABS

Representing this company? Click here to claim and customize this page!

Dapper Labs WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!