O desenvolvedor Christophe Verdot fala sobre o curso online ‘' que ele passou recentemente.
Conte-nos um pouco sobre você. O que te interessou neste curso?
Trabalho com desenvolvimento web há cerca de 15 anos, principalmente como freelancer.
Ao desenvolver uma aplicação web para um registo de longo prazo para países em desenvolvimento para um grupo bancário, deparei-me com a tarefa de integrar a certificação blockchain nela. Naquela época, eu não sabia muito sobre certificação blockchain, embora já estivesse interessado em tecnologias criptográficas, principalmente como investidor.
Com isso, esta função não foi implementada, mas, pensando que organizações e bancos estavam interessados em tal solução para suas aplicações, comecei a estudar o assunto e logo lancei o projeto .
Desenvolvi uma versão beta dele, que já está disponível na rede principal. Naquela época não existia Ride [linguagem de programação Waves], então fiz tudo da maneira mais simples, usando transações de tradução com JSON aninhado. Mas o objetivo principal era adicionar funcionalidades mais avançadas após o lançamento do Ride. E esta é a principal razão pela qual aderi ao curso: a próxima etapa do desenvolvimento do projeto envolveu a criação de uma aplicação descentralizada (dApp).
Quais aspectos do curso você achou mais fáceis e quais foram os mais desafiadores?
O mais simples foi que tínhamos tempo suficiente para todas as tarefas. O objetivo do curso é aprender algo e não competir entre si. As explicações foram muito acessíveis e as ilustrações simples, mas abrangentes. Isso ajudou a visualizar e compreender diferentes tópicos.
Ao completar as tarefas, fomos incentivados a pensar de forma independente e, às vezes, a estudar algo por conta própria. Esta é a melhor maneira de aprender e compreender as ideias abordadas em aula.
Várias vezes eu não entendi completamente a parte teórica até começar a escrever código enquanto concluía uma tarefa. Não tínhamos permissão para copiar/colar, tínhamos que escrever todo o código nós mesmos, e isso também nos ajudou a entender tudo melhor.
O mais difícil foi que as questões da tarefa de múltipla escolha nem sempre eram claras. Meu inglês não é perfeito e as perguntas foram escritas por um falante não nativo, então às vezes havia mal-entendidos.
Talvez a parte do curso dedicada aos oráculos e NFTs pudesse ser mais detalhada. Mas, em qualquer caso, o objetivo principal do curso é interessar os desenvolvedores. Então, para compreender completamente todos os seus aspectos, você precisará, é claro, passar algum tempo experimentando e praticando.
Conte-nos mais sobre a solução que você trabalhou ao longo do curso - 'Coupon Bazaar'? Também posso ver alguns exemplos de código?
Sim, trabalhamos no ‘Coupon Bazaar’, um mercado onde as pessoas vendem e compram cupons que lhes dão o direito de comprar bens e serviços a um preço menor. Cada cupom é representado por um ativo digital que oferece um desconto especial do fornecedor.
Vários componentes de aplicação precisaram ser desenvolvidos. Primeiramente foi necessário criar um sistema de cadastro de fornecedores e gerenciamento de cupons. Então precisávamos de uma função de verificação e da capacidade dos usuários de pesquisar cupons.
Durante o curso também adicionamos vários novos recursos, incluindo um sistema de votação e um recurso que permite verificar e colocar fornecedores na lista negra.
Primeiro, aprendemos a diferença entre ativos inteligentes, contas inteligentes e contas dApp e os princípios básicos de como trabalhar com funções de verificador. As funções do verificador permitem alterar o comportamento padrão da sua conta. Por padrão, eles verificam assinaturas de transações, mas o recurso de verificação permite definir outras “regras”.
{-# STDLIB_VERSION 3 #-}
{-# CONTENT_TYPE DAPP #-}
{-# SCRIPT_TYPE ACCOUNT #-}
letownerPublicKey = base58'H8ndsHjBha6oJBQQx33zqbP5wi8sQP7hwgjzWUv3q95M'
@Verifier(tx)
funcverify() = {
matchtx {
cases: SetScriptTransaction=>sigVerify(tx.bodyBytes, tx.proofs[0], ownerPublicKey)
cased: DataTransaction=>true
case_ =>false
}
}Então começamos a adicionar cupons. Usamos uma das funções mais importantes do dApp, que permite registrar dados de qualquer tipo no blockchain na forma de pares chave-valor - uma transação de dados. Combinamos isso com uma nova transação, InvokeScript, que é usada para chamar uma função que pode ser chamada em um dApp de fora do blockchain.
O tipo de transação de dados que utilizamos durante o curso foi adicionar cupons ao marketplace:
letdatajson = {
"title": "t-shirt with , vote 1",
"coupon_price": 10000000,
"old_price": 1000000000,
"new_price": 100000000,
"address": "Universe",
"description": "I want you to make love, not war, i know you've heard it before",
"image": "https://bit.ly/2EXTghg"
}
it('add item', asyncfunction(){
letts = invokeScript({
dApp: dappAddress,
call:{
function:"addItem",
args:[
{ type:"string", value: datajson.title },
{ type:"integer", value: datajson.coupon_price },
{ type:"string", value: JSON.stringify(datajson) }
]},
payment: []
}, accountSupplierSeed)
lettx = awaitbroadcast(ts)
awaitwaitForTx(tx.id)
})Para processar esses dados com a função addItem e desenvolver a função de compra e outras opções, usamos uma função que pode ser chamada que o usuário pode chamar de fora do blockchain. Como resultado, ele pode realizar diversas tarefas, como iniciar a transferência de fundos, gravar ou atualizar dados no armazenamento de dados do dApp, etc.
Aqui está um exemplo da função chamada usada na função addItem:
@Callable(i)
funcaddItem(title: String, price: Int, data: String) = {
letsupplierAddress = toBase58String(i.caller.bytes)
letitem = getKeyItem(supplierAddress, title)
if( price <= 0) thenthrow("purchase amount cannot be less than item price")
elseif( getValueItemSupplier(item) !=NONE ) thenthrow("an item is already exist")
else{
WriteSet([
DataEntry(getKeyItemSupplier(item), supplierAddress),
DataEntry(getKeyItemPrice(item), price),
DataEntry(getKeyItemData(item), data)
])
}
}Posteriormente, desenvolvemos um sistema de votação que permite votar para promover ou remover determinados produtos. Para evitar influência externa no processo de votação, utiliza o esquema 'Commit-Reveal'.
A fase “commit” é usada para coletar os votos criptografados usando uma função hash e um “salt”.
A fase de “revelação” é usada para coletar votos criptografados e comparar seus hashes.
Aqui está um exemplo da função chamada usada aqui:
@Callable(i)
funcvoteCommit(item: String, hash: String) = {
letuser = toBase58String(i.caller.bytes)
letcommits = getValueCommitsCount(item)
letstatus = getValueItemStatus(item)
if( commits >=VOTERS) thenthrow("reached max num of voters")
elseif(getValueCommit(item, user) !=NONE) thenthrow("user has already participated")
elseif(getKeyItemSupplier(item) ==NONE) thenthrow("item does not exist")
elseif(status !=NONE && status !=VOTING) thenthrow("voting is not possible")
else{
WriteSet([
DataEntry(getKeyCommit(item, user), hash),
DataEntry(getKeyCommitsCount(item), commits +1),
DataEntry(getKeyItemStatus(item),if(commits ==VOTERS) thenREVEAL elseVOTING)
])
}
}
>O que mais você aprendeu com o curso?
O curso também incluiu tokenização e tokens não fungíveis (NFTs) – tokens que representam algo único e, portanto, não são fungíveis.
A última lição foi dedicada aos oráculos. Como o blockchain não pode receber dados do mundo exterior, precisamos de oráculos para enviar esses dados para ele.
Para o nosso marketplace, eram necessários oráculos para verificar e, se necessário, colocar na lista negra um fornecedor que, por exemplo, não aceitasse um cupom vendido.
Aqui está um exemplo:
funcgetExtValueItemWhiteListStatus(item:String) = {
item +"_verifier_status"
}
letverifier = "3Mx9qgMyMhHt7WUZr6PsaXNfmydxMG7YMxv"
letVERIFIED = "verified"
letBLACKLISTED = "blacklist"
@Callable(i)
funcsetstatus(supplier: String, status: String) = {
letaccount = toBase58String(i.caller.bytes)
if( account !=verifier ) thenthrow("only oracle verifier are able to manage whitelist")
elseif( status !=VERIFIED && status !=BLACKLISTED) thenthrow("wrong status")
else{
WriteSet([
DataEntry(getExtValueItemWhiteListStatus(supplier), status)
])
}
}
Qual foi a coisa mais útil para você?
A parte mais útil são as atribuições. Graças a eles, o material da palestra ficou mais claro e o conhecimento recém-adquirido foi consolidado por tentativa e erro. Trabalho prático com , и .
Como você planeja colocar em prática o que aprendeu?
Desde o início, esperava que o curso ajudasse a levar meu projeto para o próximo nível. A ideia era agora escrever o código no passeio. A versão existente já possui funções de certificação de documentos, mas graças ao RIDE pode ser significativamente melhorada. A nova versão será mais flexível e intuitiva, e terá mais funcionalidades, incluindo certificação de e-mails, acordos multipartidários, etc.
O curso também foi instigante e me deu muitas ideias novas. Estou confiante de que os resultados continuarão a aparecer no futuro.
Fonte: habr.com
