N FT flow market

Приобретение и децентрализация Brud

Учитывая, что мотивы постепенной децентрализации и сложных сообществ прослеживаются во всей истории Dapper, не удивительно, что появление DAO на Flow началось с истории о неудачных попытках реализовать идею прогрессивной децентрализации.

Тревор Макфедрис основал Brud в 2016 году для создания новых моделей цифрового сторителлинга. Он хотел использовать для этого “коллективно созданные медиа и миры”, то есть именно то, для чего был разработан Flow.

У главного персонажа Brud, Лил Микелы, более 10 миллионов поклонников в социальных сетях, которые взаимодействуют с ней и помогают формировать ее историю.

Лил Микела на сайте Brud

Тревор рассказал мне, что причиной сделки с Dapper стало то, что он хотел превратить Brud в DAO, но эту идею не одобрили члены совета директоров.

В течение нескольких лет он выдвигал эту идею на заседаниях правления, но члены правления скептически относились к криптовалютам и не проявляли к ней интереса. Один из них сказал Тревору, что в прошлый раз, когда они инвестировали в токены, у них были проблемы с SEC. Они не хотели снова с этим сталкиваться.

Но идея Brud заключалась в коллективном создании персонажей, историй и миров, и Тревор считал, что совместное владение — единственная модель, которая действительно подходит для этого бизнеса. Поэтому он продолжал настаивать на своем. Он понял, что нужно не рассказывать, а показывать.

Отчасти я создал FWB чтобы показать, какую ценность могут генерировать DAO.

FWB — это Friends With Benefits, DAO ориентированная на сферу культуры, которую Тревор запустил в сентябре 2020 года.

Он оказался прав. Год спустя, в сентябре 2021 года, FWB привлекла 10 миллионов долларов от a16z. Точно так же, как команда Dapper популяризировала NFT, Тревор и FWB популяризировали DAO, не связанные с DeFi.

Успех FWB и растущий ажиотаж вокруг DAO в целом, наконец, убедили совет директоров в том, что децентрализация была хорошей идеей, но многим из них было запрещено владеть токенами. Поэтому они попросили Тревора найти криптоинвесторов, чтобы выкупить их долю.

Он собрал команду и начал переговоры с разными людьми, в том числе с Рохамом. Dapper и Рохам активно инвестируют в web3, но когда Тревор пообщался с Рохамом и они обсудили его видение, возникла другая идея:

Никто лучше вас не знает, как создать опыт для следующих поколений, и мы оба верим в мульти-чейн будущее. Почему бы нам просто не начать строить на Flow? Создавая инструменты для сообщества Brud, вы создадите их и для всей остальной экосистемы.

Прошло некоторое время, прежде чем они заключили сделку, потому что Тревор хотел убедиться, что культура Brud вписывается в культуру Dapper. Но после нескольких раундов переговоров между командами он понял, что все складывается идеально.

Мы — творческие подростки-неформалы; а они очень вежливые, умные канадцы.

В октябре Dapper Labs официально приобрела Brud и объявила о запуске Dapper Collectives с Тревором в качестве генерального директора.

Цель Dapper Collectives — “проложить путь к децентрализации социальных сетей и демократизации сообществ на Flow, чтобы создатели контента могли получать справедливый доход от своей деятельности”.

В своем блоге Фред Уилсон из USV объяснил, что первоначальные задачи Dapper Collectives будут включать:

• Привнести коллективное владение и возможности для совместного творчества в продукты Dapper Labs — начиная с Лил Микелы и ее десяти миллионов поклонников;
• Создать инструменты с открытым исходным кодом, чтобы помочь другим крупным сообществам участвовать в децентрализованном владении и управлении на блокчейне Flow;
• Помочь наиболее дальновидным компаниям “web 2” децентрализовать свою деятельность, помогая им в технических аспектах и вопросах токеномики.

Рохам утверждает, что в его стремлении “положить криптокошелек в каждый карман” он рассматривает DAO как “самую перспективную область после NFT”.

Для Тревора это также возможность переосмыслить все, что касается DAO и онлайн-сообществ:

• Как должны выглядеть механизмы голосования, с помощью которых члены сообщества будут принимать решения?
• Как сделать так, чтобы каждый пользователь стал создателем?
• Как должен выглядеть более понятный интерфейс для кошелька с мультиподписью?
• Как именно сообщества будут коллективно создавать истории на блокчейне?
• Что должно быть “двигателем” метавселенных, персонажи или сами вселенные?

Касательно последнего пункта Тревор сказал следующее:

Люди переезжают в Нью-Йорк не из-за архитектуры, даже если она там крутая. Они переезжают туда ради людей: познакомиться с кем-то, заработать денег, повеселиться.

Top Shot оставил за скобками термины “криптовалюта” и “NFT” (даже не смотря на то, что команда Dapper впервые ввела понятие “невзаимозаменяемый” токен).

В свою очередь у Dapper Collectives есть возможность создать новую терминологию для сообществ, которыми владеют их участники. Обратите внимание, например, что они не назвали подразделение Dapper DAOs.

Как и в случае с созданием своего блокчейна и языка программирования, идея переосмыслить DAO означает, что придется пожертвовать быстрым выходом на рынок в пользу того, что команда расценивает, как лучшее решение в долгосрочной перспективе.

Я спрашивал Тревора, когда Brud децентрализуется (по уже знакомой нам схеме, Brud станет первой DAO на Dapper Collectives, прежде чем подразделение откроется для партнеров и сторонних групп). И его ответ отражает то, как команда Flow подходит ко всему.

“Двигайся медленно и делай все правильно”

Потому что в индустрии, где все верят, что мы находимся еще в самом начале пути, команда Flow считает, что впереди нас ждет еще более длинный путь.

Rarible

Один из ведущих NFT маркетплейсов на Ethereum, Rarible — это платформа, управляемая сообществом, на которой представлен широкий спектр произведений цифрового искусства и предметов коллекционирования. На данный момент, по данным Dappradar, площадка занимает пятое место по совокупному объему торгов (210 миллионов долларов).

Как и на OpenSea, здесь представлены самые разные категории NFT. Продавцы также могут создать несколько NFT одного изображения и продать его более одного раза.

Пользовательский интерфейс Rarible достаточно прост в освоении даже для новичка; а пользователи, которые уже имели дело с подобными площадками, почувствуют себя здесь как дома.

Поток

Команда Flow сделала ряд неочевидных ставок.

• Они создали блокчейн, способный стабильно поддерживать сложные, растущие и развивающиеся миры;
• Они разработали совершенно новую многоузловую архитектуру и с нуля создали свой собственный язык программирования;
• Вместо того чтобы пытаться привлечь существующих крипто-пользователей, они сделали ставку на массовых потребителей и детей;
• Их понимание децентрализации включает не только первоначальное распределение узлов, но также доступность.

В результате в прошлом году, когда шумиха вокруг Top Shot улеглась, блокчейн переживал свою собственную мини-зиму, в то время как экосистемы других сетей процветали. Но, похоже, что одним из неожиданных преимуществ такого нестандартного подхода стала меньшая корреляция с рынком.

Потому что, пока последние пару месяцев на крипторынках продолжалось падение, активность на Flow начала набирать обороты.

Февраль стал для Flow лучшим месяцем по объему транзакций, который превзошел максимумы весны 2021 года на 50% и дважды в течение месяца превысил за сутки отметку в 1 миллион долларов. Такой всплеск активности был связан с запуском новых проектов.

За прошедшую неделю объем торгов на NFT-маркетплейсе Gaia составил 6.2 миллиона долларов. Таким образом, площадка заняла 4-ю строчку в рейтинге NFT-маркетплейсов от Dappradar.

Flow также приобретает популярность среди “единорогов”: Animoca и PlayCo создают на базе блокчейна свои игры, а Alchemy и Circle планируют вскоре добавить поддержку Flow.

Fancraze, которая официально лицензировала NFT для фанатов крикета, потенциально может привлечь десятки или сотни миллионов болельщиков популярной индийской лиги ICC.

Flow продолжает привлекать крупнейшие мейнстримные бренды.

“YouTube всегда делают креативные подарки! Кастомный NFT 🤯 Спасибо, ребята!”

В отдельности, это не такие уж крупные события, но они говорят о возможности получить доступ к невероятно масштабным рынкам с реальными вариантами использования.

Если TicketMaster захотят выпускать билеты в виде NFT на Flow, или если YouTube будет работать с Flow, чтобы создатели могли выпускать NFT популярных видео и продавать их фанатам, они получат огромную экономическую выгоду и вдобавок привлекут еще больше людей в web3.

Вся эта активность начинает привлекать десятки проектов, созданных сообществами, таких как Matrix World, KLKTN, Flovatar, Chainmonsters, Emerald City, Mantle Finance, Zeedz, Legaci, The Football Club и Ballerz.

Эти проекты возникли органично, без участия команды Flow (хотя Zeedz был основан бывшим членом команды Dapper Labs, который покинул основную команду чтобы стать частью экосистемы — что является позитивным сигналом).

Начинают проявляться реальные сетевые эффекты.

Matrix World — кросс-чейн проект на Flow и Ethereum

Создается ощущение, что Flow находится на переломном этапе, и что этим летом ситуация может достичь кульминации:

• Dapper Collectives выпустит свой первый инструментарий для DAO и начнет поддерживать сообщества на Flow;
• На Flow состоится запуск Genies, и всем, что они построят будут владеть участники сообщества. Возможно со временем децентрализуется и сама компания;
• Dapper Wallet будет полностью доступен для интеграции сторонними разработчикам;
• FLOW будет поддерживаться кошельком и всеми проектами Dapper, а также, вероятно, многими проектами сторонних разработчиков;
• Развертывание проектов на блокчейне станет полностью свободным, что откроет дорогу для безграничного творчества.

Когда последние два пункта вступят в силу, Flow совершит еще один огромный скачок в направлении максимальной децентрализации.

В долгосрочной перспективе, для того чтобы Flow соответствовал установленному его создателями определению децентрализации, самое главное убедиться, что сотни миллионов пользователей — “нормис”, дети и даже крипто-дегены — могут свободно творить, владеть цифровой собственностью и эволюционировать на Flow.

Как будет выглядеть мир если Flow достигнет своей цели?

Невозможно представить что будет, когда многие миллионы пользователей и создателей получат инструменты для программирования денег, создания цифровых активов, открытых миров и сообществ. В этом дикая красота инноваций и компонуемости.

Но для того, чтобы реализовать свои амбиции, команде Flow нужно построить мир, в котором владеть цифровыми активами также просто и безопасно, как физическими.

Это мир, в котором люди формируют платформы, которые они используют, и получают выгоду от своего коллективного успеха. Это мир, в котором дети имеют возможность создавать не только контент или продукты, но и экономику вокруг них.

Если потребуется несколько лет централизованных усилий, чтобы построить более привлекательное децентрализованное будущее для миллиардов людей, это компромисс, на который Flow готов пойти.

Между сегодняшним днем и этим будущим огромное расстояние, но если кто-то и может его преодолеть, то я бы ставил на команду, которая неоднократно доказывала, что знает, как привлечь в web3 обычных людей.

Возможно, лучшим решением в крипто-пространстве было не обращать внимания на то, что думают другие его обитатели.

С оригинальным материалом вы можете ознакомиться здесь

После прочтения статьи решили купить токены $FLOW? Это можно сделать через биржу Binance:

(по ссылке вы получите постоянную скидку 20% на комиссии на криптобирже Binance, а также поддержите работу нашего ресурса

А вы знакомы с какими-то из проектов на базе Flow? Расскажите о своих впечатлениях в комментариях ниже.

How to develop the NFT Marketplace on Flow?

Set up the Playground for Marketplace Development

// FungibleToken.cdc
// The FungibleToken contract is a sample implementation of a fungible token on Flow.
// Fungible tokens behave like everyday currencies -- they can be minted, transferred or
// traded for digital goods.
// Follow the fungible tokens tutorial to learn more: https://docs.onflow.org/docs/fungible-tokens 
pub contract FungibleToken {
    // Total supply of all tokens in existence.
    pub var totalSupply: UFix64
    // Provider
   // Interface that enforces the requirements for withdrawing
    // tokens from the implementing type.
    // We don't enforce requirements on self.balance here because
    // it leaves open the possibility of creating custom providers
    // that don't necessarily need their own balance.
    pub resource interface Provider {
        // withdraw
       // Function that subtracts tokens from the owner's Vault
        // and returns a Vault resource (@Vault) with the removed tokens.
        // The function's access level is public, but this isn't a problem
        // because even the public functions are not fully public at first.
        // anyone in the network can call them, but only if the owner grants
        // them access by publishing a resource that exposes the withdraw
        // function.
        pub fun withdraw(amount: UFix64): @Vault {
            post {
                // `result` refers to the return value of the function
                result.balance == UFix64(amount):
                    "Withdrawal amount must be the same as the balance of the withdrawn Vault"
            }
        }
    }
    // Receiver 
    // Interface that enforces the requirements for depositing
    // tokens into the implementing type.
    // We don't include a condition that checks the balance because
    // we want to give users the ability to make custom Receivers that
    // can do custom things with the tokens, like split them up and
    // send them to different places.
    pub resource interface Receiver {
        // deposit
        // Function that can be called to deposit tokens 
        // into the implementing resource type
        pub fun deposit(from: @Vault)
    }
    // Balance
    // Interface that specifies a public `balance` field for the vault
    pub resource interface Balance {
        pub var balance: UFix64
    }
    // Vault
    // Each user stores an instance of only the Vault in their storage
    // The functions in the Vault and governed by the pre and post conditions
    // in the interfaces when they are called. 
    // The checks happen at runtime whenever a function is called.
    // Resources can only be created in the context of the contract that they
    // are defined in, so there is no way for a malicious user to create Vaults
    // out of thin air. A special Minter resource needs to be defined to mint
    // new tokens.
    pub resource Vault: Provider, Receiver, Balance {     
        // keeps track of the total balance of the account's tokens
       pub var balance: UFix64
        // initialize the balance at resource creation time
        init(balance: UFix64) {
            self.balance = balance
        }
        // withdraw
        // Function that takes an integer amount as an argument
        // and withdraws that amount from the Vault.
        // It creates a new temporary Vault that is used to hold
        // the money that is being transferred. It returns the newly
        // created Vault to the context that called so it can be deposited
        // elsewhere.
        pub fun withdraw(amount: UFix64): @Vault {
            self.balance = self.balance - amount
            return <-create Vault(balance: amount)
        }    
        // deposit
        // Function that takes a Vault object as an argument and adds
        // its balance to the balance of the owners Vault.
        // It is allowed to destroy the sent Vault because the Vault
        // was a temporary holder of the tokens. The Vault's balance has
        // been consumed and therefore can be destroyed.
        pub fun deposit(from: @Vault) {
            self.balance = self.balance + from.balance
           destroy from
        }
    }
    // createEmptyVault
    // Function that creates a new Vault with a balance of zero
    // and returns it to the calling context. A user must call this function
    // and store the returned Vault in their storage in order to allow their
    // account to be able to receive deposits of this token type.
    pub fun createEmptyVault(): @Vault {
        return <-create Vault(balance: 0.0)
    }
    // VaultMinter
    // Resource object that an admin can control to mint new tokens
    pub resource VaultMinter {
        // Function that mints new tokens and deposits into an account's vault
        // using their `Receiver` reference.
        // We say `&AnyResource{Receiver}` to say that the recipient can be any resource
        // as long as it implements the Receiver interface
        pub fun mintTokens(amount: UFix64, recipient: &AnyResource{Receiver}) {
            FungibleToken.totalSupply = FungibleToken.totalSupply + amount
            recipient.deposit(from: <-create Vault(balance: amount))
        }
    }
    // The init function for the contract. All fields in the contract must
    // be initialized at deployment. This is just an example of what
    // an implementation could do in the init function. The numbers are arbitrary.
    init() {
        self.totalSupply = 30.0
        // create the Vault with the initial balance and put it in storage
        // account.save saves an object to the specified `to` path
        // The path is a literal path that consists of a domain and identifier
        // The domain must be `storage`, `private`, or `public`
        // the identifier can be any name
        let vault <- create Vault(balance: self.totalSupply)
        self.account.save(<-vault, to: /storage/MainVault)
        // Create a new MintAndBurn resource and store it in account storage
        self.account.save(<-create VaultMinter(), to: /storage/MainMinter)
        // Create a private capability link for the Minter
        // Capabilities can be used to create temporary references to an object
        // so that callers can use the reference to access fields and functions
        // of the objet.
        // 
        // The capability is stored in the /private/ domain, which is only
        // accesible by the owner of the account
        self.account.link<&VaultMinter>(/private/Minter, target: /storage/MainMinter)
    }
}

With the above starter code, you can prepare the Flow Playground for the state required to build a marketplace for NFTs.

Setting up the NFT Marketplace

• Open account 0x01. The Fungible Token definitions in ‘FungibleToken.cdc’ need to be included in this account. You can refer to the Fungible Token tutorial to ensure the same.
• The Fungible Token code needs to be deployed to account 0x01
• Select and switch to account 0x02 from the account selection menu.
• Follow the Non-fungible token tutorial to make sure you have all NFT definitions from account 0x02 in NFTv2.cdc
• Deploy the NFT code to account 0x02

Run the transaction in Transaction 3, which is the SetupAccount1Transaction.cdc file. You can use account 0x01 as the only signer to set up account 0x01’s account.

import FungibleToken from 0x01
import NonFungibleToken from 0x02
// This transaction sets up account 0x01 for the marketplace tutorial
// by publishing a Vault reference and creating an empty NFT Collection.
transaction {
  prepare(acct: AuthAccount) {
    // Create a public Receiver capability to the Vault
    acct.link<&FungibleToken.Vault{FungibleToken.Receiver, FungibleToken.Balance}>
             (/public/MainReceiver, target: /storage/MainVault)
    log("Created Vault references")
    // store an empty NFT Collection in account storage
    acct.save<@NonFungibleToken.Collection>(<-NonFungibleToken.createEmptyCollection(), to: /storage/NFTCollection)
    // publish a capability to the Collection in storage
    acct.link<&{NonFungibleToken.NFTReceiver}>(/public/NFTReceiver, target: /storage/NFTCollection)
    log("Created a new empty collection and published a reference")
  }
}

Run the transaction in Transaction 4, which is the SetupAccount2Transaction.cdc file. You need to use account 0x02 as the only signer to set up account 0x02’s account.

import FungibleToken from 0x01
import NonFungibleToken from 0x02
// This transaction adds an empty Vault to account 0x02
// and mints an NFT with id=1 that is deposited into
// the NFT collection on account 0x01.
transaction {
  // Private reference to this account's minter resource
  let minterRef: &NonFungibleToken.NFTMinter
  prepare(acct: AuthAccount) {
    // create a new vault instance with an initial balance of 0
    let vaultA <- FungibleToken.createEmptyVault()
    // Store the vault in the account storage
    acct.save<@FungibleToken.Vault>(<-vaultA, to: /storage/MainVault)
    // Create a public Receiver capability to the Vault
    let ReceiverRef = acct.link<&FungibleToken.Vault{FungibleToken.Receiver, FungibleToken.Balance}>(/public/MainReceiver, target: /storage/MainVault)
    log("Created a Vault and published a reference")
    // Borrow a reference for the NFTMinter in storage
    self.minterRef = acct.borrow<&NonFungibleToken.NFTMinter>(from: /storage/NFTMinter)
            ?? panic("Could not borrow an nft minter reference")
  }
  execute {
    // Get the recipient's public account object
    let recipient = getAccount(0x01)
    // Get the Collection reference for the receiver
    // getting the public capability and borrowing a reference from it
    let receiverRef = recipient.getCapability<&{NonFungibleToken.NFTReceiver}>(/public/NFTReceiver)
        .borrow()
        ?? panic("Could not borrow an nft receiver reference")
    // Mint an NFT and deposit it into account 0x01's collection
    self.minterRef.mintNFT(recipient: receiverRef)
   log("New NFT minted for account 1")
  }
}

Run the transaction in Transaction 5, which is the SetupAccount1TransactionMinting.cdc file. Use account 0x01 as the only signer to mint fungible tokens for accounts 1 and 2.

import FungibleToken from 0x01
import NonFungibleToken from 0x02
// This transaction mints tokens for both accounts using
// the minter stored on account 0x01.
transaction {
    // Public Vault Receiver References for both accounts
    let acct1Ref: &AnyResource{FungibleToken.Receiver}
    let acct2Ref: &AnyResource{FungibleToken.Receiver}
    // Private minter references for this account to mint tokens
    let minterRef: &FungibleToken.VaultMinter
    prepare(acct: AuthAccount) {
        // Get the public object for account 0x02
        let account2 = getAccount(0x02)
        // Retrieve public Vault Receiver references for both accounts
        self.acct1Ref = acct.getCapability<&FungibleToken.Vault{FungibleToken.Receiver}>(/public/MainReceiver)
            .borrow()
            ?? panic("Could not borrow acct1 vault receiver reference")
        self.acct2Ref = account2.getCapability<&FungibleToken.Vault{FungibleToken.Receiver}>(/public/MainReceiver)
            .borrow()
            ?? panic("Could not borrow acct2 vault receiver reference")
        // Get the stored Minter reference for account 0x01
        self.minterRef = acct.borrow<&FungibleToken.VaultMinter>(from: /storage/MainMinter)
            ?? panic("Could not borrow vault minter reference")
    }
    execute {
        // Mint tokens for both accounts
        self.minterRef.mintTokens(amount: 20.0, recipient: self.acct2Ref)
        self.minterRef.mintTokens(amount: 10.0, recipient: self.acct1Ref)
        log("Minted new fungible tokens for account 1 and 2")
    }
}

To ensure everything is set up properly, run the script CheckSetupScript.cdc file in Script 1.

import FungibleToken from 0x01
import NonFungibleToken from 0x02
// This script checks that the accounts are set up correctly for the marketplace tutorial.
// Account 0x01: Vault Balance = 40, NFT.id = 1
// Account 0x02: Vault Balance = 20, No NFTs
pub fun main() { // Get the accounts' public account objects let acct1 = getAccount(0x01) let acct2 = getAccount(0x02) // Get references to the account's receivers // by getting their public capability // and borrowing a reference from the capability let acct1ReceiverRef = acct1.getCapability<&FungibleToken.Vault{FungibleToken.Balance}>(/public/MainReceiver) .borrow<&FungibleToken.Vault{FungibleToken.Balance}>() ?? panic("Could not borrow acct1 vault receiver reference") let acct2ReceiverRef = acct2.getCapability<&FungibleToken.Vault{FungibleToken.Balance}>(/public/MainReceiver) .borrow() ?? panic("Could not borrow acct2 vault receiver reference") // Log the Vault balance of both accounts and ensure they are // the correct numbers. // Account 0x01 should have 40. // Account 0x02 should have 20. log("Account 1 Balance") log(acct1ReceiverRef.balance) log("Account 2 Balance") log(acct2ReceiverRef.balance) // verify that the balances are correct if acct1ReceiverRef.balance != 40.0 || acct2ReceiverRef.balance != 20.0 { panic("Wrong balances!") } // Find the public Receiver capability for their Collections let acct1Capability = acct1.getCapability<&{NonFungibleToken.NFTReceiver}>(/public/NFTReceiver) let acct2Capability = acct2.getCapability<&{NonFungibleToken.NFTReceiver}>(/public/NFTReceiver) // borrow references from the capabilities let nft1Ref = acct1Capability.borrow() ?? panic("Could not borrow acct1 nft receiver reference") let nft2Ref = acct2Capability.borrow() ?? panic("Could not borrow acct2 nft receiver reference") // Print both collections as arrays of IDs log("Account 1 NFTs") log(nft1Ref.getIDs()) log("Account 2 NFTs") log(nft2Ref.getIDs()) // verify that the collections are correct if nft1Ref.getIDs()[0] != 1 as UInt64 || nft2Ref.getIDs().length != 0 { panic("Wrong Collections!") }
}

"Account 1 Vault Balance"
40
"Account 2 Vault Balance"
20
"Account 1 NFTs"
[1]
"Account 2 NFTs"
[]

With the above steps, you can ensure that the Flow Playground is in the correct state to create your NFT marketplace to enable the sale of NFTs between accounts.

Selling NFT on the Marketplace

import FungibleToken from 0x01
import NonFungibleToken from 0x02
// The Marketplace contract is a sample implementation of an NFT Marketplace on Flow.
// This contract allows users to put their NFTs up for sale. Other users
// can purchase these NFTs with fungible tokens.
pub contract Marketplace {
  // Event that is emitted when a new NFT is put up for sale
  pub event ForSale(id: UInt64, price: UFix64)
  // Event that is emitted when the price of an NFT changes
  pub event PriceChanged(id: UInt64, newPrice: UFix64)
  // Event that is emitted when a token is purchased
  pub event TokenPurchased(id: UInt64, price: UFix64)
  // Event that is emitted when a seller withdraws their NFT from the sale
  pub event SaleWithdrawn(id: UInt64)
  // Interface that users will publish for their Sale collection
  // that only exposes the methods that are supposed to be public
  pub resource interface SalePublic {
    pub fun purchase(tokenID: UInt64, recipient: &AnyResource{NonFungibleToken.NFTReceiver}, buyTokens: @FungibleToken.Vault)
    pub fun idPrice(tokenID: UInt64): UFix64?
    pub fun getIDs(): [UInt64]
  }
  // SaleCollection
  // NFT Collection object that allows a user to put their NFT up for sale
  // where others can send fungible tokens to purchase it
  pub resource SaleCollection: SalePublic {
    // Dictionary of the NFTs that the user is putting up for sale
    pub var forSale: @{UInt64: NonFungibleToken.NFT} // Dictionary of the prices for each NFT by ID
    pub var prices: {UInt64: UFix64}
    // The fungible token vault of the owner of this sale.
    // When someone buys a token, this resource can deposit
    // tokens into their account.
    pub let ownerVault: Capability<&AnyResource{FungibleToken.Receiver}>
    init (vault: Capability<&AnyResource{FungibleToken.Receiver}>) {
        self.forSale <- {}
        self.ownerVault = vault
        self.prices = {}
    }
    // withdraw gives the owner the opportunity to remove a sale from the collection
    pub fun withdraw(tokenID: UInt64): @NonFungibleToken.NFT {
        // remove the price
        self.prices.remove(key: tokenID)
        // remove and return the token
        let token <- self.forSale.remove(key: tokenID) ?? panic("missing NFT")
        return <-token
    }
    // listForSale lists an NFT for sale in this collection
    pub fun listForSale(token: @NonFungibleToken.NFT, price: UFix64) {
        let id = Token ID
        // store the price in the price array
        self.prices[id] = price
        // put the NFT into the the forSale dictionary
        let oldToken <- self.forSale[id] <- token         destroy oldToken         emit ForSale(id: id, price: price)     }     // changePrice changes the price of a token that is currently for sale     pub fun changePrice(tokenID: UInt64, newPrice: UFix64) {         self.prices[tokenID] = newPrice         emit PriceChanged(id: tokenID, newPrice: newPrice)     }     // purchase lets a user send tokens to purchase an NFT that is for sale     pub fun purchase(tokenID: UInt64, recipient: &AnyResource{NonFungibleToken.NFTReceiver}, buyTokens: @FungibleToken.Vault) {         pre {             self.forSale[tokenID] != nil && self.prices[tokenID] != nil:                 "No token matching this ID for sale!"             buyTokens.balance >= (self.prices[tokenID] ?? 0.0):
                "Not enough tokens to by the NFT!"
        }
        // get the value out of the optional
        let price = self.prices[tokenID]!
        self.prices[tokenID] = nil     let vaultRef = self.ownerVault.borrow()
            ?? panic("Could not borrow reference to owner token vault")
        // deposit the purchasing tokens into the owners vault
        vaultRef.deposit(from: <-buyTokens)
        // deposit the NFT into the buyers collection
        recipient.deposit(token: <-self.withdraw(tokenID: tokenID))
        emit TokenPurchased(id: tokenID, price: price)
    }
    // idPrice returns the price of a specific token in the sale
    pub fun idPrice(tokenID: UInt64): UFix64? {
        return self.prices[tokenID]
    }
    // getIDs returns an array of token IDs that are for sale
   pub fun getIDs(): [UInt64] {
        return self.forSale.keys
    }
    destroy() {
        destroy self.forSale
    }
  }
  // createCollection returns a new collection resource to the caller  
  pub fun createSaleCollection(ownerVault: Capability<&AnyResource{FungibleToken.Receiver}>): @SaleCollection {
    return <- create SaleCollection(vault: ownerVault)
  }
}

The capability that the marketplace contract stores is:

pub let ownerVault: Capability<&AnyResource{FungibleToken.Receiver}>.

The seller (owner of the sale) saves a capability to their Fungible Token Receiver within the sale, which helps deposit the currency into the owner’s vault once the NFT purchase is made.

The marketplace contract also includes events that are supported by Cadence. Cadence can be used to add or remove events within contracts when important actions/events take place.

pub event ForSale(id: UInt64, price: UFix64)
pub event PriceChanged(id: UInt64, newPrice: UFix64)
pub event TokenPurchased(id: UInt64, price: UFix64)
pub event SaleWithdrawn(id: UInt64)

Testing and Verifying Transactions

import FungibleToken from 0x01
import NonFungibleToken from 0x02
import Marketplace from 0x03
// This transaction creates a new Sale Collection object,
// lists an NFT for sale, puts it in account storage,
// and creates a public capability to the sale so that others can buy the token.
transaction {
  prepare(acct: AuthAccount) {
    // Borrow a reference to the stored Vault
    let receiver = acct.getCapability<&{FungibleToken.Receiver}>(/public/MainReceiver)
    // Create a new Sale object,
    // initializing it with the reference to the owner's vault
    let sale <- Marketplace.createSaleCollection(ownerVault: receiver)
    // borrow a reference to the NFTCollection in storage
    let collectionRef = acct.borrow<&NonFungibleToken.Collection>(from: /storage/NFTCollection)
            ?? panic("Could not borrow a reference to the owner's nft collection")
    // Withdraw the NFT from the collection that you want to sell
    // and move it into the transaction's context
    let token <- collectionRef.withdraw(withdrawID: 1)
    // List the token for sale by moving it into the sale object
    sale.listForSale(token: <-token, price: 10.0)
    // Store the sale object in the account storage
    acct.save<@Marketplace.SaleCollection>(<-sale, to: /storage/NFTSale)
    // Create a public capability to the sale so that others can call its methods
    acct.link<&Marketplace.SaleCollection{Marketplace.SalePublic}>(/public/NFTSale, target: /storage/NFTSale)
    log("Sale Created for account 1. Selling NFT 1 for 10 tokens")
  }
}  

• Creates the SalesCollection in the owner’s vault, storing their vault reference
• Gets a capability for the owner’s vault
• Withdraws the owner’s token from their collection
• Sets the price and lists the token
• Stores the sale in their account storage
• Enables other users to purchase any NFTs for sale by establishing a capability

Step 2:
You need to run a script to check if the sale has been created correctly. For this, open script2.cdc. Click on theExecutebutton to print the ID and price of thw NFT that has been put up on sale by account 0x01

import FungibleToken from 0x01
import NonFungibleToken from 0x02
import Marketplace from 0x03
// This script prints the NFTs that account 0x01 has for sale.
pub fun main() { // Get the public account object for account 0x01 let account1 = getAccount(0x01) // Find the public Sale reference to their Collection let acct1saleRef = account1.getCapability<&AnyResource{Marketplace.SalePublic}>(/public/NFTSale) .borrow() ?? panic("Could not borrow a reference to the sale") // Los the NFTs that are for sale log("Account 1 NFTs for sale") log(acct1saleRef.getIDs()) log("Price") log(acct1saleRef.idPrice(tokenID: 1))
}

The Print output should look something like this:

"Account 1 NFTs for sale"
[1]
"Price"
10

Purchasing the NFT – Buyers

The transaction in Transaction2.cdc can be used by the buyer to purchase the seller’s NFT. Open Transaction2.cdc file and select account 0x02 as the only signer. Click the Send button.

import FungibleToken from 0x01
import NonFungibleToken from 0x02
import Marketplace from 0x03
// This transaction uses the signer's Vault tokens to purchase an NFT
// from the Sale collection of account 0x01.
transaction { // reference to the buyer's NFT collection where they // will store the bought NFT let collectionRef: &AnyResource{NonFungibleToken.NFTReceiver} // Vault that will hold the tokens that will be used to // but the NFT let temporaryVault: @FungibleToken.Vault prepare(acct: AuthAccount) { // get the references to the buyer's fungible token Vault // and NFT Collection Receiver self.collectionRef = acct.borrow<&AnyResource{NonFungibleToken.NFTReceiver}>(from: /storage/NFTCollection) ?? panic("Could not borrow reference to the signer's nft collection") let vaultRef = acct.borrow<&FungibleToken.Vault>(from: /storage/MainVault) ?? panic("Could not borrow reference to the signer's vault") // withdraw tokens from the buyers Vault self.temporaryVault <- vaultRef.withdraw(amount: 10.0) } execute { // get the read-only account storage of the seller let seller = getAccount(0x01) // get the reference to the seller's sale let saleRef = seller.getCapability<&AnyResource{Marketplace.SalePublic}>(/public/NFTSale) .borrow() ?? panic("could not borrow reference to the seller's sale") // purchase the NFT the the seller is selling, giving them the reference // to your NFT collection and giving them the tokens to buy it saleRef.purchase(tokenID: 1, recipient: self.collectionRef, buyTokens: <-self.temporaryVault) log("Token 1 has been bought by account 2!") }
}

What the above transaction can enable-

• Gets the public account object for account 0x01
• Acquires relevant references to the buyer’s stored resources
• Withdraws buyer’s tokens to be used for NFT purchase
• Gets the reference to seller’s public sale
• Calls and executes the purchase function, passing in the tokens and Collection reference
• The Purchase function deposits the purchased NFTs directly into the buyer’s collection.

Running a Script to Verify NFT Purchase

There are two steps to verify that the NFT was purchased correctly and verify the nature of the NFT transaction.

1. Open the Script3.cdc file
2. Click ‘Execute’ button with ‘Script3.cdc’ containing the following code-

import FungibleToken from 0x01
import NonFungibleToken from 0x02
import Marketplace from 0x03
// This script checks that the Vault balances and NFT collections are correct
// for both accounts.
// Account 1: Vault balance = 50, No NFTs
// Account 2: Vault balance = 10, NFT ID=1
pub fun main() { // Get the accounts' public account objects let acct1 = getAccount(0x01) let acct2 = getAccount(0x02) // Get references to the account's receivers // by getting their public capability // and borrowing a reference from the capability let acct1ReceiverRef = acct1.getCapability<&FungibleToken.Vault{FungibleToken.Balance}>(/public/MainReceiver) .borrow() ?? panic("Could not borrow reference to acct1 vault") let acct2ReceiverRef = acct2.getCapability<&FungibleToken.Vault{FungibleToken.Balance}>(/public/MainReceiver) .borrow() ?? panic("Could not borrow reference to acct2 vault") // Log the Vault balance of both accounts and ensure they are // the correct numbers. // Account 0x01 should have 50. // Account 0x02 should have 10. log("Account 1 Balance") log(acct1ReceiverRef.balance) log("Account 2 Balance") log(acct2ReceiverRef.balance) // verify that the balances are correct if acct1ReceiverRef.balance != 50.0 || acct2ReceiverRef.balance != 10.0 { panic("Wrong balances!") } // Find the public Receiver capability for their Collections let acct1Capability = acct1.getCapability<&{NonFungibleToken.NFTReceiver}>(/public/NFTReceiver) let acct2Capability = acct2.getCapability<&{NonFungibleToken.NFTReceiver}>(/public/NFTReceiver) // borrow references from the capabilities let nft1Ref = acct1Capability.borrow() ?? panic("Could not borrow reference to acct1 nft collection") let nft2Ref = acct2Capability.borrow() ?? panic("Could not borrow reference to acct2 nft collection") // Print both collections as arrays of IDs log("Account 1 NFTs") log(nft1Ref.getIDs()) log("Account 2 NFTs") log(nft2Ref.getIDs()) // verify that the collections are correct if nft2Ref.getIDs()[0] != 1 as UInt64 || nft1Ref.getIDs().length != 0 { panic("Wrong Collections!") } // Get the public sale reference for Account 0x01 let acct1SaleRef = acct1.getCapability<&AnyResource{Marketplace.SalePublic}>(/public/NFTSale) .borrow() ?? panic("Could not borrow a reference to the sale") // Print the NFTs that account 0x01 has for sale log("Account 1 NFTs for sale") log(acct1SaleRef.getIDs()) if acct1SaleRef.getIDs().length != 0 { panic("Sale should be empty!") }
}

"Account 1 Vault Balance"
50
"Account 2 Vault Balance"
10
"Account 1 NFTs"
[]
"Account 2 NFTs"
[1]
"Account 1 NFTs for Sale"
[]

The codes for each of the steps, i.e. setting up the marketplace, designing the marketplace, and facilitating transactions from one account to another, can help you create a simple marketplace on Cadence. You can also scale your marketplace further by using the CentralMarketplace.cdc contract.

TL;DR

Это самое длинное эссе в истории Not Boring, поэтому давайте начнем с краткого резюме:

• Dapper Labs, команда создавшая CryptoKitties и NBA Top Shot, разработала блокчейн Flow для решения проблем масштабируемости в Ethereum и поддержки открытых миров;
• Большая часть крипто-сообщества отнеслась к Flow скептически, посчитав его чересчур централизованным;
• Flow хочет привлечь следующий миллиард пользователей, а не бороться за существующих пользователей крипто-пространства;
• Команда проекта пытается решить Трилемму Масштабируемости при помощи времени;
• С момента запуска в конце 2020 года блокчейн постепенно децентрализуется;
• С приобретением Brud, Flow добавит возможности для DAO и удвоит свою ставку на молодых пользователей;
• Экосистема Flow набирает обороты, и впереди у нее очень важные события;
• Flow постепенно формирует одну из самых динамичных экосистем web3;

FLOW price reaction

FLOW opened on June 1, with a trading price of $2.71, reached a monthly high of $2.72, tested a monthly low of $1.17, and closed the month at $1.50. 

Overall, this represents a 44% decrease between the opening and closing price of June. 

What do you think about this subject? Write to us and tell us!

Disclaimer

BeinCrypto strives to provide accurate and up-to-date information, but it will not be responsible for any missing facts or inaccurate information. You comply and understand that you should use any of this information at your own risk. Cryptocurrencies are highly volatile financial assets, so research and make your own financial decisions.

Криптовалюта для “нормис”

Пока я я писал эту статью, я спросил своего приятеля, что он думает о Flow. Потом он спросил о Flow одного из своих друзей, и тот ответил следующее:

Flow — это типа блокчейн для нормис.

В крипто-сообществе это своего рода оскорбление, но давайте займемся несложной математикой.

По состоянию на ноябрь прошлого года существовало около 21 миллиона кошельков MetaMask. Если предположить, что за каждым из них стоит отдельный, реальный человек, это означает, что как минимум 21 миллион пользователей могут подключаться непосредственно к web3.

По оценкам Crypto.com, во всем мире насчитывается примерно 300 миллионов криптопользователей, включая всех держателей биткоинов и пользователей централизованных бирж, таких как Coinbase. Так что давайте остановимся на цифре в 300 миллионов.

Во всем мире насчитывается около 5 миллиардов пользователей Интернета. Для простоты мы сделаем здесь несколько экстремальных допущений:

1. Ни один из сегодняшних трехсот миллионов держателей криптоактивов не использует Flow.
2. Люди, которые действительно неравнодушны к криптовалюте, либо уже являются частью этих 300 миллионов, либо еще слишком молоды.

Это грубые и некорректные предположения, но взятые вместе, они помогают проиллюстрировать суть.

Таким образом, если Flow — это блокчейн для обывателей, у него, похоже, есть все шансы на успех.

Конечно, эта картинка отражает положение дел очень грубо. Многие L1 и L2 слева пытаются сделать web3 дешевле и эффективнее именно для того, чтобы разработчики могли создавать продукты, которые способны привлечь в web3 обычных пользователей из этих 4.7 миллиардов.

Но для того, чтобы не утратить расположение существующих разработчиков и пользователей web3, эти сети, вероятно, не захотят заранее идти на те же компромиссы, что и Flow. Команда Flow, с другой стороны, доказала, что им наплевать насколько “круто” выглядит то, что они делают. Это те же самые люди, которые подарили нам CryptoKitties.

В то время как все остальные конкурируют за существующих криптопользователей, Flow пытается привлечь всех остальных.

Крис Диксон из a16z сказал мне:

Flow играет в совершенно другую игру. Иногда нужно делать ставки на будущее.

Так что, читая эту статью, постарайтесь сфокусироваться на будущем.

Лейн описывет это так:

Мы спроектировали Flow с прицелом на долгосрочное развитие.

Блокчейны станут домом для цифровых городов, и Flow должен предлагать людям то же, что они хотели бы получить, если бы строили город — стабильность, надежность и безопасность, гарантии для строителей, права собственности для владельцев цифровых предметов и активов.

Сегодня при строительстве городов нужно заботиться об окружающей среде, и в этом плане Flow ничем не отличается. Это “экологичный” способ владеть цифровыми активами.

Мы хотим, чтобы это был продукт, рассчитанный на несколько поколений dapps.

Когда вы планируете на десятилетия вперед, нужно принимать нестандартные решения в краткосрочной перспективе.

Например, несмотря на то, что переход к свободному развертыванию проектов на Flow по мнению многих занял бесконечно много времени, полтора года в долгосрочной перспективе — не такой уж большой срок.

По той же причине самые известные на данный момент проекты на Flow, например, Cryptoys, Genies, и Brud, рассчитаны на детей и подростков.

Мне очень нравится одна цитата Патрика Коллисона из Stripe:

Идея о том, чтобы использовать временные горизонты в качестве конкурентного преимущества кажется мне очень глубокой. Вы просто готовы ждать дольше, чем другие, и у вас есть организация, которая ориентирована на долгосрочную цель.

Разобравшись в том, что такое Flow, я увидел ту же идею. Команда Flow готова обменять время и краткосрочный хайп на шанс сделать правильный продукт для миллиардов обычных людей.

Стратегия разумна, и компромиссы имеют смысл, но до тех пор, пока Flow не привлечет свой миллиард пользователей, остаются вопросы.

Вот некоторые из основных:

• Действительно ли большое количество обычных пользователей предпочтет знакомиться с миром web3 через блокчейн-приложения, ориентированные на массового потребителя, а не через более аутентичные продукты?
• Сможет ли проект привлечь так много пользователей, что разработчики обратят на него внимание и будут готовы изучить новый, не совместимый с EVM язык программирования для создания приложений на Flow?
• Смогут ли эти разработчики создать приложения, которые способны удержать пользователей в экосистеме Flow?
• Смогут ли Flow и разработчики в его экосистеме со временем предоставить полноценный опыт работы с web3 тем, кто этого захочет?

И все эти вопросы сводятся к тому, на что делает ставку команда Flow.

Со своим нестандартным подходом — сначала создавая продукт для обычных людей и постепенно децентрализуясь, — сможет ли Flow убить сразу двух зайцев: создать реальные сетевые эффекты и найти решение трилеммы? 

Никто не гарантирует, что они смогут реализовать свою идею — на самом деле Flow сейчас выглядит симпатичным аутсайдером среди блокчейнов, — но внутренняя структура проекта скрывает огромные возможности. К тому же, если и есть команда, которая знает как привлечь в web3 следующий миллиард пользователей, то это Dapper.

General Flow NFT marketplaces

General purpose marketplaces enable NFTs from all kinds of different categories to be bought and sold i.e. avatar, sports, music, art etc.

Gaia Marketplace

Supported Wallet/s: Dapper Wallet

BloctoBay

Supported Wallet/s: Blocto Wallet

BloctoBay is an NFT marketplace built by the creators of Blocto wallet. The BloctoBay marketplace has the broadest range of Flow NFT collections (nearly 30) integrated including popular NFTs such as Matrix World, Chainmonsters, Jambb, NBA Top Shot and more. 

The experience is similar to Opensea in that you directly connect your Flow wallet (Blocto wallet) to their platform to buy and sell NFTs. Unlike most Flow marketplaces, the BloctoBay marketplace is purely for buying and selling NFTs that have already launched — you can’t mint / create NFTs on this platform.

Rarible

Supported Wallet/s: Blocto Wallet

The well-known Ethereum NFT marketplace, Rarible, is also one of the only open marketplaces enabling permissionless NFT minting on Flow. 

Starly

Supported Wallet/s: Blocto Wallet

Starly is a gamified launchpad and marketplace for Flow NFT collections. It enables partnering creators to release Top Shot style NFT packs of their own content end-to-end and makes it easy for creators to reward their most dedicated fans.

Matrix Market

Supported Wallet/s: Blocto Wallet, Lilico, Dapper Wallet (soon)

Matrix Market describes itself as the first all-in-one marketplace for creators, collectors, and traders on Flow.

The marketplace launched recently, with a very Opensea-feel to it enabling anyone to create NFT collections on Flow with collection rankings.

VIV3

Supported Wallet/s: Blocto Wallet

VIV3 was the first general marketplace on Flow and also launched one of the earliest NFT collections, Evolution by Ben Mauro.

The VIV3 marketplace is integrated with multiple Flow NFT collections including NBA Top Shot, Canes Vault, Dark Country, Moto GP Ignition, Vault by CNN, Evolution and Chainmonsters. They also partner with curated artists to drop their own NFTs. Similar to BloctoBay, this marketplace uses the Blocto wallet.

Sturdy Exchange

Supported Wallet/s: Sturdy Exchange Custodial Wallet, Dapper Wallet (coming soon)

Geniace

Supported Wallet/s: Blocto Wallet

Geniace is a curated NFT collectibles marketplace commemorating culture’s icons. They have released collections including Icons of Anime and Icons of Rap with Icons of Extreme Sports coming soon.

Mynft

Supported Wallet/s: Blocto Wallet

Mynft is a platform designed to connect East and West markets. Like Rarible, they are a permissionless marketplace where anyone can mint 1/1 NFTs for a fee of 1 FLOW. Two of their most popular collections released were Cyber Monkeys and Flowns. The marketplace utilises the Blocto wallet. 

Mynft also has a native token, $MY which can be used to vote on creators and earn rewards.

Epix 

Supported Wallet/s: Blocto Wallet

Epix Industries is building a world of collectibles that blends the ownership and authenticity of NFTs with interactive technology and breathtaking visuals. Their marketplace aims to bridge Custodial/Non-custodial — Crypto/Fiat — Digital/Physical and interconnect premium collections, trading cards and game assets in their ecosystem.

So far, Epix has released two collections in their marketplace: Hip Hop Icons and Enemy Metal.

Unblocked

They have not yet launched their secondary marketplace (NFTs cannot be sold yet) and are a fully custodial solution operating their own wallet with payment via debit card. 

Opensea (coming soon)

.find v2 (coming soon)

OpenSea

OpenSea — это первый и крупнейший на данный момент одноранговый NFT-маркетплейс. На момент написания статьи совокупный объем торгов на OpenSea составлял более 6,5 миллиардов долларов (по данным аналитической платформы DappRadar). На площадке вы можете найти самые разные NFT, от игровых предметов и коллекционных вещей, до произведений искусства, музыки, GIF-файлов и многого другого.

Процесс регистрации предельно прост: вам всего лишь необходимо подключить к платформе свой кошелек Metamask. Площадка также поддерживает и другие кошельки, такие как Coinbase Wallet, Bitski и Formatic.

Процесс покупки NFT достаточно прост: вы можете изучить представленные на площадке коллекции или воспользоваться поиском, чтобы найти интересующий вас NFT. Затем вам нужно будет разместить ставку и дождаться подтверждения продавца.

Загрузить на платформу свой NFT также очень просто. Просто перейдите на вкладку “Create” и подключите свой кошелек. Затем вы сможете загрузить свой NFT, заполнить описание и выставить его на продажу.

Nifty Gateway

Nifty Gateway — один из первых крупных NFT-маркетплейсов. В 2019 году платформу приобрела криптовалютная биржа Gemini. Это оказалось дальновидным решением. В феврале 2021, в разгар бума невзаимозаменяемых токенов, площадка Nifty Gateway попала в заголовки СМИ благодаря одной из первых многомилионных продаж NFT — работа CROSSROAD художника Beeple была продана за 6.6 миллионов долларов  К маю совокупная стоимость представленных на площадке товаров достигла 300 миллионов долларов.

CROSSROAD – NFT художника Beeple

Каждые три недели на площадке проходят дропы специально отобранных NFT, включая работы таких артистов как The Weeknd, Граймс и Эминем. На платформе также есть торговая площадка, где вы можете найти отобранные кураторами коллекции, работы верифицированных художников, а также широкий выбор работ авторов, не прошедших верификацию.

Вы также можете привязать к учетной записи Nifty Gateway ваш аккаунт на бирже Gemini. Это позволит вам покупать NFT с вашего баланса на бирже (который можно пополнить с помощью банковского перевода, криптодепозита или посредством торговли на бирже).