Habrahabr blockchain: Blockchain / Хабр

Blockchain на Go. Часть 1: Прототип / Хабр

Содержание

1. Blockchain на Go. Часть 1: Прототип
2. Blockchain на Go. Часть 2: Proof-of-Work
3. Blockchain на Go. Часть 3: Постоянная память и интерфейс командной строки
4. Blockchain на Go. Часть 4: Транзакции, часть 1
5. Blockchain на Go. Часть 5: Адреса
6. Blockchain на Go. Часть 6: Транзакции, часть 2
7. Blockchain на Go. Часть 7: Сеть

Блокчейн одна из самых революционных технологий 21 века, до сих пор не реализовавшая весь свой потенциал. По сути, блокчейн это просто распределенная база данных. Что же делает ее уникальной? Это база данных полностью открыта и хранится у каждого участника полной или частичной копией. Новая запись создается только с согласия всех кто хранит базу. Благодаря этому существуют такие вещи как криптовалюта и умные контракты.

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

Блок

Начнем с «блока» части «блокчейна». В блокчейне, блоки хранят полезную информацию. Например, в bitcoin блоки хранят транзакции, суть любой криптовалюты. Помимо полезной информации, в блоке содержится служебная информация: версия, дата создания в виде timestamp и хеш предыдущего блока. В этой статье мы будем создавать упрощенный блок, содержащий только существенную информацию. Опишем его в виде go структуры.

type Block struct {
    Timestamp     int64
    Data          []byte
    PrevBlockHash []byte
    Hash          []byte
}

Timestamp это время создания блока, Data это полезная информация, содержащаяся в блоке, PrevBlockHash хранит хэш предыдущего блока, и наконец, Hash содержит хэш блока. В спецификации bitcoin Timestamp, PrevBlockHash и Hash образуют заголовок блока и образуют отдельную от транзакций (в нашем случае это Data) структуру. Мы же смешали их для простоты.

Как вычисляется хэши? Вычисление хэшей одна из важных свсойств блокчейна, благодаря ему он считается безопасным. Все потому, что вычисление хэша это довольно сложная операция (именно поэтому майнеры покупали мощные видеокарты, для добычи биткойна). Это было задумано специально, предотвращая от изменения всей цепочки.

Обсудим это в следующей статье, а сейчас мы просто соеденим все поля блока и захэшируем результат в SHA-256:

func (b *Block) SetHash() {
    timestamp := []byte(strconv.FormatInt(b.Timestamp, 10))
    headers := bytes.Join([][]byte{b.PrevBlockHash, b.Data, timestamp}, []byte{})
    hash := sha256.Sum256(headers)
    b.Hash = hash[:]
}

Далее, создадим «конструктор» для нашего блока

func NewBlock(data string, prevBlockHash []byte) *Block {
    block := &Block{time.Now().Unix(), []byte(data), prevBlockHash, []byte{}}
    block.SetHash()
    return block
}

Блок готов!

Блокчейн

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

В Golang эта структура может быть реализована с помощью массива (array) и карты (map): массив будет содержать упорядоченный список хэшей (массивы упорядоченны в Go), а карты будут хранить пары hash -> block (карты не упорядочены). Но для нашего прототипа, мы будем использовать только массивы потому, что нам не требуется получать блок по его хэшу.

type Blockchain struct {
    blocks []*Block
}

Это наш первый блокчейн! Никогда не думал, что это так просто 🙂

Добавим возможность добавлять блоки в него.

func (bc *Blockchain) AddBlock(data string) {
    prevBlock := bc.blocks[len(bc.blocks)-1]
    newBlock := NewBlock(data, prevBlock.Hash)
    bc.blocks = append(bc. blocks, newBlock)
}

Чтобы добавить первый блок, нам нужен существующий, но наш блокчейн пуст! Таким образом нам в любом блокчейне должен быть как минимум один блок, который называют genesis блоком. Реализуем метод, создающий такой блок.

func NewGenesisBlock() *Block {
    return NewBlock("Genesis Block", []byte{})
}

А теперь реализуем функцию создающую блокчейн с genesis блоком.

func NewBlockchain() *Blockchain {
    return &Blockchain{[]*Block{NewGenesisBlock()}}
}

Давайте проверим, что блокчейн работает корректно

func main() {
    bc := NewBlockchain()
    bc.AddBlock("Send 1 BTC to Ivan")
    bc.AddBlock("Send 2 more BTC to Ivan")
    for _, block := range bc.blocks {
        fmt.Printf("Prev. hash: %x\n", block.PrevBlockHash)
        fmt.Printf("Data: %s\n", block.Data)
        fmt.Printf("Hash: %x\n", block.Hash)
        fmt.Println()
    }
}

Этот код выведет

Prev. hash:
Data: Genesis Block
Hash: aff955a50dc6cd2abfe81b8849eab15f99ed1dc333d38487024223b5fe0f1168
Prev.  hash: aff955a50dc6cd2abfe81b8849eab15f99ed1dc333d38487024223b5fe0f1168
Data: Send 1 BTC to Ivan
Hash: d75ce22a840abb9b4e8fc3b60767c4ba3f46a0432d3ea15b71aef9fde6a314e1
Prev. hash: d75ce22a840abb9b4e8fc3b60767c4ba3f46a0432d3ea15b71aef9fde6a314e1
Data: Send 2 more BTC to Ivan
Hash: 561237522bb7fcfbccbc6fe0e98bbbde7427ffe01c6fb223f7562288ca2295d1

Наш прототип работает!

Заключение

Мы только что построили очень простой прототип блокчейна: простого массива блоков, каждый из которых связан с предыдущим. Настоящий блокчейн намного сложнее. Наш блокчейн добавляет новые блоки очень легко и быстро, в реальном же блокчейне добавление новых блоков требует определенной работы: выполнение сложных вычислений, перед получением права на добавления блока (этот механизм называется Prof-of-Work). Кроме того, блокчейн — распределенная база, которая не имеет единого центра принятия решения. Таким образом, новый блок должен быть подтвержден и одобрен другими участниками сети (данный механизм называется консенсусом). Ну и собственно у нас пока нет самих транзакций.

Все эти свойства мы рассмотрим в будущих статьях.

Ссылки

Исходный код для статьи.

Сетевое взаимодействие — Написание blockchain менее чем за 200 строк кода на Go / Habr

Вы прочитали первую часть из этой серии? Если нет, то стоит взглянуть. Не волнуйся, мы подождем…

Добро пожаловать!

Мы были ошеломлены обратной связью от нашего первого поста: «Написание blockchain менее чем за 200 строк кода на Go». То, что предназначалось для небольшого урока для начинающих разработчиков по blockchain, приобрело новую жизнь. Нас завалили запросами сделать пост, где мы добавляем сетевое взаимодействие.

Прежде чем начнем, вы можете присоединиться к нашему чату в Telegram! Это лучшее место, что бы задать нам вопросы, дать отзывы и попросить новые уроки. Если вы нуждаетесь в помощи с вашим кодом, то это идеальное место, что бы спросить!

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

Рабочий процесс

• Первый терминал создает первый базовый блок и TCP сервер, к которому могут подключаться новые ноды.

Шаг 1

• Открываются дополнительные терминалы и TCP соединения с первым терминалом
• Новый терминал записывает блок на первый терминал

Шаг 2

• Первый терминал проверяет блок
• Первый терминал рассылает новую цепочку блоков каждой новой ноде

Шаг 3

• Все терминалы синхронизированы!

После урока попробуйте сделать сами: каждый новый терминал, так же выступает в качестве «первых» терминалов, но с различными TCP портами и каждый с каждым имеет соединения для правильной работы сети.

Что вы сможете сделать

• Запустите терминал, который обеспечивает первый базовый блок
• Запустите множество новых дополнительных терминалов, сколько хотите и пусть они запишут блоки в первый терминал
• Первый терминал должен рассылать обновленные блоки для новых терминалов

Что вы не сможете сделать

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

Давайте начнем кодить!

Местами будет обзор предыдущего поста. Оставим множество функций, таких как генерация блоков, хэширование, проверка. Функционал HTTP использовать не будем, а просматривать результат будем в консоли, а для работы по сети будем использовать TCP.

Какие различия между TCP и HTTP?

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

Установка, импорты и обзор

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

Установка

Создайте .env файл в вашей главной директории и добавьте строку:

ADDR=9000

Сохраняем номер порта TCP, который хотим использовать (в нашем случае 9000) в переменной окружения под названием ADDR.

Если вы еще этого не сделали, установите следующие пакеты:

go get github.com/davecgh/go-spew/spew

для красивой печати нашей цепочки блоков в консоль

go get github.com/joho/godotenv

для чтения переменных из нашего .env файла.

Создайте пустой main.go файл. Там расположим наш код.

Импорты

Декларация пакета и необходимые нам импорты:

package main
import (
    "bufio"
    "crypto/sha256"
    "encoding/hex"
    "encoding/json"
    "io"
    "log"
    "net"
    "os"
    "strconv"
    "time"
    "github. com/davecgh/go-spew/spew"
    "github.com/joho/godotenv"
)

Обзор

Следующие фрагменты кода хорошо описаны в первой части.

Давайте создадим нашу Block структуру и объявим слайс блоков, это и будет наша цепочка блоков.

type Block struct {
    Index     int
    Timestamp string
    BPM       int
    Hash      string
    PrevHash  string
}
var Blockchain []Block

Объявим так же нашу функцию хэширования, которая понадобится нам при создании новых блоков.

func calculateHash(block Block) string {
    record := string(block.Index) + block.Timestamp + string(block.BPM) + block.PrevHash
    h := sha256.New()
    h.Write([]byte(record))
    hashed := h.Sum(nil)
    return hex.EncodeToString(hashed)
}

И функция создания блоков:

func generateBlock(oldBlock Block, BPM int) (Block, error) {
    var newBlock Block
    t := time.Now()
    newBlock.Index = oldBlock.Index + 1
    newBlock.Timestamp = t.String()
    newBlock. BPM = BPM
    newBlock.PrevHash = oldBlock.Hash
    newBlock.Hash = calculateHash(newBlock)
    return newBlock, nil
}

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

func isBlockValid(newBlock, oldBlock Block) bool {
    if oldBlock.Index+1 != newBlock.Index {
        return false
    }
    if oldBlock.Hash != newBlock.PrevHash {
        return false
    }
    if calculateHash(newBlock) != newBlock.Hash {
        return false
    }
    return true
}

Теперь гарантируем, что возьмем самую длинную цепочку, как правильную:

func replaceChain(newBlocks []Block) {
    if len(newBlocks) > len(Blockchain) {
        Blockchain = newBlocks
    }
}

Замечательно! Получили основной функционал по работе с цепочкой блоков. Теперь можем перейти к созданию взаимодействия по сети.

Сетевое взаимодействие

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

Начнем с функции main, но перед этим давайте объявим глобальную переменную bcServer, которая является каналом принимающим входящие блоки.

var bcServer chan []Block

Примечание: Каналы являются одним из наиболее популярных инструментов в Go и обеспечивает красивую реализацию чтения/записи данных и чаще всего используется для предотвращения состояния гонки. Они становятся мощным инструментом, когда несколько Go-рутин конкурентно (не путать с параллельностью) пишут в один и тот же канал. Обычно в Java и других C-подобных языках вам придется блокировать и разблокировать мьютекс для доступа к данным. Каналы в Go делают это намного проще, хотя в Go так же есть и мьютексы. Можете подробнее почитать об этом тут.

Теперь давайте объявим нашу функцию main и загрузим переменные окружения из нашего файла .env, который находится в корневом каталоге. А так же запустим экземпляр нашего bcServer в функции main.

func main() {
   err := godotenv. Load()
   if err != nil {
       log.Fatal(err)
   }
   bcServer = make(chan []Block)
   // create genesis block
   t := time.Now()
   genesisBlock := Block{0, t.String(), 0, "", ""}
   spew.Dump(genesisBlock)
   Blockchain = append(Blockchain, genesisBlock)
}

Теперь нам необходимо создать TCP сервер. Помните, что TCP серверы похожи на HTTP серверы, но для работы с браузером протокола TCP недостаточно. Все данные будут отображаться через консоль. Будем обрабатывать несколько соединений с нашим TCP портом. Добавим это к нашей функции main:

server, err := net.Listen("tcp", ":"+os.Getenv("ADDR"))
    if err != nil {
        log.Fatal(err)
    }
    defer server.Close()

Этот код запустит наш TCP сервер на порту 9000. Важно выполнить defer server.Close(), что бы соединение закрылось, когда больше нет необходимости в нем. Почитать подробнее про defer можно тут.

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

for {
    conn, err := server.Accept()
    if err != nil {
        log.Fatal(err)
    }
    go handleConn(conn)
}

Создаем бесконечный цикл, в котором принимаем новые соединения. Для конкурентной обработки, каждое соединение запускаем в обработчике в Go рутине go handleConn(conn), поэтому не останавливаем наш цикл. Таким образом можем одновременно слушать несколько соединений конкурентно.

Внимательный читатель заметит, что функция обработчик handleConn не объявлена. Мы пока что создали нашу основную функцию main. Целиком она выглядит так:

func main() {
    err := godotenv.Load()
    if err != nil {
        log.Fatal(err)
    }
    bcServer = make(chan []Block)
    // create genesis block
    t := time.Now()
    genesisBlock := Block{0, t.String(), 0, "", ""}
    spew.Dump(genesisBlock)
    Blockchain = append(Blockchain, genesisBlock)
    // start TCP and serve TCP server
    server, err := net.Listen("tcp", ":"+os. Getenv("ADDR"))
    if err != nil {
        log.Fatal(err)
    }
    defer server.Close()
    for {
        conn, err := server.Accept()
        if err != nil {
            log.Fatal(err)
        }
        go handleConn(conn)
    }
}

Давайте теперь напишем нашу функцию handleConn. Она принимает только один аргумент, это интерфейс net.Conn. На наш взгляд, интерфейсы в Go поразительны и они отличают его от всех C-подобный языков. Конкурентность и Go рутины рекламируют язык, но интерфейсы и тот факт, что они могут реализовывать интерфейс не явно, является самой мощной функцией языка. Если вы еще не используете интерфейсы в Go, ознакомитесь с ними как только сможете. Интерфейсы это ваш следующий шаг, для становления как Go разработчика.

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

func handleConn(conn net.Conn) {
    defer conn.Close()
}

Теперь нам нужно разрешить клиенту добавлять новые блоки в цепочку. Для данных будем использовать частоту пульса, как в первой части. Замерьте свой пульс в течение минуты и запомните это число. Это будет параметр BPM (beats per minute)

Для реализации вышеуказанного нам необходимо:

• попросить клиента ввести свой BPM
• запросить это значение у клиента через stdin
• создать новый блок с этими данными, используя функции generateBlock, isBlockValid и replaceChain
• положить новую цепочку блоков в канал, созданный ранее для передачи по сети
• разрешить клиенту вводить новое значение BMP

Код, который реализует выше описанный функционал:

io.WriteString(conn, "Enter a new BPM:")
scanner := bufio.NewScanner(conn)
go func() {
    for scanner.Scan() {
        bpm, err := strconv.Atoi(scanner.Text())
        if err != nil {
            log.Printf("%v not a number: %v", scanner.Text(), err)
            continue
        }
        newBlock, err := generateBlock(Blockchain[len(Blockchain)-1], bpm)
        if err != nil {
            log. Println(err)
            continue
        }
        if isBlockValid(newBlock, Blockchain[len(Blockchain)-1]) {
            newBlockchain := append(Blockchain, newBlock)
            replaceChain(newBlockchain)
        }
        bcServer <- Blockchain
        io.WriteString(conn, "\nEnter a new BPM:")
    }
}()

Создаем новый сканер. for scanner.Scan() это цикл, который работает конкурентно в Go рутине и отдельно от других соединений. Делаем быстрое строковое преобразование значения BMP (которое всегда будет типом integer, поэтому проверяем его). Выполняем стандартную генерацию блока, проверка блока на валидность и добавление нового блока в цепочку.

Синтаксис bcServer <- Blockchain просто означает, что мы бросаем нашу новую цепочку в канал, который создали ранее. Затем предлагаем клиенту ввести новое значение BPM для создания следующего блока.

Широковещательный канал

Нам необходимо разослать новую цепочку блоков для всех соединений на нашем TCP сервере. Поскольку мы программируем на одном компьютере, нам надо имитировать, как данные будет передаваться всем клиентам. В функцию handleConn нам необходимо добавить:

• конвертацию нашей цепочки блоков в JSON формат, что она была удобочитаемой
• запись новой цепочки блоков в консоль для каждого из соединений
• установка таймаута периодичности, что бы наша цепочка блоков не спамила постоянно. В существующих системах это происходит каждый X минут. Будем использовать 30 секунд
• вывод основной цепочку блоков на первом терминале, что бы мы могли видеть, что происходит. Так мы убедимся, что блоки добавляемые различными нодами, действительно интегрируются в основную цепочку блоков

Вот код, выполняющий все в нужном порядке:

go func() {
    for {
        time.Sleep(30 * time.Second)
        output, err := json.Marshal(Blockchain)
        if err != nil {
            log.Fatal(err)
        }
        io.WriteString(conn, string(output))
    }
}()
for _ = range bcServer {
    spew. Dump(Blockchain)
}

Замечательно! Наша функция handleConn готова. Фактически вся программа готова и мы сохранили ее компактность в 200 строк кода. Это неплохо, не так ли?

Целиком со всем кодом, можно ознакомиться тут!

Интересный материал

Давайте перейдем в директорию с нашим кодом и запустим нашу программу, выполнив: go run main.go

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

Откройте новое окно терминала и подключитесь к нашему TCP серверу с помощью nc localhost 9000. Будем использовать разный цвет в терминалах, что бы было понятно, что это разные клиенты. Сделайте это несколько раз с разными сеансами терминала, что бы запустить несколько клиентов.

Теперь введите BPM на любом из клиентов. Видим, что новый блок добавлен в первый терминал! Сеть работает!

Ждем 30 секунд. Перейдите к одному из других клиентов, и вы увидите, что новая цепочка блоков передалась всем клиентам, даже если эти клиенты никогда не вводили BPM!

Следующие шаги

Поздравляем! Вы не только создали свой собственный blockchain из последнего урока, но и добавили сетевое взаимодействие. Теперь есть несколько направлений для того, что бы двигаться дальше:

• что бы получить большую сеть, работающую локально, создайте несколько каталогов, в которых хранится копия приложения. Каждая копия должна иметь разные TCP-порты. Для каждого сеанса терминала слушайте порт TCP и подключайтесь к другому, что бы вы могли получать и отправлять ваши данные.
• Объединяйте данные, полученные с нескольких портов. Это тема для другого урока, но это делается легко. Все это blockchain. Он должен принимать данные, а также передавать данные.
• Вы можете попробовать это с друзьями, настройте сервер в облаке, используя ваш любимый хостинг-провайдер. Попросите ваших друзей подключиться к нему и отправить данные. На данном этапе можно добавить немного безопасности. Если будут запросы, то мы сделаем учебник по этому материалу.
  
  Вы уже понимаете множество аспектов blockchain. Рекомендуем почитать алгоритмы наподобие Proof of Work или Proof of Stake.
  
  Или можете просто подождать, пока мы напишем новое сообщение в блоге 🙂
  
  Напомним, что бы сообщить нам, что вы хотите увидеть, присоединяйтесь к нашему Telegram чату! Возможно, вы сможете поменять наше мнение о том, что написать в дальнейших уроках. Можете подписаться на наш Twitter так же.
  
  Чтобы узнать больше о Coral Health и о том, как мы используем blockchain в исследовательской работе по медицине, можете посетить наш сайт.

P.S. Автор перевода будет благодарен за указанные ошибки и неточности перевода.

IBM Blockchain — корпоративные решения и услуги блокчейна

Обеспечьте надежный обмен данными и автоматизацию рабочих процессов за пределами границ с помощью технологии распределенного реестра и блокчейна.

Обзор

Добейтесь оперативной гибкости с доверием

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

Преимущества

Блокчейн-решения

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

Записаться на консультацию

Тематические исследования

• Рено
• IPwe
• Фермер Коннект
• электронное происхождение
• Сеть поставщиков морепродуктов Atea
• Голден Стэйт Фудс
• Лигон
• Хоум Депо

Рено

Фермер Коннект

электронное происхождение

Сеть поставщиков морепродуктов Atea

Голден Стэйт Фудс

Хоум Депо

Блокчейн для промышленности

Ресурсы

Следующие шаги

Свяжитесь с экспертом по блокчейну

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

Записаться на консультацию

Сноски

¹ Hyperledger Fabric — это проект Linux Foundation с открытым исходным кодом.

Как блокчейн меняет индустрию развлечений — вопросы и ответы с EarnTV

В постоянно развивающемся мире развлечений конвергенция технологий «смотри, чтобы зарабатывать» и блокчейна меняет способ потребления пользователями медиаконтента и взаимодействия с ним. Это динамичное слияние предлагает ряд возможностей: от вознаграждения зрителей за время, потраченное на просмотр, до создания прозрачных и децентрализованных экосистем.

Эти возможности вдохновили Паскаля Валлата, опытного профессионала в области маркетинга и цифровых медиа, на создание EarnTV, платформы, целью которой является революционный подход к потреблению и взаимодействию пользователей с медиаконтентом.

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

Cointelegraph: Можете ли вы начать с рассказа о своем путешествии в индустрию цифровых медиа и линейного телевидения и о том, как это повлияло на ваше решение запустить EarnTV?

Паскаль Валлат: Имея 20-летний опыт работы в области маркетинга, данных, телевидения и цифровых медиа, я своими глазами видел, как развивается отрасль. Развитие стриминга и растущий спрос на персонализированный контент вдохновили меня на создание EarnTV. Я увидел возможность улучшить впечатления от просмотра, вознаградить зрителей и расширить возможности создателей контента с помощью технологий блокчейна и Web3. EarnTV — это мое видение преодоления разрыва между зрителями, владельцами контента и рекламодателями, создание справедливой и полезной экосистемы для всех.

CT: Как бы вы описали переход от традиционных моделей к технологиям Web3 и блокчейн в индустрии медиа и развлечений?

PV: Переход от традиционных моделей к технологиям Web3 и блокчейна носит преобразующий характер. Это обеспечивает прозрачность, децентрализацию и новые возможности для продюсеров, правообладателей, ведущих студий и зрителей. Блокчейн обеспечивает неизменность записей, а смарт-контракты обеспечивают справедливое распределение вознаграждений, а токенизация открывает новые формы обмена ценностями. Этот сдвиг расширяет возможности отдельных лиц, устраняет посредников и обеспечивает прямое взаимодействие между создателями и потребителями. Он открывает двери для инновационных моделей монетизации, персонализированного опыта и более инклюзивного медиа- и развлекательного ландшафта.

CT: Не могли бы вы объяснить, как платформа EarnTV использует технологию блокчейн для преобразования опыта просмотра для пользователей?

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

Источник: EarnTV

CT: Недавно вы объявили о предпродаже токенов ETV. Можете ли вы рассказать нам больше об этом и о том, что это значит для будущего EarnTV?

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

CT: Можете ли вы объяснить концепцию Watch to Earn? Чем это предложение отличает EarnTV от других платформ?

PV: Смотреть, чтобы заработать — это основная концепция EarnTV, которая отличает нас от других платформ. Проще говоря, зрители награждаются токенами ETV за время, которое они тратят на просмотр фильмов, телешоу и быстрых каналов премиум-класса. Этот инновационный подход признает ценность внимания зрителей и превращает его в ощутимую награду. В отличие от традиционных платформ, EarnTV напрямую приносит пользу своим пользователям, создавая привлекательную и полезную экосистему, которая стимулирует просмотр и формирует сильное сообщество энтузиастов контента. Мы запустили EarnTV на всех устройствах с 2000 часов контента и 200 премиальных быстрых каналов. Время, потраченное на просмотр контента, вознаграждается служебным токеном ETV.

CT: Что такое киноклуб ETV NFT? Можете ли вы объяснить, как это работает и какие преимущества для зрителей?

PV: Киноклуб ETV NFT — захватывающая функция EarnTV. Он предлагает зрителям эксклюзивный доступ к курируемым фильмам и предварительным показам с помощью невзаимозаменяемых токенов (NFT). Члены киноклуба ETV NFT могут получить ранний доступ к долгожданным фильмам и принять участие в захватывающих впечатлениях, связанных с кино. Участвуя в клубе, зрители получают привилегии и становятся частью эксклюзивного сообщества любителей кино. Для нас это способ вознаградить наших пользователей незабываемыми кинематографическими впечатлениями и способствовать более глубокой связи с индустрией развлечений.

CT: С какими ключевыми проблемами вы столкнулись при развертывании протокола доставки видеоконтента на основе блокчейна и как вы их преодолели?

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

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

CT: Учитывая динамичный характер отрасли, как вы видите будущее EarnTV и роль технологии блокчейна в медиа и развлечениях?

PV: Яркое будущее EarnTV обусловлено нашей приверженностью инновациям и преобразующим потенциалом технологии блокчейн. Мы предполагаем, что EarnTV расширит возможности зрителей, владельцев контента и рекламодателей и станет ведущим межплатформенным протоколом доставки видеоконтента.

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

CT: Наконец, не могли бы вы поделиться какими-либо предстоящими функциями или планами, которых пользователи должны с нетерпением ждать на EarnTV?

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